Xinwen Deng / aem-src

/*
 * ADOBE CONFIDENTIAL
 *
 * Copyright 2016 Adobe Systems Incorporated
 * All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 */

/**
 * The service admin is a singleton that offers a global registry for name based services.
 *
 * @module screens/player/shared/serviceadmin
 */
define('screens/player/shared/serviceadmin', ['underscore', 'eventemitter'], function(_, EventEmitter) {
    'use strict';

    /**
     * @typedef STATE
     */
    var STATE = Object.freeze({
        INVALID: 0,
        REGISTERED: 1,
        STARTING: 2,
        STARTED: 3,
        STOPPING: 4,
        STOPPED: 5,
        ABORTED: 6
    });

    var EVENTS = Object.freeze({

        /**
         * Event when service admin was started.
         * @event serviceadmin-started
         */
        SERVICE_ADMIN_STARTED: 'serviceadmin-started',

        /**
         * Event when service admin was stopped.
         * @event serviceadmin-stopped
         */
        SERVICE_ADMIN_STOPPED: 'serviceadmin-stopped',

        /**
         * Event when a service was registered
         * @event service-registered
         */
        SERVICE_REGISTERED: 'service-registered',

        /**
         * Event when a service is starting
         * @event service-starting
         */
        SERVICE_STARTING: 'service-starting',

        /**
         * Event when a service was started
         * @event service-started
         */
        SERVICE_STARTED: 'service-started',

        /**
         * Event when a service is stopping
         * @event service-stopping
         */
        SERVICE_STOPPING: 'service-stopping',

        /**
         * Event when a service was stopped
         * @event service-stopped
         */
        SERVICE_STOPPED: 'service-stopped',

        /**
         * Event when a service was aborted
         * @event service-aborted
         */
        SERVICE_ABORTED: 'service-aborted'

    });


    /**
     * Comparator for Service Entries.
     * @param {number} s1 left entry to compare
     * @param {number} s2 right entry to compare
     * @returns {number} the comparison result
     */
    function RANK_COMPARATOR(s1, s2) {
        return s2.rank - s1.rank;
    }

    /**
     * Creates a service entry processor that transitions the service from the current to a final state
     * @param {STATE} transientState the state the service gets during transition
     * @param {STATE} finalState the final state
     * @param {STATE} errorState the error state
     * @param {String} funcName Name of the transition function. eg 'activate'.
     * @returns {Function} the transition function processor
     * @see ServiceAdmin#start
     * @see ServiceAdmin#stop
     * @private
     */
    function createSvcEntryProcessor(transientState, finalState, errorState, funcName) {
        return function processSvcEntry(entry) {
            entry.state = transientState;

            if (!_.isFunction(entry.svc[funcName])) {
                entry.state = finalState;
                entry.completedActivation = Promise.resolve();
                return entry.completedActivation;
            }
            var p = entry.svc[funcName]();
            if (!p || !p.then || !_.isFunction(p.then)) {
                p = Promise.resolve();
            }
            entry.completedActivation = p.then(function() {
                entry.state = finalState;
            }, function() {
                entry.state = errorState;
            });
            return entry.completedActivation;
        };
    }

    /**
     * The service admin.
     *
     * @classdesc Simple service admin
     * @class ServiceAdmin
     * @singleton
     * @extends EventEmitter
     */
    var ServiceAdmin = function() {

        /**
         * Array of entries of all registered services.
         * @type {Array}
         * @private
         */
        var _services = [];

        /**
         * Map from service names to service entries
         * @type {Object}
         * @private
         */
        var _servicesByName = {};

        /**
         * Indicates if the service admin was started
         * @type {boolean}
         * @private
         */
        var _started = false;

        /**
         * Indicates if the service admin starting is currently in progress
         * @type {boolean}
         * @private
         */
        var _isStarting = false;

        /**
         * internal function that returns the list of service entries for a given name.
         * @param {String} name Service name
         * @param {boolean} create If true, create the list if missing.
         * @returns {Array} Array of service entries
         * @private
         */
        function _getServiceList(name, create) {
            var list = _servicesByName[name];
            if (!list) {
                if (!create) {
                    return null;
                }
                list = _servicesByName[name] = [];
            }
            return list;
        }

        function _addEntryToServices(entry, serviceNames) {
            _services.push(entry);

            // register service names
            _.each(serviceNames, function(name) {
                var list = _getServiceList(name, true);
                list.push(entry);
                list.sort(RANK_COMPARATOR);

                // in case the service admin is already started
                // the service will need to get started if the priority matches
                if (_started) {
                    createSvcEntryProcessor(
                        STATE.STARTING, STATE.STARTED, STATE.ABORTED, 'activate'
                    )(entry);
                }
            });
        }

        return _.create(EventEmitter.prototype, _.assign({'_super': EventEmitter.prototype},
            /** @lends module:screens/player/shared/serviceadmin.ServiceAdmin.prototype */ {

            /**
             * Registers a new service. The name can be optional, but can also be provisioned with {@link Service#name}
             * @param {Service} service The service to register
             * @param {String|Array} [names] optional name(s) of services
             */
            register: function(service, names) {
                var self = this;
                // sanitize service names
                var serviceNames = Array.prototype.concat([], names || service.serviceName || 'anonymous' + _.now());

                // check if service is already registered
                if (_.find(_services, function(info) {
                        return info.svc === service;
                    })) {
                    throw new Error('service already registered: ', serviceNames);
                }

                // check if service with same id already exists
                if (service.serviceId && _.find(_services, function(info) {
                        return info.svc && (info.svc.serviceId === service.serviceId);
                    })) {
                    throw new Error('service with same id already registered: ', service.serviceId);
                }

                // create service entry and remember it
                var entry = {
                    svc: service,
                    rank: service.serviceRanking || 0
                };

                // observe state changes with a property
                var _state;
                Object.defineProperty(entry, 'state', {
                    get: function() {
                        return _state;
                    },
                    set: function(val) {
                        var s = _.invert(STATE);
                        if (s[val]) {
                            _state = val;
                            self.emit(EVENTS['SERVICE_' + s[val]], {
                                state: val,
                                service: this.svc
                            });
                        }
                    }
                });
                entry.state = STATE.REGISTERED;

                if (_isStarting) {
                    this.on(EVENTS.SERVICE_ADMIN_STARTED, function(data) {
                        _addEntryToServices(entry, serviceNames);
                    });
                } else {
                    _addEntryToServices(entry, serviceNames);
                }
            },

            /**
             * Enables to execute a function once a service is started.
             * The function is called every time the given service is started.
             * @param {String} name Name of the service to wait for
             * @param {Function} callback to be executed
             */
            onServiceStart: function(name, callback) {
                var svc = this.getService(name);

                if (svc) {
                    callback(svc);
                }

                this.on(EVENTS.SERVICE_STARTED, function(data) {
                    if (data.service.serviceName === name || data.service.serviceName.indexOf(name) > -1) {
                        callback(data.service);
                    }
                });
            },

            /**
             * Enables to execute a function once the highest ranked service is started.
             * The function is called every time the highest ranked service changed
             * @param {String} name Name of the service to wait for
             * @param {Function} callback to be executed
             */
            onServiceHighestRankedStart: function(name, callback) {
                var self = this;

                function always(promise, cb) {
                    return promise.then(cb, cb);
                }

                this.onServiceStart(name, function(service) {

                    // we need to make sure that not a higher ranked service
                    // is still booting
                    var services = _getServiceList(name);

                    // gather all higher ranked services
                    // and wait for them to finish their transition
                    var promiseChain = Promise.resolve();

                    _.every(services, function(entry) {
                        if (entry.svc === service) {
                            return false;
                        }

                        var nextPromise = function() {
                            return entry.completedActivation;
                        };

                        promiseChain = always(promiseChain, nextPromise);

                        return true;
                    });

                    // when this callback is called then all services
                    // have completed their transition
                    always(promiseChain, function() {
                        var highestRank = self.getService(name);
                        if (highestRank === service) {
                            callback(service);
                        }
                    });
                });
            },

            /**
             * Returns the state of the service with the given name.
             * @param {String} name Name of the service state to retrieve
             * @returns {Number} Service state
             */
            getServiceState: function(name) {
                var list = _getServiceList(name);
                if (!list || list.length === 0) {
                    return STATE.INVALID;
                }
                return list[0].state;
            },

            /**
             * Returns the best service with the given name that is started.
             * @param {String} name Name of the service state to retrieve
             * @returns {Service} the service
             */
            getService: function(name) {
                var e = _.find(_getServiceList(name), function(entry) {
                    return entry.state === STATE.STARTED;
                });
                return e ? e.svc : null;
            },

            /**
             * Returns the array of service with the given name that are started.
             * @param {String} name Name of the service state to retrieve
             * @returns {Array} the service list
             */
            getServices: function(name) {
                var services = [];
                _.each(_getServiceList(name), function(entry) {
                    if (entry.state === STATE.STARTED) {
                        services.push(entry.svc);
                    }
                });
                return services;
            },

            /**
             * Starts the service admin and call the {@link Service#activate} method on all registered services.
             * @return {Promise} a promise that resolves when all services are started.
             */
            start: function() {
                var self = this;
                _isStarting = true;
                var transitionProcessor = createSvcEntryProcessor(
                    STATE.STARTING, STATE.STARTED, STATE.ABORTED, 'activate'
                );
                return Promise.all(_.map(_services, transitionProcessor)).then(function() {
                    _isStarting = false;
                    _started = true;
                    self.emit(EVENTS.SERVICE_ADMIN_STARTED);
                });
            },

            /**
             * Stops the service admin and calls the {@link Service#deactivate} method on all activated services
             * @return {Promise} a promise that resolves when all services are stopped.
             */
            stop: function() {
                var self = this;
                var transitionProcessor = createSvcEntryProcessor(
                    STATE.STOPPING, STATE.STOPPED, STATE.ABORTED, 'deactivate'
                );
                return Promise.all(_.map(_services, transitionProcessor)).then(function() {
                    _started = false;
                    self.emit(EVENTS.SERVICE_ADMIN_STOPPED);
                });
            },

            /**
             * Creates a new pristine service admin instance that does not conflict with the globally
             * exported one. Mainly used for testing.
             *
             * @returns {ServiceAdmin} a new service admin instance.
             */
            noConflict: function() {
                var serviceAdmin = new ServiceAdmin();
                serviceAdmin.STATE = STATE;
                serviceAdmin.EVENTS = EVENTS;
                return serviceAdmin;
            }

        }));
    };

    var _instance = new ServiceAdmin();
    _instance.STATE = STATE;
    _instance.EVENTS = EVENTS;
    return _instance;

});