Source: js/activity_window.js

  1. /* global AppWindow, BrowserFrame, Service */
  2. 'use strict';
  4. (function(exports) {
  5.   var _id = 0;
  7.   /**
  8.    * ActivityWindow is the wrapper for the inline activity instances.
  9.    * For window disposition activity, they are done in AppWindow.
  10.    *
  11.    * ##### Flow chart
  12.    * ![ActivityWindow flow](http://i.imgur.com/4O1Frs3.png)
  13.    *
  14.    * @example
  15.    * var app = new AppWindow({
  16.    *   url: 'http://uitest.gaiamobile.org:8080/index.html',
  17.    *   manifestURL: 'http://uitest.gaiamobile.org:8080/manifest.webapp'
  18.    * });
  19.    * var activity = new ActivityWindow({
  20.    *   url: 'http://gallery.gaiamobile.org:8080/pick.html',
  21.    *   manifestURL: 'http://gallery.gaiamobile.org:8080/manifest.webapp'
  22.    * }, app);
  23.    *
  24.    * @class ActivityWindow
  25.    * @param {Object} config The configuration object of this activity.
  26.    * @param {AppWindow|ActivityWindow} caller The caller of this activity.
  27.    */
  28.   /**
  29.    * Fired when the activity window is created.
  30.    * @event ActivityWindow#activitycreated
  31.    */
  32.   /**
  33.    * Fired when the activity window is removed.
  34.    * @event ActivityWindow#activityterminated
  35.    */
  36.   /**
  37.    * Fired when the activity window is opening.
  38.    * @event ActivityWindow#activityopening
  39.    */
  40.   /**
  41.    * Fired when the activity window is opened.
  42.    * @event ActivityWindow#activityopen
  43.    */
  44.   /**
  45.    * Fired when the activity window is cloing.
  46.    * @event ActivityWindow#activityclosing
  47.    */
  48.   /**
  49.    * Fired when the activity window is closed.
  50.    * @event ActivityWindow#activityclose
  51.    */
  52.   /**
  53.    * Fired before the activity window is rendered.
  54.    * @event ActivityWindow#activitywillrender
  55.    */
  56.   /**
  57.    * Fired when the activity window is rendered to the DOM tree.
  58.    * @event ActivityWindow#activityrendered
  59.    */
  60.   /**
  61.    * Fired when the page visibility of the activity window is
  62.    * changed to foreground.
  63.    * @event ActivityWindow#activityforeground
  64.    */
  65.   /**
  66.    * Fired when the page visibility of the activity window is
  67.    * changed to background.
  68.    * @event ActivityWindow#activitybackground
  69.    */
  70.   var ActivityWindow = function ActivityWindow(config, caller) {
  71.     this.config = config;
  72.     for (var key in config) {
  73.       this[key] = config[key];
  74.     }
  76.     if (caller) {
  77.       caller.setFrontWindow(this);
  78.       this.rearWindow = caller;
  79.       if (caller.element) {
  80.         this.containerElement = caller.element;
  81.       }
  82.     }
  84.     this.publish('creating');
  85.     this.render();
  86.     this.publish('created');
  87.   };
  89.   ActivityWindow.prototype = Object.create(AppWindow.prototype);
  91.   ActivityWindow.prototype.constructor = ActivityWindow;
  93.   ActivityWindow.prototype.eventPrefix = 'activity';
  95.   ActivityWindow.prototype.CLASS_NAME = 'ActivityWindow';
  97.   /**
  98.    * Turn on this flag to dump debugging messages for all activity windows.
  99.    * @type {Boolean}
  100.    */
  101.   ActivityWindow.prototype._DEBUG = false;
  103.   ActivityWindow.prototype.openAnimation = 'fade-in';
  104.   ActivityWindow.prototype.closeAnimation = 'fade-out';
  106.   /**
  107.    * ActivityWindow's fullscreen state is copying from the caller
  108.    * instead of reading manifest so we just overwrite the
  109.    * isFullScreen method of AppWindow.
  110.    *
  111.    * @return {Boolean} The activity window is fullscreen or not.
  112.    */
  113.   ActivityWindow.prototype.isFullScreen = function acw_isFullScreen() {
  114.     if (typeof(this._fullscreen) !== 'undefined') {
  115.       return this._fullscreen;
  116.     }
  118.     this._fullscreen = (this.manifest && !!this.manifest.fullscreen) ?
  119.                        !!this.manifest.fullscreen :
  120.                        this.rearWindow ?
  121.                        this.rearWindow.isFullScreen() :
  122.                        false;
  123.     return this._fullscreen;
  124.   };
  126.   /**
  127.    * Lock or unlock orientation for this activity.
  128.    */
  129.   ActivityWindow.prototype.lockOrientation =
  130.     function acw_lockOrientation(noCapture) {
  131.       if (this.isActive()) {
  132.         var orientation1 = (this.manifest) ?
  133.                             this.manifest.orientation : null;
  134.         var orientation2 = (this.config.manifest) ?
  135.                             this.config.manifest.orientation : null;
  136.         var orientation3 = (this.rearWindow.manifest) ?
  137.                             this.rearWindow.manifest.orientation : null;
  138.         var orientation4 = Service.query('globalOrientation');
  140.         var orientation = orientation1 ||
  141.                           orientation2 ||
  142.                           orientation3 ||
  143.                           orientation4;
  145.         if (orientation) {
  146.           var rv = false;
  147.           if ('lockOrientation' in screen) {
  148.             rv = screen.lockOrientation(orientation);
  149.           } else if ('mozLockOrientation' in screen) {
  150.             rv = screen.mozLockOrientation(orientation);
  151.           }
  152.           if (rv === false) {
  153.             console.warn('screen.mozLockOrientation() returned false for',
  154.                          this.origin, 'orientation', orientation);
  155.           }
  156.         } else {  // If no orientation was requested, then let it rotate
  157.           if ('unlockOrientation' in screen) {
  158.             screen.unlockOrientation();
  159.           } else if ('mozUnlockOrientation' in screen) {
  160.             screen.mozUnlockOrientation();
  161.           }
  162.         }
  163.       }
  164.     };
  166.   ActivityWindow.prototype.view = function acw_view() {
  167.     this.instanceID = this.CLASS_NAME + '_' + _id;
  168.     _id++;
  169.     return `<div id="${this.instanceID}"
  170.             class="appWindow activityWindow inline-activity">
  171.             <div class="fade-overlay"></div>
  172.             <div class="browser-container">
  173.              <div class="screenshot-overlay"></div>
  174.             </div>
  175.             </div>`;
  176.   };
  178.   ActivityWindow.SUB_COMPONENTS = {
  179.     'transitionController': 'AppTransitionController',
  180.     'modalDialog': 'AppModalDialog',
  181.     'valueSelector': 'ValueSelector',
  182.     'authDialog': 'AppAuthenticationDialog',
  183.     'childWindowFactory': 'ChildWindowFactory',
  184.     'statusbar': 'AppStatusbar'
  185.   };
  187.   ActivityWindow.SUB_MODULES = {
  188.     'contextmenu': 'BrowserContextMenu'
  189.   };
  191.   ActivityWindow.REGISTERED_EVENTS = AppWindow.REGISTERED_EVENTS;
  193.   ActivityWindow.prototype._handle_mozbrowseractivitydone =
  194.     function aw__handle_mozbrowseractivitydone() {
  195.       this.kill();
  196.     };
  198.   ActivityWindow.prototype.render = function acw_render() {
  199.     this.publish('willrender');
  200.     this.containerElement.insertAdjacentHTML('beforeend', this.view());
  201.     // TODO: Use BrowserConfigHelper.
  202.     this.browser_config = {
  203.       parentApp: this.parentApp,
  204.       origin: this.origin,
  205.       url: this.url,
  206.       name: this.name,
  207.       manifest: this.manifest,
  208.       manifestURL: this.manifestURL,
  209.       window_name: 'inline' + this.instanceID,
  210.       oop: true
  211.     };
  212.     this.browser = new BrowserFrame(this.browser_config);
  213.     this.element =
  214.       document.getElementById(this.instanceID);
  216.     this.browserContainer = this.element.querySelector('.browser-container');
  217.     this.browserContainer.appendChild(this.browser.element);
  218.     this.frame = this.element;
  219.     this.iframe = this.browser.element;
  220.     this.screenshotOverlay = this.element.querySelector('.screenshot-overlay');
  221.     this.fadeOverlay = this.element.querySelector('.fade-overlay');
  223.     // Copy fullscreen state from caller.
  224.     if (this.isFullScreen()) {
  225.       this.element.classList.add('fullscreen-app');
  226.     }
  228.     this._registerEvents();
  229.     this.installSubComponents();
  230.     this.publish('rendered');
  231.   };
  233.   /**
  234.    * ActivityWindow's default container is '#windows'.
  235.    * However, we could dynamically change this in layout manager
  236.    * after it recieves the activitywillrender event.
  237.    */
  238.   ActivityWindow.prototype.containerElement =
  239.     document.getElementById('windows');
  241.   /**
  242.    * Bringing ourselves up. To do so we simply do
  243.    * requestOpen() the original caller app window instance.
  244.    * Note: this overrides AppWindow.prototype.requestOpen().
  245.    */
  246.   ActivityWindow.prototype.requestOpen = function acw_requestOpen() {
  247.     if (this.rearWindow) {
  248.       this.rearWindow.requestOpen();
  249.     }
  250.   };
  252.   /**
  253.    * Request to close. We don't need to reset the visibility of
  254.    * the bottom window here so we simply close.
  255.    * Note: this overrides AppWindow.prototype.requestClose().
  256.    */
  257.   ActivityWindow.prototype.requestClose = function acw_requestOpen() {
  258.     this.close();
  259.   };
  261.   exports.ActivityWindow = ActivityWindow;
  263. }(window));