Source: js/secure_window_factory.js

  1. /* -*- Mode: js; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
  2. /* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
  3. 'use strict';
  5. (function(exports) {
  7.   /**
  8.    * To delegate the ownership of apps out of other components,
  9.    * so we can keep our components clean, and only hold minimal
  10.    * parts they should know. The user should only need to know
  11.    * how to create a SecureWindow app via the `create` method in
  12.    * this factory.
  13.    *
  14.    * @constructor SecureWindowFactory
  15.    */
  16.   var SecureWindowFactory = function() {
  17.     this.initEvents();
  18.   };
  20.   SecureWindowFactory.prototype = {
  21.     /**
  22.      * @memberof SecureWindowFactory#
  23.      * @prop {object} apps - would hold spawned apps and release them
  24.      *                       while they got terminated.
  25.      */
  26.     states: {
  27.       apps: {}
  28.     },
  30.     /**
  31.      * @memberof SecureWindowFactory#
  32.      */
  33.     configs: {
  34.       listens: ['secure-launchapp',
  35.                 'secure-appterminated',
  36.                 'secure-modeon',
  37.                 'secure-modeoff']
  38.     }
  39.   };
  41.   /**
  42.    * Hook listeners of events this factory interested in.
  43.    *
  44.    * @private
  45.    * @this {SecureWindowFactory}
  46.    * @memberof SecureWindowFactory
  47.    */
  48.   SecureWindowFactory.prototype.initEvents =
  49.     function swf_initEvents() {
  50.       this.configs.listens.forEach((function _initEvent(type) {
  51.         self.addEventListener(type, this);
  52.       }).bind(this));
  53.     };
  55.   /**
  56.    * Remove listeners of events this factory interested in.
  57.    *
  58.    * @private
  59.    * @this {SecureWindowFactory}
  60.    * @memberof SecureWindowFactory
  61.    */
  62.   SecureWindowFactory.prototype.suspendEvents =
  63.     function swf_suspendEvents() {
  64.       this.configs.listens.forEach((function _unbind(ename) {
  65.         self.removeEventListener(ename, this);
  66.       }).bind(this));
  67.     };
  69.   /**
  70.    * Remove event listeners except the resuming (`secure-modeon`)
  71.    * event.
  72.    *
  73.    * @private
  74.    * @this {SecureWindowFactory}
  75.    * @memberof SecureWindowFactory
  76.    */
  77.   SecureWindowFactory.prototype.suspend =
  78.     function swf_suspend() {
  79.       this.suspendEvents();
  80.       self.addEventListener('secure-modeon', this);
  81.       for (var origin in this.states.apps) {
  82.         this.unregisterApp(this.states.apps[origin]);
  83.       }
  84.     };
  86.   /**
  87.    * Hook event listeners back and don't care the resuming
  88.    * (`secure-modeon`) event anymore.
  89.    *
  90.    * @private
  91.    * @this {SecureWindowFactory}
  92.    * @memberof SecureWindowFactory
  93.    */
  94.   SecureWindowFactory.prototype.resume =
  95.     function swf_resume() {
  96.       this.initEvents();
  98.       // To prevent duplicated init.
  99.       self.removeEventListener('secure-modeon', this);
  100.     };
  102.   /**
  103.    * @listens secure-launchapp - launch app by URL and manifest URL.
  104.    * @listens secure-modeon - the system would be in the secure mode by locking
  105.    *                          or other reasons.
  106.    * @listens secure-modeoff - the system now is not in the secure mode anymore.
  107.    * @listens secure-appterminated - when a secure app got really closed, it
  108.    *                                 would fire this event.
  109.    * @memberof SecureWindowFactory
  110.    */
  111.   SecureWindowFactory.prototype.handleEvent =
  112.     function(evt) {
  113.       switch (evt.type)
  114.       {
  115.         case 'secure-launchapp':
  116.           var {appURL, appManifestURL} = evt.detail;
  117.           this.create(appURL, appManifestURL);
  118.           break;
  119.         case 'secure-appterminated':
  120.           var app = evt.detail;
  121.           this.unregisterApp(app);
  122.           break;
  123.         case 'secure-modeoff':
  124.           this.suspend();
  125.           break;
  126.         case 'secure-modeon':
  127.           this.resume();
  128.           break;
  129.       }
  130.     };
  132.   /**
  133.    * Create a SecureWindow app.
  134.    *
  135.    * @param {URL} url - the app's URL
  136.    * @param {URL} manifestURL - the URL of the app's manifest
  137.    * @this {SecureWindowFactory}
  138.    * @memberof SecureWindowFactory
  139.    */
  140.   SecureWindowFactory.prototype.create =
  141.     function(url, manifestURL) {
  142.       var config = new self.BrowserConfigHelper({
  143.         url: url,
  144.         manifestURL: manifestURL
  145.       });
  146.       for (var instanceID in this.states.apps) {
  147.         var secureWindow = this.states.apps[instanceID];
  148.         if (config.manifestURL === secureWindow.manifestURL) {
  149.           secureWindow.cancelSoftKill();
  150.           secureWindow.open();
  151.           return;  // Already created.
  152.         }
  153.       }
  154.       var app = new self.SecureWindow(config);
  155.       app.open();
  156.       this.registerApp(app);
  157.     };
  159.   /**
  160.    * @private
  161.    * @this {SecureWindowFactory}
  162.    * @memberof SecureWindowFactory
  163.    */
  164.   SecureWindowFactory.prototype.registerApp =
  165.     function(app) {
  166.       this.states.apps[app.instanceID] = app;
  167.     };
  169.   /**
  170.    * @private
  171.    * @this {SecureWindowFactory}
  172.    * @memberof SecureWindowFactory
  173.    */
  174.   SecureWindowFactory.prototype.unregisterApp =
  175.     function(app) {
  176.       delete this.states.apps[app.instanceID];
  177.     };
  179.   /** @exports SecureWindowFactory */
  180.   exports.SecureWindowFactory = SecureWindowFactory;
  181. })(self);