Source: panels/simcard_manager/simcard_manager.js

  1. /**
  2.  * SimCardManager is responsible for
  3.  *   1. handling simcard UI
  4.  *   2. handling simcard virtual status (please refer SimUIModel class)
  5.  *   3. handling related mozSettings (please refer SimSettingsHelper class)
  6.  *
  7.  * @module SimCardManager
  8.  */
  9. define(function(require) {
  10.   'use strict';
  12.   var _ = window.navigator.mozL10n.get;
  13.   var l10n = window.navigator.mozL10n;
  14.   var Tagged = require('shared/tagged');
  15.   var SimSettingsHelper = require('shared/sim_settings_helper');
  16.   var AirplaneModeHelper = require('shared/airplane_mode_helper');
  17.   var MobileOperator = require('shared/mobile_operator');
  18.   var SimUIModel = require('panels/simcard_manager/sim_ui_model');
  20.   var SimCardManager = function(elements) {
  21.     // we store all SimUIModel instances into this array
  22.     this._elements = elements;
  23.     this._simcards = [];
  24.     this._isAirplaneMode = false;
  25.   };
  27.   SimCardManager.prototype = {
  28.     /**
  29.      * Initiazlization
  30.      *
  31.      * @memberOf SimCardManager
  32.      * @access public
  33.      */
  34.     init: function scm_init() {
  35.       // `handleEvent` is used to handle these sim related changes
  36.       this._elements.outgoingCallSelect.addEventListener('change', this);
  37.       this._elements.outgoingMessagesSelect.addEventListener('change', this);
  39.       // XXX because we handle `onchange` event differently in value selector,
  40.       // in order to show confirm dialog after users changing value, the better
  41.       // way right now is to check values when `onblur` event triggered.
  42.       this._addOutgoingDataSelectEvent();
  43.       this._addVoiceChangeEventOnConns();
  44.       this._addCardStateChangeEventOnIccs();
  45.       this._addLocalizedChangeEventOnIccs();
  47.       // SMS app will directly change this value if users are going to
  48.       // donwload specific sms from differnt simcard, so we have to
  49.       // make sure our UI will reflect the right value at the moment.
  50.       SimSettingsHelper.observe('outgoingData',
  51.         this._outgoingDataChangeEvent.bind(this));
  53.       // because in fugu, airplaneMode will not change cardState
  54.       // but we still have to make UI consistent. In this way,
  55.       // when airplaneMode is on in fugu, we have to mimic the nosim
  56.       // situation in single sim.
  57.       this._addAirplaneModeChangeEvent();
  59.       this._isAirplaneMode =
  60.         AirplaneModeHelper.getStatus() === 'enabled' ? true : false;
  62.       // init UI
  63.       this._initSimCardsInfo();
  64.       this._initSimCardManagerUI();
  65.     },
  67.     simItemView: function({simIndex}) {
  68.       return Tagged.escapeHTML `<li class="sim-card sim-card-${simIndex}">
  69.         <div class="sim-card-icon"></div>
  70.         <div class="information-container">
  71.           <p class="sim-card-name"></p>
  72.           <p class="sim-card-operator"></p>
  73.           <bdi class="sim-card-number"></bdi>
  74.         </div>
  75.       </li>`;
  76.     },
  78.     /**
  79.      * We will initialize SimUIModel and store them into our internal
  80.      * variables.
  81.      *
  82.      * @memberOf SimCardManager
  83.      * @access public
  84.      */
  85.     _initSimCardsInfo: function scm__initSimCardsInfo() {
  86.       var conns = window.navigator.mozMobileConnections;
  87.       for (var cardIndex = 0; cardIndex < conns.length; cardIndex++) {
  88.         var conn = conns[cardIndex];
  89.         var iccId = conn.iccId;
  90.         var simcard = SimUIModel(cardIndex);
  91.         this._simcards.push(simcard);
  92.         this._updateCardState(cardIndex, iccId);
  93.       }
  94.     },
  96.     /**
  97.      * Handle incoming events
  98.      *
  99.      * @memberOf SimCardManager
  100.      * @access private
  101.      * @param {Event} evt
  102.      */
  103.     handleEvent: function scm_handlEvent(evt) {
  104.       var cardIndex = evt.target.value;
  106.       // it means users is seleting '--' options
  107.       // when _simcards are all disabled
  108.       if (cardIndex === SimSettingsHelper.EMPTY_OPTION_VALUE) {
  109.         return;
  110.       }
  112.       switch (evt.target) {
  113.         case this._elements.outgoingCallSelect:
  114.           SimSettingsHelper.setServiceOnCard('outgoingCall', cardIndex);
  115.           break;
  117.         case this._elements.outgoingMessagesSelect:
  118.           SimSettingsHelper.setServiceOnCard('outgoingMessages', cardIndex);
  119.           break;
  120.       }
  121.     },
  123.     /**
  124.      * Handle mozSettings change event for `outgoing data` key
  125.      *
  126.      * @memberOf SimCardManager
  127.      * @access private
  128.      * @param {Number} cardIndex
  129.      */
  130.     _outgoingDataChangeEvent: function scm__outgoingDataChangeEvent(cardIndex) {
  131.       this._elements.outgoingDataSelect.value = cardIndex;
  132.     },
  134.     /**
  135.      * Handle change event for `outgoing data` select
  136.      *
  137.      * @memberOf SimCardManager
  138.      * @access private
  139.      */
  140.     _addOutgoingDataSelectEvent: function scm__addOutgoingDataSelectEvent() {
  141.       var prevCardIndex;
  142.       var newCardIndex;
  144.       // initialize these two variables when focus
  145.       this._elements.outgoingDataSelect.addEventListener('focus', function() {
  146.         prevCardIndex = this.selectedIndex;
  147.         newCardIndex = this.selectedIndex;
  148.       });
  150.       this._elements.outgoingDataSelect.addEventListener('blur', function() {
  151.         newCardIndex = this.selectedIndex;
  152.         if (prevCardIndex !== newCardIndex) {
  153.           // UX needs additional hint for users to make sure
  154.           // they really want to change data connection
  155.           var wantToChange =
  156.             window.confirm(_('change-outgoing-data-confirm'));
  158.           if (wantToChange) {
  159.             SimSettingsHelper.setServiceOnCard('outgoingData',
  160.               newCardIndex);
  161.           } else {
  162.             this.selectedIndex = prevCardIndex;
  163.           }
  164.         }
  165.       });
  166.     },
  168.     /**
  169.      * Get count of current simcards
  170.      *
  171.      * @memberOf SimCardManager
  172.      * @access private
  173.      * @return {Number} count of simcards
  174.      */
  175.     _getSimCardsCount: function scm__getSimCardsCount() {
  176.       return this._simcards.length;
  177.     },
  179.     /**
  180.      * Get information of simcard
  181.      *
  182.      * @memberOf SimCardManager
  183.      * @access private
  184.      * @param {Number} cardIndex
  185.      * @return {Object} information stored in SimUIModel
  186.      */
  187.     _getSimCardInfo: function scm__getSimCardInfo(cardIndex) {
  188.       return this._simcards[cardIndex].getInfo();
  189.     },
  191.     /**
  192.      * Get simcard
  193.      *
  194.      * @memberOf SimCardManager
  195.      * @access private
  196.      * @param {Number} cardIndex
  197.      * @return {SimUIModel}
  198.      */
  199.     _getSimCard: function scm__getSimCard(cardIndex) {
  200.       return this._simcards[cardIndex];
  201.     },
  203.     /**
  204.      * Iterate stored instances of SimUIModel and update each Sim UI
  205.      *
  206.      * @memberOf SimCardManager
  207.      * @access private
  208.      */
  209.     _updateSimCardsUI: function scm__updateSimCardsUI() {
  210.       this._simcards.forEach(function(simcard, cardIndex) {
  211.         this._updateSimCardUI(cardIndex);
  212.       }.bind(this));
  213.     },
  215.     /**
  216.      * We would use specified instance of SimUIModel based on passing cardIndex
  217.      * to render related UI on SimCardManager.
  218.      *
  219.      * @memberOf SimCardManager
  220.      * @access private
  221.      * @param {Number} cardIndex
  222.      */
  223.     _updateSimCardUI: function scm__updateSimCardUI(cardIndex) {
  224.       var simcardInfo = this._getSimCardInfo(cardIndex);
  225.       var selectors = ['name', 'number', 'operator'];
  227.       var cardSelector = '.sim-card-' + cardIndex;
  229.       var cardDom =
  230.         this._elements.simCardContainer.querySelector(cardSelector);
  232.       // reflect cardState on UI
  233.       cardDom.classList.toggle('absent', simcardInfo.absent);
  234.       cardDom.classList.toggle('locked', simcardInfo.locked);
  235.       cardDom.classList.toggle('enabled', simcardInfo.enabled);
  237.       // we are in three rows now, we have to fix styles
  238.       cardDom.classList.toggle('with-number', !!simcardInfo.number);
  240.       // relflect wordings on UI
  241.       selectors.forEach(function(selector) {
  243.         // will generate ".sim-card-0 .sim-card-name" for example
  244.         var targetSelector = cardSelector + ' .sim-card-' + selector;
  245.         var element =
  246.           this._elements.simCardContainer.querySelector(targetSelector);
  247.         if (selector === 'number') {
  248.           element.textContent = simcardInfo[selector];
  249.         } else {
  250.           var l10nObj = simcardInfo[selector];
  251.           if (l10nObj.id) {
  252.             l10n.setAttributes(element, l10nObj.id, l10nObj.args);
  253.           } else {
  254.             element.removeAttribute('data-l10n-id');
  255.             element.textContent = l10nObj.text;
  256.           }
  257.         }
  258.       }.bind(this));
  259.     },
  261.     /**
  262.      * Initialize SimCardManager UIs which includes
  263.      * SimCardsUI, selectOptionsUI, simSecurityUI
  264.      *
  265.      * @memberOf SimCardManager
  266.      * @access private
  267.      */
  268.     _initSimCardManagerUI: function scm__initSimCardManagerUI() {
  269.       this._initSimCardsUI();
  270.       this._updateSelectOptionsUI();
  272.       // we only inject basic DOM from templates before
  273.       // , so we have to map UI to its info
  274.       this._updateSimCardsUI();
  275.       this._updateSimSettingsUI();
  276.     },
  278.     /**
  279.      * Initialize SimCardsUI
  280.      *
  281.      * @memberOf SimCardManager
  282.      * @access private
  283.      */
  284.     _initSimCardsUI: function scm__initSimCardsUI() {
  285.       var simItemHTMLs = [];
  287.       // inject new childs
  288.       this._simcards.forEach(function(simcard, index) {
  289.         simItemHTMLs.push(
  290.           this.simItemView({
  291.             simIndex: index.toString()
  292.           })
  293.         );
  294.       }.bind(this));
  296.       this._elements.simCardContainer.innerHTML = simItemHTMLs.join('');
  297.     },
  299.     /**
  300.      * Update the UI of the sim settings section
  301.      *
  302.      * @memberOf SimCardManager
  303.      * @access private
  304.      */
  305.     _updateSimSettingsUI: function scm__updateSimSettingsUI() {
  306.       var firstCardInfo = this._simcards[0].getInfo();
  307.       var secondCardInfo = this._simcards[1].getInfo();
  308.       var hidden = firstCardInfo.absent && secondCardInfo.absent ||
  309.         this._isAirplaneMode;
  311.       // if we don't have any card available right now
  312.       // or if we are in airplane mode
  313.       this._elements.simSettingsHeader.hidden = hidden;
  314.       this._elements.simSettingsList.hidden = hidden;
  315.     },
  317.     /**
  318.      * Update SelectOptions UI
  319.      *
  320.      * @memberOf SimCardManager
  321.      * @access private
  322.      */
  323.     _updateSelectOptionsUI: function scm__updateSelectOptionsUI() {
  324.       var firstCardInfo = this._simcards[0].getInfo();
  325.       var secondCardInfo = this._simcards[1].getInfo();
  327.       // two cards all are not absent, we have to update separately
  328.       if (!firstCardInfo.absent && !secondCardInfo.absent) {
  329.         SimSettingsHelper.getCardIndexFrom('outgoingCall',
  330.           function(cardIndex) {
  331.             this._updateSelectOptionUI('outgoingCall', cardIndex,
  332.               this._elements.outgoingCallSelect);
  333.         }.bind(this));
  335.         SimSettingsHelper.getCardIndexFrom('outgoingMessages',
  336.           function(cardIndex) {
  337.             this._updateSelectOptionUI('outgoingMessages', cardIndex,
  338.               this._elements.outgoingMessagesSelect);
  339.         }.bind(this));
  341.         SimSettingsHelper.getCardIndexFrom('outgoingData',
  342.           function(cardIndex) {
  343.             this._updateSelectOptionUI('outgoingData', cardIndex,
  344.               this._elements.outgoingDataSelect);
  345.         }.bind(this));
  346.       } else {
  347.         // there is one card absent while the other one is not
  349.         var selectedCardIndex;
  351.         // if two cards all are absent
  352.         if (firstCardInfo.absent && secondCardInfo.absent) {
  353.           // we will just set on the first card even
  354.           // they are all with '--'
  355.           selectedCardIndex = 0;
  356.         } else {
  357.           // if there is one card absent, the other one is not absent
  359.           // we have to set defaultId to available card automatically
  360.           // and disable select/option
  361.           selectedCardIndex = firstCardInfo.absent ? 1 : 0;
  362.         }
  364.         // for these two situations, they all have to be disabled
  365.         // and can not be selected by users
  366.         this._elements.outgoingCallSelect.disabled = true;
  367.         this._elements.outgoingMessagesSelect.disabled = true;
  368.         this._elements.outgoingDataSelect.disabled = true;
  370.         // then change related UI
  371.         this._updateSelectOptionUI('outgoingCall', selectedCardIndex,
  372.           this._elements.outgoingCallSelect);
  373.         this._updateSelectOptionUI('outgoingMessages', selectedCardIndex,
  374.           this._elements.outgoingMessagesSelect);
  375.         this._updateSelectOptionUI('outgoingData', selectedCardIndex,
  376.           this._elements.outgoingDataSelect);
  377.       }
  378.     },
  380.     /**
  381.      * Update SelectOption UI
  382.      *
  383.      * @memberOf SimCardManager
  384.      * @access private
  385.      * @param {String} storageKey
  386.      * @param {Number} selectedCardIndex
  387.      * @param {HTMLElement} selectedDOM
  388.      */
  389.     _updateSelectOptionUI: function scm__updateSelectOptionUI(
  390.       storageKey, selectedCardIndex, selectDOM) {
  391.         // We have to remove old options first
  392.         while (selectDOM.firstChild) {
  393.           selectDOM.removeChild(selectDOM.firstChild);
  394.         }
  396.         // then insert the new ones
  397.         this._simcards.forEach(function(simcard, index) {
  398.           var simcardInfo = simcard.getInfo();
  399.           var option = document.createElement('option');
  400.           option.value = index;
  402.           if (simcardInfo.absent) {
  403.             option.value = SimSettingsHelper.EMPTY_OPTION_VALUE;
  404.             option.text = SimSettingsHelper.EMPTY_OPTION_TEXT;
  405.           } else {
  406.             if (simcardInfo.name.id) {
  407.               l10n.setAttributes(option,
  408.                 simcardInfo.name.id, simcardInfo.name.args);
  409.             } else {
  410.               option.text = simcardInfo.name.text;
  411.             }
  412.           }
  414.           if (index == selectedCardIndex) {
  415.             option.selected = true;
  416.           }
  418.           selectDOM.add(option);
  419.         });
  421.         // we will add `always ask` option these two select
  422.         if (storageKey === 'outgoingCall' ||
  423.           storageKey === 'outgoingMessages') {
  424.             var option = document.createElement('option');
  425.             option.value = SimSettingsHelper.ALWAYS_ASK_OPTION_VALUE;
  426.             option.setAttribute('data-l10n-id', 'sim-manager-always-ask');
  428.             if (SimSettingsHelper.ALWAYS_ASK_OPTION_VALUE ===
  429.               selectedCardIndex) {
  430.                 option.selected = true;
  431.             }
  432.             selectDOM.add(option);
  433.         }
  434.     },
  436.     /**
  437.      * Check whether current cardState is locked or not.
  438.      *
  439.      * @memberOf SimCardManager
  440.      * @access private
  441.      * @param {String} cardState
  442.      * @return {Boolean}
  443.      */
  444.     _isSimCardLocked: function scm__isSimCardLocked(cardState) {
  445.       var lockedState = [
  446.         'pinRequired',
  447.         'pukRequired',
  448.         'networkLocked',
  449.         'serviceProviderLocked',
  450.         'corporateLocked',
  451.         'network1Locked',
  452.         'network2Locked',
  453.         'hrpdNetworkLocked',
  454.         'ruimCorporateLocked',
  455.         'ruimServiceProviderLocked'
  456.       ];
  458.       // make sure the card is in locked mode or not
  459.       return lockedState.indexOf(cardState) !== -1;
  460.     },
  462.     /**
  463.      * Check whether current cardState is blocked or not.
  464.      *
  465.      * @memberOf SimCardManager
  466.      * @access private
  467.      * @param {String} cardState
  468.      * @return {Boolean}
  469.      */
  470.     _isSimCardBlocked: function scm__isSimCardBlocked(cardState) {
  471.       var uselessState = [
  472.         'permanentBlocked'
  473.       ];
  474.       return uselessState.indexOf(cardState) !== -1;
  475.     },
  477.     /**
  478.      * If voidechange happened on any conn, we would upate its cardState and
  479.      * reflect the change on UI.
  480.      *
  481.      * @memberOf SimCardManager
  482.      * @access private
  483.      */
  484.     _addVoiceChangeEventOnConns: function scm__addVoiceChangeEventOnConns() {
  485.       var conns = window.navigator.mozMobileConnections;
  486.       for (var i = 0; i < conns.length; i++) {
  487.         var iccId = conns[i].iccId;
  488.         conns[i].addEventListener('voicechange',
  489.           this._updateCardStateWithUI.bind(this, i, iccId));
  490.       }
  491.     },
  493.     /**
  494.      * Iterate conns to add changeEvent
  495.      *
  496.      * @memberOf SimCardManager
  497.      * @access private
  498.      */
  499.     _addCardStateChangeEventOnIccs:
  500.       function scm__addCardStateChangeEventOnIccs() {
  501.         var conns = window.navigator.mozMobileConnections;
  502.         var iccManager = window.navigator.mozIccManager;
  503.         for (var i = 0; i < conns.length; i++) {
  504.           var iccId = conns[i].iccId;
  505.           var icc = iccManager.getIccById(iccId);
  506.           if (icc) {
  507.             this._addChangeEventOnIccByIccId(iccId);
  508.           }
  509.         }
  510.     },
  512.     /**
  513.      * When localized event happened, we would update each cardState and its
  514.      * UI.
  515.      *
  516.      * @memberOf SimCardManager
  517.      * @access private
  518.      */
  519.     _addLocalizedChangeEventOnIccs:
  520.       function scm__addLocalizedChangeEventOnIccs() {
  521.         var conns = window.navigator.mozMobileConnections;
  522.         window.addEventListener('localized', function() {
  523.           for (var i = 0; i < conns.length; i++) {
  524.             var iccId = conns[i].iccId;
  525.             this._updateCardStateWithUI(i, iccId);
  526.           }
  527.         }.bind(this));
  528.     },
  530.     /**
  531.      * Add change event on each icc and would update UI if possible.
  532.      *
  533.      * @memberOf SimCardManager
  534.      * @access private
  535.      * @param {String} iccId
  536.      */
  537.     _addChangeEventOnIccByIccId:
  538.       function scm__addChangeEventOnIccByIccId(iccId) {
  539.         var self = this;
  540.         var icc = window.navigator.mozIccManager.getIccById(iccId);
  541.         if (icc) {
  542.           icc.addEventListener('cardstatechange', function() {
  543.             var cardIndex = self._getCardIndexByIccId(iccId);
  544.             self._updateCardStateWithUI(cardIndex, iccId);
  546.             // If we make PUK locked for more than 10 times,
  547.             // we sould get `permanentBlocked` state, in this way
  548.             // we have to update select/options
  549.             if (self._isSimCardBlocked(icc.cardState)) {
  550.               self._updateSelectOptionsUI();
  551.             }
  552.           });
  553.         }
  554.     },
  556.     /**
  557.      * If the state of APM is changed, we will update states and update all
  558.      * related UIs.
  559.      *
  560.      * @memberOf SimCardManager
  561.      * @access private
  562.      */
  563.     _addAirplaneModeChangeEvent: function scm__addAirplaneModeChangeEvent() {
  564.       var self = this;
  565.       AirplaneModeHelper.addEventListener('statechange', function(state) {
  566.         // we only want to handle these two states
  567.         if (state === 'enabled' || state === 'disabled') {
  568.           var enabled = (state === 'enabled') ? true : false;
  569.           self._isAirplaneMode = enabled;
  570.           self._updateCardsState();
  571.           self._updateSimCardsUI();
  572.           self._updateSimSettingsUI();
  573.         }
  574.       });
  575.     },
  577.     /**
  578.      * Iterate conns to call updateCardState on each conn.
  579.      *
  580.      * @memberOf SimCardManager
  581.      * @access private
  582.      */
  583.     _updateCardsState: function scm__updateCardsState() {
  584.       var conns = window.navigator.mozMobileConnections;
  585.       for (var cardIndex = 0; cardIndex < conns.length; cardIndex++) {
  586.         var iccId = conns[cardIndex].iccId;
  587.         this._updateCardState(cardIndex, iccId);
  588.       }
  589.     },
  591.     /**
  592.      * we will use specified conn to update its state on our internal simcards
  593.      *
  594.      * @memberOf SimCardManager
  595.      * @access private
  596.      * @param {Number} cardIndex
  597.      * @param {String} iccId
  598.      */
  599.     _updateCardState: function scm__updateCardState(cardIndex, iccId) {
  600.       var iccManager = window.navigator.mozIccManager;
  601.       var conn = window.navigator.mozMobileConnections[cardIndex];
  602.       var simcard = this._simcards[cardIndex];
  604.       if (!iccId || this._isAirplaneMode) {
  605.         simcard.setState('nosim');
  606.       } else {
  607.         // else if we can get mobileConnection,
  608.         // we have to check locked / enabled state
  609.         var icc = iccManager.getIccById(iccId);
  610.         var iccInfo = icc.iccInfo;
  611.         var cardState = icc.cardState;
  612.         var operatorInfo = MobileOperator.userFacingInfo(conn);
  614.         if (this._isSimCardLocked(cardState)) {
  615.           simcard.setState('locked');
  616.         } else if (this._isSimCardBlocked(cardState)) {
  617.           simcard.setState('blocked');
  618.         } else {
  619.           // TODO:
  620.           // we have to call Gecko API here to make sure the
  621.           // simcard is enabled / disabled
  622.           simcard.setState('normal', {
  623.             number: iccInfo.msisdn || iccInfo.mdn || '',
  624.             operator: operatorInfo.operator
  625.           });
  626.         }
  627.       }
  628.     },
  630.     /**
  631.      * Sometimes, we have to update state and UI at the same time, so this is
  632.      * a handy function to use.
  633.      *
  634.      * @memberOf SimCardManager
  635.      * @access private
  636.      * @param {Number} cardIndex
  637.      * @return {String} iccId
  638.      */
  639.     _updateCardStateWithUI:
  640.       function scm__updateCardStateWithUI(cardIndex, iccId) {
  641.         this._updateCardState(cardIndex, iccId);
  642.         this._updateSimCardUI(cardIndex);
  643.         this._updateSimSettingsUI();
  644.     },
  646.     /**
  647.      * This method would help us find out the index of passed in iccId.
  648.      *
  649.      * @memberOf SimCardManager
  650.      * @access private
  651.      * @param {String} iccId
  652.      * @return {Number} cardIndex
  653.      */
  654.     _getCardIndexByIccId: function scm__getCardIndexByIccId(iccId) {
  655.       var conns = window.navigator.mozMobileConnections;
  656.       var cardIndex;
  657.       for (var i = 0; i < conns.length; i++) {
  658.         if (conns[i].iccId == iccId) {
  659.           cardIndex = i;
  660.         }
  661.       }
  662.       return cardIndex;
  663.     }
  664.   };
  666.   return SimCardManager;
  667. });