Source: panels/hotspot/hotspot.js

  1. /**
  2.  * Hotspot is a singleton that you can easily use it to fetch
  3.  * some shared data across different panels
  4.  *
  5.  * @module Hotspot
  6.  */
  7. define(function(require) {
  8.   'use strict';
  10.   // modules / helpers
  11.   var SettingsListener = require('shared/settings_listener');
  13.   const RE_ENABLE_WIFI_TETHERING_TIME = 1000;
  15.   var Hotspot = function() {
  16.     this._settings = navigator.mozSettings;
  17.   };
  19.   /**
  20.    * @alias module:hotspot/hotspot
  21.    * @requires module:hotspot/hotspot_settings
  22.    * @returns {Hotspot}
  23.    */
  24.   Hotspot.prototype = {
  25.     /**
  26.      * Wifi hotspot setting
  27.      *
  28.      * @memberOf Hotspot
  29.      * @type {Boolean}
  30.      */
  31.     _hotspotSetting: null,
  32.     /**
  33.      * Usb hotspot setting
  34.      *
  35.      * @memberOf Hotspot
  36.      * @type {Boolean}
  37.      */
  38.     _usbHotspotSetting: null,
  39.     /**
  40.      * Usb storage setting
  41.      *
  42.      * @memberOf Hotspot
  43.      * @type {Boolean}
  44.      */
  45.     _usbStorageSetting: null,
  46.     /**
  47.      * These listeners would be called when hotspot setting is changed
  48.      *
  49.      * @memberOf Hotspot
  50.      * @type {Array}
  51.      */
  52.     _hotspotChangeListeners: [],
  54.     /**
  55.      * These listeners would be called when usb hotspot setting is changed
  56.      *
  57.      * @memberOf Hotspot
  58.      * @type {Array}
  59.      */
  60.     _usbHotspotChangeListeners: [],
  62.     /**
  63.      * These listeners would be called when usb storage setting is changed
  64.      *
  65.      * @memberOf Hotspot
  66.      * @type {Array}
  67.      */
  68.     _usbStorageChangeListeners: [],
  70.     /**
  71.      * These listeners would be called when incompatibles settings are
  72.      * enabled at the same time
  73.      *
  74.      * @memberOf Hotspot
  75.      * @type {Array}
  76.      */
  77.     _incompatibleSettingsListeners: [],
  79.     /**
  80.      * Wifi tethering setting key
  81.      *
  82.      * @access public
  83.      * @memberOf Hotspot
  84.      * @type {String}
  85.      */
  86.     tetheringWifiKey: 'tethering.wifi.enabled',
  88.     /**
  89.      * Usb tethering setting key
  90.      *
  91.      * @access public
  92.      * @memberOf Hotspot
  93.      * @type {String}
  94.      */
  95.     tetheringUsbKey: 'tethering.usb.enabled',
  97.     /**
  98.      * Usb storage setting key
  99.      *
  100.      * @access public
  101.      * @memberOf Hotspot
  102.      * @type {String}
  103.      */
  104.     usbStorageKey: 'ums.enabled',
  106.     /**
  107.      * Init is used to initialize some basic stuffs
  108.      *
  109.      * @memberOf Hotspot
  110.      */
  111.     init: function h_init() {
  112.       this._bindEvents();
  113.     },
  115.     /**
  116.      * We will bind some default listeners here
  117.      *
  118.      * @memberOf Hotspot
  119.      */
  120.     _bindEvents: function() {
  121.       // Wifi tethering enabled
  122.       SettingsListener.observe(this.tetheringWifiKey, false,
  123.         this._hotspotSettingChange.bind(this));
  125.       // USB tethering enabled
  126.       SettingsListener.observe(this.tetheringUsbKey, false,
  127.         this._usbHotspotSettingChange.bind(this));
  129.       // USB storage enabled
  130.       SettingsListener.observe(this.usbStorageKey, false,
  131.         this._usbStorageSettingChange.bind(this));
  132.     },
  134.     /**
  135.      * When wifi hotspot is changed, we will call all registered listeners
  136.      *
  137.      * @memberOf Hotspot
  138.      */
  139.     _hotspotSettingChange: function(enabled) {
  140.       this._hotspotSetting = enabled;
  141.       this._hotspotChangeListeners.forEach(function(listener) {
  142.         listener(enabled);
  143.       });
  144.     },
  146.     /**
  147.      * When usb hotspot is changed, we will call all registered listeners
  148.      *
  149.      * @memberOf Hotspot
  150.      */
  151.     _usbHotspotSettingChange: function(enabled) {
  152.       this._usbHotspotSetting = enabled;
  153.       this._usbHotspotChangeListeners.forEach(function(listener) {
  154.         listener(enabled);
  155.       });
  156.     },
  158.     /**
  159.      * When usb storage is changed, we will call all registered listeners
  160.      *
  161.      * @memberOf Hotspot
  162.      */
  163.     _usbStorageSettingChange: function(enabled) {
  164.       this._usbStorageSetting = enabled;
  165.       this._usbStorageChangeListeners.forEach(function(listener) {
  166.         listener(enabled);
  167.       });
  168.     },
  170.     /**
  171.      * When two incompatible settings are enabled we will call all
  172.      * registered listeners.
  173.      *
  174.      * @param bothConflicts Indicates that usb hotspot has the two
  175.      * possible conflicts (wifi hotspot and usb storage)
  176.      *
  177.      * @memberOf Hotspot
  178.      */
  179.     _incompatibleSettings: function(newSetting, oldSetting, bothConflicts) {
  180.       this._incompatibleSettingsListeners.forEach(function(listener) {
  181.         listener(newSetting, oldSetting, bothConflicts);
  182.       });
  183.     },
  185.     /**
  186.      * Check if two incompatible settings are enabled
  187.      *
  188.      * @memberOf Hotspot
  189.      */
  190.     checkIncompatibleSettings: function(newSetting, value) {
  191.       switch(newSetting) {
  192.         case this.tetheringWifiKey:
  193.           // Early return if the user has disabled the setting
  194.           if (!value) {
  195.             this._setWifiTetheringSetting(value);
  196.             return;
  197.           }
  199.           if (value && this._usbHotspotSetting) {
  200.             this._incompatibleSettings(this.tetheringWifiKey,
  201.               this.tetheringUsbKey, false);
  202.           } else {
  203.             this._setWifiTetheringSetting(value);
  204.           }
  205.           break;
  206.         case this.tetheringUsbKey:
  207.           // Early return if the user has disabled the setting or the
  208.           // incompatible settings are disabled
  209.           if (!value || (!this._hotspotSetting && !this._usbStorageSetting)) {
  210.             this._setUsbTetheringSetting(value);
  211.             return;
  212.           }
  213.           if (this._usbStorageSetting && this._hotspotSetting) {
  214.             this._incompatibleSettings(this.tetheringUsbKey, null, true);
  215.           } else {
  216.             var oldSetting = this._usbStorageSetting ? this.usbStorageKey :
  217.               this.tetheringWifiKey;
  218.             this._incompatibleSettings(this.tetheringUsbKey, oldSetting, false);
  219.           }
  220.           break;
  221.       }
  222.     },
  224.     reEnableWifiTetheringSetting: function() {
  225.       if (!this.wifiHotspotSetting) {
  226.         return;
  227.       }
  229.       // The time is used to avoid the quick changes on the toggle that may
  230.       // cause bad user experience.
  231.       this._setWifiTetheringSetting(false);
  232.       setTimeout(() => {
  233.         this._setWifiTetheringSetting(true);
  234.       }, RE_ENABLE_WIFI_TETHERING_TIME);
  235.     },
  237.     /**
  238.      * This is an internal function that can help us find out the matched
  239.      * callback from catched listeners and remove it
  240.      *
  241.      * @memberOf Hotspot
  242.      * @param {Array} listeners
  243.      * @param {Function} callback
  244.      */
  245.     _removeEventListener: function(listeners, callback) {
  246.       var index = listeners.indexOf(callback);
  247.       if (index >= 0) {
  248.         listeners.splice(index, 1);
  249.       }
  250.     },
  252.     /**
  253.      * This is an internal function that set a value to the
  254.      * Wifi tethering setting
  255.      *
  256.      * @memberOf Hotspot
  257.      * @param {Boolean} Setting value
  258.      */
  259.     _setWifiTetheringSetting: function(value) {
  260.       var cset = {};
  261.       cset[this.tetheringWifiKey] = value;
  262.       this._settings.createLock().set(cset);
  263.     },
  265.     /**
  266.      * This is an internal function that set a value to the
  267.      * Usb tethering setting
  268.      *
  269.      * @memberOf Hotspot
  270.      * @param {Boolean} Setting value
  271.      */
  272.     _setUsbTetheringSetting: function(value) {
  273.       var cset = {};
  274.       cset[this.tetheringUsbKey] = value;
  275.       this._settings.createLock().set(cset);
  276.     },
  278.     addEventListener: function(eventName, callback) {
  279.       if (eventName === 'incompatibleSettings') {
  280.         this._incompatibleSettingsListeners.push(callback);
  281.       } else if (eventName === 'wifiHotspotChange') {
  282.         this._hotspotChangeListeners.push(callback);
  283.       } else if (eventName === 'usbHotspotChange') {
  284.         this._usbHotspotChangeListeners.push(callback);
  285.       } else if (eventName === 'usbStorageChange') {
  286.         this._usbStorageChangeListeners.push(callback);
  287.       }
  288.     },
  290.     removeEventListener: function(eventName, callback) {
  291.       if (eventName === 'incompatibleSettings') {
  292.         this._removeEventListener(
  293.           this._incompatibleSettingsListeners, callback);
  294.       } else if (eventName === 'wifiHotspotChange') {
  295.         this._removeEventListener(
  296.           this._hotspotChangeListeners, callback);
  297.       } else if (eventName === 'usbHotspotChange') {
  298.         this._removeEventListener(
  299.           this._usbHotspotChangeListeners, callback);
  300.       } else if (eventName === 'usbStorageChange') {
  301.         this._removeEventListener(
  302.           this._usbStorageChangeListeners, callback);
  303.       }
  304.     },
  306.     get wifiHotspotSetting() {
  307.       return this._hotspotSetting;
  308.     },
  310.     get usbHotspotSetting() {
  311.       return this._usbHotspotSetting;
  312.     },
  314.     get usbStorageSetting() {
  315.       return this._usbStorageSetting;
  316.     },
  318.     set hotspotSetting(value) {
  319.       this._setWifiTetheringSetting(value);
  320.     },
  322.     set usbHotspotSetting(value) {
  323.       this._setUsbTetheringSetting(value);
  324.     }
  325.   };
  327.   return function ctor_hotspot() {
  328.     return new Hotspot();
  329.   };
  330. });