Source: js/activity_window_manager.js

  1. /* global Service */
  2. 'use strict';
  3. (function(exports) {
  4.   /**
  5.    * ActivityWindowManager manages the activity window instances.
  6.    *
  7.    * Currently it's only responsible to kill an existing
  8.    * activity window if the next creating instance has the same
  9.    * manifestURL + pageURL.
  10.    *
  11.    * @class ActivityWindowManager
  12.    */
  13.   function ActivityWindowManager() {
  14.   }
  15.   ActivityWindowManager.prototype = {
  16.     /**
  17.      * The list of all current running activity window instances.
  18.      * @access private
  19.      * @type {Array}
  20.      * @memberof ActivityWindowManager.prototype
  21.      */
  22.     _activities: [],
  24.     /**
  25.      * Register all event handlers.
  26.      * @memberof ActivityWindowManager.prototype
  27.      */
  28.     start: function acwf_start() {
  29.       if (this._started) {
  30.         return;
  31.       }
  32.       this._started = true;
  34.       this.activityPool = new Map();
  35.       window.addEventListener('activityopened', this);
  36.       window.addEventListener('popupopened', this);
  37.       window.addEventListener('appopened', this);
  38.       window.addEventListener('activityrequesting', this);
  39.       window.addEventListener('activitycreated', this);
  40.       window.addEventListener('activityterminated', this);
  41.     },
  43.     /**
  44.      * Unregister all event handlers.
  45.      * @memberof ActivityWindowManager.prototype
  46.      */
  47.     stop: function acwf_stop() {
  48.       if (!this._started) {
  49.         return;
  50.       }
  51.       this._started = false;
  53.       this.activityPool = null;
  54.       window.removeEventListener('activityopened', this);
  55.       window.removeEventListener('popupopened', this);
  56.       window.removeEventListener('appopened', this);
  57.       window.removeEventListener('activityrequesting', this);
  58.       window.removeEventListener('activitycreated', this);
  59.       window.removeEventListener('activityterminated', this);
  60.     },
  62.     /**
  63.      * Put all window ID which is involved in an activity here.
  64.      * XXX: This is a workaround of bug 931339.
  65.      * @type {Map}
  66.      */
  67.     activityPool: null,
  69.     /**
  70.      * Activity Config
  71.      * @typedef {Object} ActivityConfig
  72.      * @property {String} manifestURL The manifestURL of the activity
  73.      * @property {String} url The URL of the activity handling page
  74.      * @property {Boolean} isActivity
  75.      * @property {Boolean} inline The disposition of the activty is inline
  76.      *                            or not
  77.      */
  79.     handleEvent: function acwf_handleEvent(evt) {
  80.       switch (evt.type) {
  81.         // XXX: Workaround of bug 931339.
  82.         // We are maintaining only one chain of activities here
  83.         // in this.activityPool.
  84.         // If the next coming activity request does not belong
  85.         // to the previous pool,
  86.         // kill all the background inline activities.
  87.         case 'popupopened':
  88.         case 'activityopened':
  89.         case 'appopened':
  90.           var app = evt.detail;
  91.           var parent = app.callerWindow ||
  92.                         app.bottomWindow ||
  93.                         app.previousWindow;
  94.           if (parent && this.activityPool.has(parent.instanceID)) {
  95.             // We don't really care about the instance context,
  96.             // so we set the value to a boolean.
  97.             this.activityPool.set(app.instanceID, true);
  98.           }
  99.           break;
  100.         case 'popupterminated':
  101.         case 'appterminated':
  102.           this.activityPool.delete(app.instanceID);
  103.           break;
  104.         case 'activityrequesting':
  105.           // The request may come from the top most window
  106.           // or the system app, but we don't care here.
  107.           var caller = Service.query('getTopMostWindow');
  108.           if (!this.activityPool.size) {
  109.             this.activityPool.set(caller.instanceID, true);
  110.           } else {
  111.             if (!this.activityPool.has(caller.instanceID)) {
  112.               // A new request from a new chain,
  113.               // kill all the background.
  114.               this._activities.forEach(function iterator(activity, index) {
  115.                 if (!activity.getBottomMostWindow().isActive() ||
  116.                     !activity.isActive()) {
  117.                   activity.kill();
  118.                 }
  119.               }, this);
  120.               this.activityPool.clear();
  121.               this.activityPool.set(caller.instanceID, true);
  122.             }
  123.           }
  124.           break;
  126.         case 'activityterminated':
  127.           this._activities.some(function iterator(activity, index) {
  128.             if (activity.instanceID === evt.detail.instanceID) {
  129.               this._activities.splice(index, 1);
  130.               return true;
  131.             }
  132.           }, this);
  133.           this.activityPool.delete(evt.detail.instanceID);
  134.           break;
  136.         case 'activitycreated':
  137.           this._activities.push(evt.detail);
  138.           break;
  139.       }
  140.     }
  141.   };
  143.   exports.ActivityWindowManager = ActivityWindowManager;
  144. }(window));