Source: modules/bluetooth/bluetooth_connection_manager.js

  1. /**
  2.  * BluetoothConnectionManager:
  3.  * BluetoothConnectionManager only update state and does not involve in any UI
  4.  *   logic.
  5.  *
  6.  * @module BluetoothConnectionManager
  7.  */
  8. define(function(require) {
  9.   'use strict';
  11.   var AdapterManager = require('modules/bluetooth/bluetooth_adapter_manager');
  12.   var AsyncStorage = require('shared/async_storage');
  14.   var _debug = false;
  15.   var Debug = function() {};
  16.   if (_debug) {
  17.     Debug = function btam_debug(msg) {
  18.       console.log('--> [BluetoothConnectionManager]: ' + msg);
  19.     };
  20.   }
  22.   /**
  23.    * @alias module:modules/bluetooth/BluetoothConnectionManager
  24.    * @requires module:modules/bluetooth/bluetooth_adapter_manager
  25.    * @requires module:shared/async_storage
  26.    * @return {BluetoothConnectionManager}
  27.    */
  28.   var BluetoothConnectionManager = {
  29.     /**
  30.      * The profiles of connected device that we are defined here.
  31.      *
  32.      * @public
  33.      * @memberOf BluetoothConnectionManager
  34.      * @type {Object}
  35.      */
  36.     Profiles: {
  37.       'hfp': 0x111E,  // Handsfree
  38.       'a2dp': 0x110D  // Advanced Audio Distribution Devices
  39.     },
  41.     /**
  42.      * The address of device that we are trying to connect.
  43.      *
  44.      * @public
  45.      * @memberOf BluetoothConnectionManager
  46.      * @type {String}
  47.      */
  48.     connectingAddress: null,
  50.     /**
  51.      * A object that we cache the connected devices information(address, device,
  52.      * connectedProfiles). It will be inited while default adapter is ready.
  53.      * And these information is coming from profile events.
  54.      * Each connected device is hashed by device address.
  55.      *
  56.      * EX:
  57.      * _connectedDevicesInfo = {
  58.      *   'AA:BB:CC:00:11:22': {
  59.      *     'device': DeviceObject,
  60.      *     'connectedProfiles': {
  61.      *       'hfp': true,
  62.      *       'a2dp': false
  63.      *     }
  64.      *   }
  65.      * };
  66.      *
  67.      * @private
  68.      * @memberOf BluetoothConnectionManager
  69.      * @type {Object}
  70.      */
  71.     _connectedDevicesInfo: {},
  73.     /**
  74.      * An instance to maintain that we have created a promise to get connected
  75.      * devices.
  76.      *
  77.      * @access public
  78.      * @memberOf BluetoothConnectionManager
  79.      * @return {Promise}
  80.      */
  81.      _getConnectedDevicesPromise: null,
  83.     /**
  84.      * The object maintains listeners' callback per property name.
  85.      * Each listener would be called as following definition.
  86.      * 'connecting' - be called when device is connecting.
  87.      * 'connected': - be called when device is connected.
  88.      * 'disconnected': - be called when device is disconnected.
  89.      * 'profileChanged': - be called when profile is changed.
  90.      *
  91.      * @memberOf BluetoothConnectionManager
  92.      * @type {Object}
  93.      */
  94.     _listeners: {
  95.       'connecting': [],
  96.       'connected': [],
  97.       'disconnected': [],
  98.       'profileChanged': []
  99.     },
  101.     /**
  102.      * Default adapter of Bluetooth.
  103.      *
  104.      * @access private
  105.      * @memberOf BluetoothConnectionManager
  106.      * @type {BluetoothAdapter}
  107.      */
  108.     _defaultAdapter: null,
  110.     /**
  111.      * Init BluetoothConnectionManager module.
  112.      *
  113.      * @access private
  114.      * @memberOf BluetoothConnectionManager
  115.      */
  116.     _init: function btcm__init() {
  117.       // Observe 'defaultAdapter' property for reaching default adapter.
  118.       AdapterManager.observe('defaultAdapter',
  119.                              this._onDefaultAdapterChanged.bind(this));
  120.       this._onDefaultAdapterChanged(AdapterManager.defaultAdapter);
  121.     },
  123.     /**
  124.      * 'defaultAdapter' change event handler from adapter manager for
  125.      * updating adapter immediately.
  126.      *
  127.      * @access private
  128.      * @memberOf BluetoothConnectionManager
  129.      * @param {BluetoothAdapter} newAdapter
  130.      * @param {BluetoothAdapter} oldAdapter
  131.      */
  132.     _onDefaultAdapterChanged:
  133.     function btcm__onDefaultAdapterChanged(newAdapter, oldAdapter) {
  134.       Debug('_onDefaultAdapterChanged(): newAdapter = ' + newAdapter);
  135.       Debug('_onDefaultAdapterChanged(): oldAdapter = ' + oldAdapter);
  137.       // save default adapter
  138.       this._defaultAdapter = newAdapter;
  140.       if (oldAdapter) {
  141.         // unwatch event since the old adapter is no longer usefull
  142.         this._unwatchProfilesStatuschanged(oldAdapter);
  143.         this._unwatchDefaultAdapterOnattributechanged(oldAdapter);
  144.       }
  146.       if (newAdapter) {
  147.         // watch event since the new adapter is ready to access
  148.         this._watchProfilesStatuschanged(newAdapter);
  149.         this._watchDefaultAdapterOnattributechanged(newAdapter);
  150.         // restore connection
  151.         if (newAdapter.state === 'enabled') {
  152.           this._restoreConnection();
  153.         }
  154.       } else {
  155.         // reset properties only
  156.         this._resetConnectionInfo();
  157.       }
  158.     },
  160.     /**
  161.      * Return the cache of connected devices in ConnectionManager.
  162.      *
  163.      * @access public
  164.      * @memberOf BluetoothConnectionManager
  165.      * @return {Promise}
  166.      */
  167.     getConnectedDevices: function btcm_getConnectedDevices() {
  168.       if (!this._getConnectedDevicesPromise) {
  169.         this._getConnectedDevicesPromise =
  170.           this._initConnectedDevicesInfo().then(() => {
  171.             Debug('getConnectedDevices(): resolved with latest cache = ' +
  172.                   JSON.stringify(this._connectedDevicesInfo));
  173.             return this._connectedDevicesInfo;
  174.         }, (reason) => {
  175.           Debug('getConnectedDevices(): rejected with reason = ' + reason);
  176.           this._getConnectedDevicesPromise = null;
  177.         });
  178.       }
  179.       return this._getConnectedDevicesPromise;
  180.     },
  182.     /**
  183.      * Init cache of connected device and save it in cache.
  184.      *
  185.      * @access private
  186.      * @memberOf BluetoothConnectionManager
  187.      * @return {Promise}
  188.      */
  189.     _initConnectedDevicesInfo: function btcm__initConnectedDevicesInfo() {
  190.       if (!this._defaultAdapter) {
  191.         return Promise.reject('default adapter is not existed!!');
  192.       }
  193.       // Init connection status and profile from platform.
  194.       // Then, save these connected device information in cache.
  195.       return this._getConnectedDevicesFromPlatform().then(
  196.       (connectedDevicesByProfile) => {
  197.         this._constructDeviceItemsMap(connectedDevicesByProfile);
  198.       }, (reason) => {
  199.         Debug('_initConnectedDevicesInfo(): rejected in ' + 
  200.               '_getConnectedDevicesFromPlatform');
  201.         return Promise.reject(reason);
  202.       });
  203.     },
  205.     /**
  206.      * The method will update each device item in maintaining map.
  207.      *
  208.      * @access private
  209.      * @memberOf BluetoothConnectionManager
  210.      * @param {Object} connectedDevices
  211.      */
  212.     _constructDeviceItemsMap:
  213.     function btcm__constructDeviceItemsMap(connectedDevices) {
  214.       Debug('_constructDeviceItemsMap(): connectedDevices = ' + 
  215.             JSON.stringify(connectedDevices));
  216.       if (!connectedDevices) {
  217.         // Return empty object while there is no any connected devices.
  218.         Debug('_constructDeviceItemsMap(): early return with empty object');
  219.         return;
  220.       }
  221.       
  222.       Object.keys(this.Profiles).map((profileID) => {
  223.         connectedDevices[profileID].forEach((connectedDevice) => {
  224.           var connectionDeviceInfo = {
  225.             address: connectedDevice.address,
  226.             connected: true,
  227.             profileID: profileID,
  228.             device: connectedDevice
  229.           };
  230.           Debug('_constructDeviceItemsMap(): connectionDeviceInfo = ' + 
  231.                 JSON.stringify(connectionDeviceInfo));
  232.           this._initConnectedDevicesCache(connectionDeviceInfo);
  233.         });
  234.       });
  235.     },
  237.     /**
  238.      * Init the cache which is maintained for connection devices.
  239.      * And the input is gotten from platform API adapter.getConnectedDevices().
  240.      *
  241.      * @access private
  242.      * @memberOf BluetoothConnectionManager
  243.      * @param {Object} options
  244.      * @param {String} options.address - address of the device
  245.      * @param {Boolean} options.connected - is connected or not
  246.      * @param {Object} options.profileID - profile ID of the connection type
  247.      * @param {Object} options.device - connect device, Bluetooth Object
  248.      */
  249.     _initConnectedDevicesCache: 
  250.     function btcm__initConnectedDevicesCache(options) {
  251.       Debug('_initConnectedDevicesCache(): options = ' + 
  252.             JSON.stringify(options));
  253.       // hash by device address
  254.       var info = this._connectedDevicesInfo[options.address];
  255.       if (info) {
  256.         // Already have profiles, update it for other profile.
  257.         info.connectedProfiles[options.profileID] = options.connected;
  258.       } else {
  259.         // Not have profiles yet, create for it.
  260.         // If options.device is existed, save the connected device.
  261.         // Otherwise, given null in this property.
  262.         var connectedDevice = (options.device) ? options.device : null;
  263.         info = {
  264.           'device': connectedDevice, 
  265.           'connectedProfiles': {}
  266.         };
  267.         info.connectedProfiles[options.profileID] = options.connected;
  268.       }
  269.       // Save the device/profile in map.
  270.       this._connectedDevicesInfo[options.address] = info;
  272.       // If there is no profile connected, 
  273.       // remove the device item from cache since it is already disconnected.
  274.       var dataToCheckConnectedProfile = {
  275.         address: options.address,
  276.         connectedDevices: this._connectedDevicesInfo
  277.       };
  278.       if (!this._hasConnectedProfileByAddress(dataToCheckConnectedProfile)) {
  279.         delete this._connectedDevicesInfo[options.address];
  280.       }
  281.       // Return the latest cache which is just updated here.
  282.       Debug('_initConnectedDevicesCache(): this._connectedDevicesInfo = ' + 
  283.             JSON.stringify(this._connectedDevicesInfo));
  284.       return this._connectedDevicesInfo;
  285.     },
  287.     /**
  288.      * Update the cache which is maintained for connection devices.
  289.      *
  290.      * @access private
  291.      * @memberOf BluetoothConnectionManager
  292.      * @param {Object} options
  293.      * @param {String} options.address - address of the device
  294.      * @param {Boolean} options.connected - is connected or not
  295.      * @param {Object} options.profileID - profile ID of the connection type
  296.      * @param {Object} options.device - connect device, Bluetooth Object
  297.      */
  298.     _updateConnectedDevices: 
  299.     function btcm__updateConnectedDevices(options) {
  300.       return this.getConnectedDevices().then((connectedDevicesInfo) => {
  301.         Debug('_updateConnectedDevices(): connectedDevicesInfo = ' + 
  302.               JSON.stringify(connectedDevicesInfo));
  304.         // hash by device address
  305.         var info = 
  306.           (connectedDevicesInfo) ? connectedDevicesInfo[options.address] : null;
  307.         if (info) {
  308.           // Already have profiles, update it for other profile.
  309.           info.connectedProfiles[options.profileID] = options.connected;
  310.         } else {
  311.           // Not have profiles yet, create for it.
  312.           // If options.device is existed, save the connected device.
  313.           // Otherwise, given null in this property.
  314.           var connectedDevice = (options.device) ? options.device : null;
  315.           info = {
  316.             'device': connectedDevice, 
  317.             'connectedProfiles': {}
  318.           };
  319.           info.connectedProfiles[options.profileID] = options.connected;
  320.         }
  321.         // Save the device/profile in map.
  322.         this._connectedDevicesInfo[options.address] = info;
  324.         // If there is no profile connected, 
  325.         // remove the device item from cache since it is already disconnected.
  326.         var dataToCheckConnectedProfile = {
  327.           address: options.address,
  328.           connectedDevices: this._connectedDevicesInfo
  329.         };
  330.         if (!this._hasConnectedProfileByAddress(dataToCheckConnectedProfile)) {
  331.           delete this._connectedDevicesInfo[options.address];
  332.         }
  333.         // Return the latest cache which is just updated here.
  334.         Debug('_updateConnectedDevices(): this._connectedDevicesInfo = ' + 
  335.               JSON.stringify(this._connectedDevicesInfo));
  336.         return Promise.resolve(this._connectedDevicesInfo);
  337.       }, () => {
  338.         Debug('_updateConnectedDevices(): rejected with some exception');
  339.         return Promise.reject('rejected with some exception');
  340.       });
  341.     },
  343.     /**
  344.      * Only reset properties since there is no available default adapter.
  345.      *
  346.      * @access private
  347.      * @memberOf BluetoothConnectionManager
  348.      */
  349.     _resetConnectionInfo: function btcm__resetConnectionInfo() {
  350.       // Reset connection status.
  351.       this.connectingAddress = null;
  352.       // Clean up the instance to get connected devices 
  353.       // while new adapter is ready.
  354.       this._getConnectedDevicesPromise = null;
  355.     },
  357.     /**
  358.      * Watch 'onattributechanged' event from default adapter for watching
  359.      * adapter enabled/disabled status.
  360.      *
  361.      * Description of 'onattributechanged' event:
  362.      * A handler to trigger when one of the local bluetooth adapter's properties
  363.      * has changed. Note access to the changed property in this event handler
  364.      * would get the updated value.
  365.      *
  366.      * @access private
  367.      * @memberOf BluetoothConnectionManager
  368.      * @param {BluetoothAdapter} adapter
  369.      */
  370.     _watchDefaultAdapterOnattributechanged:
  371.     function btcm__watchDefaultAdapterOnattributechanged(adapter) {
  372.       adapter.addEventListener('attributechanged', 
  373.         this._onAdapterAttributeChanged.bind(this, adapter));
  374.     },
  376.     /**
  377.      * Unwatch 'onattributechanged' event from default adapter since adapter is
  378.      * removed.
  379.      *
  380.      * @access private
  381.      * @memberOf BluetoothConnectionManager
  382.      * @param {BluetoothAdapter} adapter
  383.      */
  384.     _unwatchDefaultAdapterOnattributechanged:
  385.     function btcm__unwatchDefaultAdapterOnattributechanged(adapter) {
  386.       adapter.removeEventListener('attributechanged', 
  387.         this._onAdapterAttributeChanged);
  388.     },
  390.     /**
  391.      * 'onattributechanged' event handler from default adapter for reaching
  392.      * adapter enabled/disabled status.
  393.      *
  394.      * @access private
  395.      * @memberOf BluetoothConnectionManager
  396.      * @param {BluetoothAdapter} adapter
  397.      * @param {event} evt
  398.      */
  399.     _onAdapterAttributeChanged:
  400.     function btcm__onAdapterAttributeChanged(adapter, evt) {
  401.       for (var i in evt.attrs) {
  402.         Debug('_onAdapterAttributeChanged(): ' + evt.attrs[i]);
  403.         switch (evt.attrs[i]) {
  404.           case 'state':
  405.             if (adapter.state === 'enabled') {
  406.               // Restore connection while default adapter state is enabled.
  407.               this._restoreConnection();
  408.             }
  409.             break;
  410.           default:
  411.             break;
  412.         }
  413.       }
  414.     },
  416.     /**
  417.      * Watch every of profile events('onhfpstatuschanged','ona2dpstatuschanged')
  418.      * from default adapter for updating device connected status immediately.
  419.      *
  420.      * Description of 'onhfpstatuschanged' event:
  421.      * Specifies an event listener to receive hfpstatuschanged events.
  422.      * Those events occur when an HFP connection status changes.
  423.      *
  424.      * Description of 'ona2dpstatuschanged' event:
  425.      * Specifies an event listener to receive a2dpstatuschanged events.
  426.      * Those events occur when an A2DP connection status changes.
  427.      *
  428.      * @access private
  429.      * @memberOf BluetoothConnectionManager
  430.      * @param {BluetoothAdapter} adapter
  431.      */
  432.     _watchProfilesStatuschanged: 
  433.     function btcm__watchProfilesStatuschanged(adapter) {
  434.       var eventName;
  435.       for (var profileID in this.Profiles) {
  436.         eventName = 'on' + profileID + 'statuschanged';
  437.         adapter[eventName] = 
  438.           this._onProfileStatuschangeHandler.bind(this, profileID);
  439.       }
  440.     },
  442.     /**
  443.      * Unwatch every of profile events('onhfpstatuschanged', 
  444.      * 'ona2dpstatuschanged') from default adapter since adapter is removed.
  445.      *
  446.      * @access private
  447.      * @memberOf BluetoothConnectionManager
  448.      * @param {BluetoothAdapter} adapter
  449.      */
  450.     _unwatchProfilesStatuschanged:
  451.     function btc__unwatchProfilesStatuschanged(adapter) {
  452.       var eventName;
  453.       for (var profileID in this.Profiles) {
  454.         eventName = 'on' + profileID + 'statuschanged';
  455.         adapter[eventName] = null;
  456.       }
  457.     },
  459.     /**
  460.      * 'onhfpstatuschanged', 'ona2dpstatuschanged' events handler from 
  461.      * default adapter for updating device connected status.
  462.      *
  463.      * @access private
  464.      * @memberOf BluetoothConnectionManager
  465.      * @param {String} profileID
  466.      * @param {event} evt
  467.      */
  468.     _onProfileStatuschangeHandler: 
  469.     function btcm__onProfileStatuschangeHandler(profileID, evt) {
  470.       Debug('_onProfileStatuschangeHandler(): profileID = ' + profileID + 
  471.             ', evt.address = ' + evt.address + ', evt.status = ' + evt.status);
  472.       var options = {
  473.         address: evt.address,
  474.         connected: evt.status,
  475.         profileID: profileID
  476.       };
  477.       // Update connection status.
  478.       this._updateConnectionStatus(options);
  479.     },
  481.     /**
  482.      * Query async storage to restore connection.
  483.      *
  484.      * @access private
  485.      * @memberOf BluetoothConnectionManager
  486.      */
  487.     _restoreConnection: function btcm__restoreConnection() {
  488.       if (!this._defaultAdapter) {
  489.         return;
  490.       }
  492.       // Reconnect the one kept in the async storage.
  493.       AsyncStorage.getItem('device.connected', (address) => {
  494.         if (!address) {
  495.           return;
  496.         }
  498.         // Make sure the restore device is already connected or not.
  499.         this.getConnectedDevices().then((connectedDevices) => {
  500.           if (connectedDevices && connectedDevices[address]) {
  501.             // Do an early return since the restore device is connected already.
  502.             Debug('_restoreConnection(): early return cause connected already');
  503.             return;
  504.           }
  506.           // Get the device which is wanted to connect from paired devices.
  507.           var restoreDevice = this._getPairedDeviceByAddress(address);
  508.           if (restoreDevice) {
  509.             this.connectingAddress = restoreDevice.address;
  510.             // Fire 'connecting' event.
  511.             var event = {
  512.               type: 'connecting',
  513.               detail: {
  514.                 address: restoreDevice.address  
  515.               }
  516.             };
  517.             this._emitEvent(event);
  518.             this._connect(restoreDevice).then(() => {
  519.               Debug('_restoreConnection(): restore connection successfully');
  520.             }, (reason) => {
  521.               Debug('_restoreConnection(): restore connection failed, ' +
  522.                     'reason = ' + reason);
  523.               // No available profiles are connected. Reset connecting address. 
  524.               this.connectingAddress = null;
  525.               // Then, fire 'disconnected' event.
  526.               event = {
  527.                 type: 'disconnected',
  528.                 detail: {
  529.                   address: restoreDevice.address  
  530.                 }
  531.               };
  532.               this._emitEvent(event);
  533.             });
  534.           }
  535.         });
  536.       });
  537.     },
  539.     /**
  540.      * Record connected device so if Bluetooth is turned off and then on 
  541.      * we can restore the connection.
  542.      *
  543.      * @access private
  544.      * @memberOf BluetoothConnectionManager
  545.      * @param {String} action - to set or remove item for recording connection
  546.      * @param {String} address - the address of connected device
  547.      */
  548.     _recordConnection: function btcm__recordConnection(action, address) {
  549.       if (action === 'set') {
  550.         // record connected device so if Bluetooth is turned off and then on
  551.         // we can restore the connection
  552.         AsyncStorage.setItem('device.connected', address);
  553.         Debug('_recordConnection(): set item');
  554.       } else if ((action === 'remove') && 
  555.                  (this._defaultAdapter.state === 'enabled')) {
  556.         // Clean up the connected device from async storage
  557.         // which is recorded before.
  558.         // Only remove the record while Bluetooth state is enabled.
  559.         // Because the request also comes while Bluetooth is turned off.
  560.         AsyncStorage.removeItem('device.connected');
  561.         Debug('_recordConnection(): remove item');
  562.       }
  563.     },
  565.     /**
  566.      * Update connection status.
  567.      *
  568.      * @access private
  569.      * @memberOf BluetoothConnectionManager
  570.      * @param {Object} options
  571.      * @param {String} options.address - address of the device
  572.      * @param {Boolean} options.connected - is connected or not
  573.      * @param {Object} options.profileID - profile ID of the connection type
  574.      */
  575.     _updateConnectionStatus: function btcm___updateConnectionStatus(options) {
  576.       Debug('_updateConnectionStatus(): address = ' + options.address + 
  577.                                        ', connected = ' + options.connected +
  578.                                        ', profileID = ' + options.profileID);
  579.       this.connectingAddress = null;
  580.       
  581.       // Update the profile in the cache of connected device info.
  582.       this._updateConnectedDevices(options).then((connectedDevicesInfo) => {
  583.         Debug('_updateConnectionStatus(): _updateConnectedDevices() ' + 
  584.               'resolved with connectedDevicesInfo = ' + 
  585.               JSON.stringify(connectedDevicesInfo));
  586.         // Prepare latest data to check connected profile.
  587.         var dataToCheckConnectedProfile = {
  588.           address: options.address,
  589.           connectedDevices: connectedDevicesInfo
  590.         };
  591.         // Fire 'connected'/'disconnected' event according to 
  592.         // the connection profile. Then, record connection.
  593.         var event;
  594.         if (options.connected) {
  595.           // Fire 'connected' event.
  596.           event = {
  597.             type: 'connected',
  598.             detail: {
  599.               address: options.address
  600.             }
  601.           };
  602.           this._emitEvent(event);
  603.           // Record connection.
  604.           this._recordConnection('set', options.address);
  605.         } else {
  606.           // If there is no profile connected, 
  607.           // we have to remove the record connection.
  608.           // And fire 'disconnected' event for outer modules.
  609.           if (!this._hasConnectedProfileByAddress(
  610.               dataToCheckConnectedProfile)) {
  611.             // Record connection. Only remove the record while Bluetooth state 
  612.             // is enabled. Because the event also comes while Bluetooth is 
  613.             // turned off.
  614.             if (this._defaultAdapter.state === 'enabled') {
  615.               this._recordConnection('remove');  
  616.             }
  617.             // Fire 'disconnected' event.
  618.             event = {
  619.               type: 'disconnected',
  620.               detail: {
  621.                 address: options.address
  622.               }
  623.             };
  624.             this._emitEvent(event);
  625.           }
  626.         }
  628.         // Fire 'profileChanged' event.
  629.         var newProfiles;
  630.         if (!this._hasConnectedProfileByAddress(dataToCheckConnectedProfile)) {
  631.           newProfiles = null;
  632.         } else {
  633.           newProfiles = connectedDevicesInfo[options.address].connectedProfiles;
  634.         }
  635.         event = {
  636.           type: 'profileChanged',
  637.           detail: {
  638.             address: options.address,
  639.             profiles: newProfiles
  640.           }
  641.         };
  642.         this._emitEvent(event);
  643.       }, (reason) => {
  644.         Debug('_updateConnectionStatus(): miss to update in rejected case, ' + 
  645.               'reason = ' + reason);
  646.       });
  647.     },
  649.     /**
  650.      * It provides a convenient function for panel to connect with a device.
  651.      * And the panel no need to care about connected device currently.
  652.      * The method will disconnect current connected device first.
  653.      * Then, it will start connecting a paired device with the device's adapter.
  654.      *
  655.      * @access public
  656.      * @memberOf BluetoothConnectionManager
  657.      * @param {BluetoothDevice} device
  658.      * @return {Promise}
  659.      */
  660.     connect: function btcm_connect(device) {
  661.       if (!this._defaultAdapter) {
  662.         return Promise.reject('default adapter is not existed!!');
  663.       }
  665.       // Disconnect current connected device first.
  666.       Debug('connect(): Want to connect device address = ' + device.address +
  667.             ', name = ' + device.name);
  669.       var connectedDevices = [];
  670.       return this.getConnectedDevices().then((connectedDevicesInfo) => {
  671.         for (var address in connectedDevicesInfo) {
  672.           if (connectedDevicesInfo[address].device !== null) {
  673.             connectedDevices.push(connectedDevicesInfo[address].device);
  674.             Debug('connect(): push device cache in queue = ' + 
  675.                   JSON.stringify(connectedDevices));
  676.           } else {
  677.             var regetPairedDevice = this._getPairedDeviceByAddress(address);
  678.             connectedDevices.push(regetPairedDevice);
  679.             Debug('connect(): push _getPairedDeviceByAddress in queue = ' + 
  680.                   JSON.stringify(regetPairedDevice));
  681.           }
  682.         }
  684.         Debug('connect(): Will disconnect these connected devices = ' + 
  685.               JSON.stringify(connectedDevices));
  687.         // Disconnect these connected device before 
  688.         // service to connect with new device.
  689.         return Promise.all(connectedDevices.map((connectedDevice) => {
  690.           return this.disconnect(connectedDevice);
  691.         })).then(() => {
  692.           // All connected devices is disconnected. 
  693.           // We can start to connect the new request.
  694.           Debug('connect(): Start to connect with wanted device address = ' + 
  695.                 device.address);
  696.           return this._connect(device).then(() => {
  697.             Debug('connect(): Resolved');
  698.           }, (reason) => {
  699.             Debug('connect(): reason = ' + reason);
  700.             return Promise.reject(reason);
  701.           });
  702.         });
  703.       });
  704.     },
  706.     /**
  707.      * The method will connect the input device with the device's adapter.
  708.      *
  709.      * @access private
  710.      * @memberOf BluetoothConnectionManager
  711.      * @param {BluetoothDevice} device
  712.      * @returns {Promise}
  713.      */
  714.     _connect: function btcm__connect(device) {
  715.       if (!this._defaultAdapter) {
  716.         return Promise.reject('default adapter is not existed!!');
  717.       }
  719.       // Save the connecting address
  720.       this.connectingAddress = device.address;
  721.       // Fire 'connecting' event.
  722.       var event = {
  723.         type: 'connecting',
  724.         detail: {
  725.           address: device.address
  726.         }
  727.       };
  728.       this._emitEvent(event);
  729.       Debug('_connect(): before start to connect, stop discovery first');
  731.       // Note on Bluedroid stack, discovery has to be stopped before connect
  732.       // (i.e., call stopDiscovery() before connect()) 
  733.       // otherwise stack callbacks with connect failure.
  734.       return this._defaultAdapter.stopDiscovery().then(() => {
  735.         Debug('_connect(): start connecting device, ' + 
  736.               'address = ' + device.address);
  737.         return this._defaultAdapter.connect(device).then(() => {
  738.           Debug('_connect(): resolve, already connected with address = ' + 
  739.                 device.address);
  740.         }, () => {
  741.           // No available profiles are connected. Reset connecting address. 
  742.           this.connectingAddress = null;
  743.           // Fire 'disconnected' event.
  744.           event = {
  745.             type: 'disconnected',
  746.             detail: {
  747.               address: device.address
  748.             }
  749.           };
  750.           this._emitEvent(event);
  751.           Debug('_connect(): reject with connection failed');
  752.           return Promise.reject('connection failed');
  753.         });
  754.       }, () => {
  755.         // Cannot connect with the device since stopDiscovery failed. 
  756.         this.connectingAddress = null;
  757.         // Fire 'disconnected' event.
  758.         event = {
  759.           type: 'disconnected',
  760.           detail: {
  761.             address: device.address
  762.           }
  763.         };
  764.         this._emitEvent(event);
  765.         Debug('_connect(): reject with stop discovery failed');
  766.         return Promise.reject('stop discovery failed');
  767.       });
  768.     },
  770.     /**
  771.      * The method will disconnect the input device with the device's adapter.
  772.      *
  773.      * @access public
  774.      * @memberOf BluetoothConnectionManager
  775.      * @param {BluetoothDevice} device
  776.      * @returns {Promise}
  777.      */
  778.     disconnect: function btcm_disconnect(device) {
  779.       if (!this._defaultAdapter) {
  780.         return Promise.reject('default adapter is not existed!!');
  781.       }
  783.       return this._defaultAdapter.disconnect(device).then(() => {
  784.         Debug('disconnect(): onsuccess(): resolve');
  785.       }, () => {
  786.         Debug('disconnect(): onerror(): reject with disconnect failed');
  787.         return Promise.reject('disconnect failed');
  788.       });
  789.     },
  791.     /**
  792.      * The method will get all connected devices profiles 
  793.      * which we are interested in. Profile: HFP, A2DP.
  794.      *
  795.      * @access private
  796.      * @memberOf BluetoothConnectionManager
  797.      * @returns {Promise} resolve: connectedDevices
  798.      * @returns {Promise} reject: reason
  799.      */
  800.     _getConnectedDevicesFromPlatform: 
  801.     function btcm__getConnectedDevicesFromPlatform() {
  802.       // Get connected device via profiles HFP, A2DP
  803.       return Promise.all(Object.keys(this.Profiles).map((profile) => {
  804.         return this._getConnectedDevicesByProfile(this.Profiles[profile]);
  805.       })).then((connectedDevices) => {
  806.         // Update each connected devices in map.
  807.         var collectedConnectedDevicesByProfile = {};
  808.         Object.keys(this.Profiles).forEach((profile, index) => {
  809.           collectedConnectedDevicesByProfile[profile] = connectedDevices[index];
  810.         });
  811.         Debug('_getConnectedDevicesFromPlatform(): ' + 
  812.               'collectedConnectedDevicesByProfile = ' + 
  813.               JSON.stringify(collectedConnectedDevicesByProfile));
  814.         return Promise.resolve(collectedConnectedDevicesByProfile);
  815.       });
  816.     },
  818.     /**
  819.      * The method will get connected device by inputed profile.
  820.      *
  821.      * @access private
  822.      * @memberOf BluetoothConnectionManager
  823.      * @param {String} profileID
  824.      * @returns {Promise} resolve: the connected devices in array
  825.      * @returns {Promise} reject: reason
  826.      */
  827.     _getConnectedDevicesByProfile: 
  828.     function btcm__getConnectedDevicesByProfile(profileID) {
  829.       if (!this._defaultAdapter) {
  830.         Debug('_getConnectedDevicesByProfile(): reject with no adapter');
  831.         return Promise.reject('default adapter is not existed!!');
  832.       }
  834.       if (this._defaultAdapter.state === 'disabled') {
  835.         Debug('_getConnectedDevicesByProfile(): resolve with empty array ' + 
  836.               'since it is impossible to connect with any device');
  837.         return Promise.reject('getConnectedDevices in disabled state');
  838.       }
  840.       return this._defaultAdapter.getConnectedDevices(profileID).then(
  841.       (connectedDevice) => {
  842.         Debug('_getConnectedDevicesByProfile(): resolved with ' + 
  843.               'connectedDevice = ' + JSON.stringify(connectedDevice));
  844.         return Promise.resolve(connectedDevice || []);
  845.       }, (reason) => {
  846.         Debug('_getConnectedDevicesByProfile(): rejected with ' + 
  847.               'reason = ' + reason);
  848.         return Promise.reject(reason);
  849.       });
  850.     },
  852.     /**
  853.      * Get device from paired devices by address.
  854.      *
  855.      * @access private
  856.      * @memberOf BluetoothConnectionManager
  857.      * @param {String} address
  858.      */
  859.     _getPairedDeviceByAddress: 
  860.     function btcm__getPairedDeviceByAddress(address) {
  861.       if (!this._defaultAdapter) {
  862.         return null;
  863.       }
  865.       var pairedDevices = this._defaultAdapter.getPairedDevices();
  866.       if (pairedDevices.length === 0) {
  867.         return null;
  868.       } else {
  869.         for (var i in pairedDevices) {
  870.           if (pairedDevices[i].address === address) {
  871.             return pairedDevices[i];
  872.           }
  873.         }
  874.         return null;
  875.       }
  876.     },
  878.     /**
  879.      * Find out there is any profile still connected.
  880.      *
  881.      * @access private
  882.      * @memberOf BluetoothConnectionManager
  883.      * @param {Object} options
  884.      * @param {String} options.connectedDevices - connected devices info
  885.      * @param {String} options.address - the address of device
  886.      */
  887.     _hasConnectedProfileByAddress: 
  888.     function btcm__hasConnectedProfileByAddress(options) {
  889.       if (!options.connectedDevices[options.address]) {
  890.         return false;
  891.       }
  893.       var hasConnectedProfile = false;
  894.       for (var profileID in this.Profiles) {
  895.         var connectedProfiles = 
  896.           options.connectedDevices[options.address].connectedProfiles;
  897.         if (connectedProfiles && (connectedProfiles[profileID] === true)) {
  898.           hasConnectedProfile = true;
  899.         }
  900.       }
  901.       return hasConnectedProfile;
  902.     },
  904.     /**
  905.      * A function to emit event to each registered listener by the input type.
  906.      *
  907.      * @memberOf BluetoothConnectionManager
  908.      * @param {Object} options
  909.      * @param {String} options.type - type of event name
  910.      * @param {Object} options.detail - the object pass to the listener
  911.      */
  912.     _emitEvent: function btcm__emitEvent(options) {
  913.       this._listeners[options.type].forEach(function(listener) {
  914.         listener(options);
  915.       });
  916.     },
  918.     /**
  919.      * The method will provide event listener for outer modules to regist.
  920.      *
  921.      * @access public
  922.      * @memberOf BluetoothConnectionManager
  923.      * @param {String} eventName
  924.      * @param {Function} callback
  925.      */
  926.     addEventListener: function btcm_addEventListener(eventName, callback) {
  927.       if (callback && (this._listeners.hasOwnProperty(eventName))) {
  928.         this._listeners[eventName].push(callback);
  929.       }
  930.     },
  932.     /**
  933.      * The method will provide event listener for outer modules to un-regist.
  934.      *
  935.      * @access public
  936.      * @memberOf BluetoothConnectionManager
  937.      * @param {String} eventName
  938.      * @param {Function} callback
  939.      */
  940.     removeEventListener: 
  941.     function btcm_removeEventListener(eventName, callback) {
  942.       if (callback && (this._listeners.hasOwnProperty(eventName))) {
  943.         var index = this._listeners[eventName].indexOf(callback);
  944.         if (index >= 0) {
  945.           this._listeners[eventName].splice(index, 1);
  946.         }
  947.       }
  948.     }
  949.   };
  951.   BluetoothConnectionManager._init();
  952.   return BluetoothConnectionManager;
  953. });