b38dea0597
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
575 lines
16 KiB
JavaScript
575 lines
16 KiB
JavaScript
'use strict';
|
|
/**
|
|
* Bluetooth2 is compatible with Bluetooth APIv2 and used to enable/
|
|
* disable bluetooth hardware, get bluetooth adapter, and check target
|
|
* bluetooth profile is connected.
|
|
*
|
|
* Bluetooth api v2 is the two level structure.
|
|
* We use _btManagerHandler to handle BluetoothManager defaultAdapter
|
|
* change event and _btAdapterHandler to handle status change event.
|
|
*
|
|
* Current supported Bluetooth profiles are:
|
|
* - hfp: Hands-Free Profile
|
|
* - opp: Object Push Profile
|
|
* - a2dp: Advenced Audio Distribution Profile
|
|
* - sco: Synchronous Connection-Oriented Profile
|
|
*/
|
|
/* global Service, LazyLoader, BluetoothIcon, BluetoothTransferIcon,
|
|
BluetoothHeadphoneIcon, BluetoothTransfer */
|
|
/* exported Bluetooth2 */
|
|
(function(exports) {
|
|
var Bluetooth = function() {};
|
|
|
|
Bluetooth.prototype = {
|
|
name: 'Bluetooth',
|
|
|
|
/**
|
|
* Debug message.
|
|
*
|
|
* @public
|
|
* @type {Boolean} turn on/off the console log
|
|
*/
|
|
onDebug: false,
|
|
|
|
/**
|
|
* Store a reference of the default adapter.
|
|
* If the adapter is not availble, no bluetooth operation could be
|
|
* executed.
|
|
*
|
|
* @private
|
|
*/
|
|
_adapter: null,
|
|
|
|
/**
|
|
* Hold instance of bluetooth adapter state change handler.
|
|
*
|
|
* @private
|
|
*/
|
|
_bindBtAdapterHandler: null,
|
|
|
|
/**
|
|
* Hold instance of HFP status changed handler.
|
|
*
|
|
* @private
|
|
*/
|
|
_bindHfpStatusChangedHandler: null,
|
|
|
|
/**
|
|
* Hold instance of A2DP status changed handler.
|
|
*
|
|
* @private
|
|
*/
|
|
_bindA2dpStatusChangedHandler: null,
|
|
|
|
/**
|
|
* Hold instance of SCO status changed handler.
|
|
*
|
|
* @private
|
|
*/
|
|
_bindScoStatusChangedHandler: null,
|
|
|
|
/**
|
|
* Store a reference for mozBluetooth.
|
|
*
|
|
* @private
|
|
*/
|
|
_bluetooth: null,
|
|
|
|
/**
|
|
* State of Bluetooth default adapter.
|
|
*
|
|
* @private
|
|
*/
|
|
_isEnabled: false,
|
|
|
|
/**
|
|
* Set profile connect state.
|
|
*
|
|
* @private
|
|
* @param {String} profile profile id
|
|
* @param {Boolean} connected connect status
|
|
*/
|
|
_setProfileConnected: function bt_setProfileConnected(profile, connected) {
|
|
var value = this['_' + profile + 'Connected'];
|
|
if (value !== connected) {
|
|
this['_' + profile + 'Connected'] = connected;
|
|
|
|
// Raise an event for the profile connection changes.
|
|
window.dispatchEvent(new CustomEvent('bluetoothprofileconnectionchange',
|
|
{
|
|
detail: {
|
|
name: profile,
|
|
connected: connected
|
|
}
|
|
}
|
|
));
|
|
// Update Bluetooth and profile icons
|
|
this.icon && this.icon.update();
|
|
if (profile === 'opp' && this.transferIcon) {
|
|
this.transferIcon.update();
|
|
}
|
|
if (profile === 'a2dp' && this.headphoneIcon) {
|
|
this.headphoneIcon.update();
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Check if bluetooth profile is connected.
|
|
*
|
|
* @private
|
|
* @param {String} profile profile name
|
|
* @return {Boolean} connected state
|
|
*/
|
|
_isProfileConnected: function bt__isProfileConnected(profile) {
|
|
var isConnected = this['_' + profile + 'Connected'];
|
|
if (isConnected === undefined) {
|
|
return false;
|
|
} else {
|
|
return isConnected;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Initialize bluetooth module.
|
|
*
|
|
* @public
|
|
*/
|
|
start: function bt_start() {
|
|
if (!window.navigator.mozSettings || !window.navigator.mozBluetooth) {
|
|
return;
|
|
}
|
|
|
|
this._bluetooth = window.navigator.mozBluetooth;
|
|
|
|
// hold the instances so we can remove it when needed
|
|
this._bindBtAdapterHandler =
|
|
this._btAdapterHandler.bind(this);
|
|
|
|
this._bindHfpStatusChangedHandler = function(evt) {
|
|
this._setProfileConnected('hfp', evt.status);
|
|
}.bind(this);
|
|
this._bindA2dpStatusChangedHandler = function(evt) {
|
|
this._setProfileConnected('a2dp', evt.status);
|
|
}.bind(this);
|
|
this._bindScoStatusChangedHandler = function(evt) {
|
|
this._setProfileConnected('sco', evt.status);
|
|
}.bind(this);
|
|
|
|
this._initDefaultAdapter();
|
|
|
|
this._bluetooth.addEventListener('attributechanged',
|
|
this._btManagerHandler.bind(this));
|
|
|
|
// decouple enable/disable bluetooth function from other system part
|
|
window.addEventListener('request-enable-bluetooth',
|
|
this._requestEnableHandler.bind(this));
|
|
window.addEventListener('request-disable-bluetooth',
|
|
this._requestDisableHandler.bind(this));
|
|
|
|
// relay bluetooth transfer system messages
|
|
navigator.mozSetMessageHandler('bluetooth-opp-transfer-start',
|
|
this._oppTransferStartHandler.bind(this));
|
|
navigator.mozSetMessageHandler('bluetooth-opp-transfer-complete',
|
|
this._oppTransferCompleteHandler.bind(this));
|
|
|
|
// expose functions to Service.request
|
|
Service.register('adapter', this);
|
|
Service.register('pair', this);
|
|
Service.register('getPairedDevices', this);
|
|
// expose functions to Service.query
|
|
Service.registerState('isEnabled', this);
|
|
Service.registerState('getAdapter', this);
|
|
Service.registerState('isOPPProfileConnected', this);
|
|
Service.registerState('isA2DPProfileConnected', this);
|
|
Service.registerState('isSCOProfileConnected', this);
|
|
|
|
// handle statusbar icons
|
|
LazyLoader.load(['js/bluetooth_transfer.js',
|
|
'js/bluetooth_icon.js',
|
|
'js/bluetooth_transfer_icon.js',
|
|
'js/bluetooth_headphone_icon.js']).then(() => {
|
|
BluetoothTransfer.start();
|
|
this.icon = new BluetoothIcon(this);
|
|
this.icon.start();
|
|
this.transferIcon = new BluetoothTransferIcon(this);
|
|
this.transferIcon.start();
|
|
this.headphoneIcon = new BluetoothHeadphoneIcon(this);
|
|
this.headphoneIcon.start();
|
|
}).catch(function(err) {
|
|
console.error(err);
|
|
});
|
|
},
|
|
|
|
stop: function() {
|
|
Service.unregister('adapter', this);
|
|
Service.unregister('pair', this);
|
|
Service.unregister('getPairedDevices', this);
|
|
Service.unregisterState('isEnabled', this);
|
|
Service.unregisterState('getAdapter', this);
|
|
Service.unregisterState('isOPPProfileConnected', this);
|
|
Service.unregisterState('isA2DPProfileConnected', this);
|
|
Service.unregisterState('isSCOProfileConnected', this);
|
|
},
|
|
|
|
/**
|
|
* Generally bluetooth adapter is already available when start
|
|
* this module and no related event will be received.
|
|
* so we try to get the adapter then listen to mozBluetooth change
|
|
* to prevent race condition
|
|
*
|
|
* @private
|
|
*/
|
|
_initDefaultAdapter: function() {
|
|
this.debug('init bluetooth adapter');
|
|
this._adapter = this._bluetooth.defaultAdapter;
|
|
if (this._adapter) {
|
|
this.debug('adapter is available');
|
|
// listen states when the adapter is available
|
|
this._adapterAvailableHandler();
|
|
|
|
// dispatch default bluetooth enable state
|
|
this._isEnabled = (this._adapter.state === 'enabled');
|
|
this._dispatchEnableState();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Once adapter is available, listen to bluetooth state and
|
|
* the connect stat of supported profiles.
|
|
*
|
|
* we only support two use cases for bluetooth connection:
|
|
* 1. connecting with a headset
|
|
* 2. transfering a file to/from another device
|
|
* So we need to listen to corresponding events to know we are (aren't)
|
|
* connected, then summarize to an event and dispatch to Statusbar
|
|
*
|
|
* @private
|
|
*/
|
|
_adapterAvailableHandler: function bt__adapterAvailableHandler() {
|
|
// listen to adapter state
|
|
this._adapter.addEventListener('attributechanged',
|
|
this._bindBtAdapterHandler);
|
|
|
|
// headset connected cases
|
|
this._adapter.addEventListener('hfpstatuschanged',
|
|
this._bindHfpStatusChangedHandler);
|
|
this._adapter.addEventListener('a2dpstatuschanged',
|
|
this._bindA2dpStatusChangedHandler);
|
|
this._adapter.addEventListener('scostatuschanged',
|
|
this._bindScoStatusChangedHandler);
|
|
},
|
|
|
|
/**
|
|
* Remove all EventListeners when default adapter is changed.
|
|
*/
|
|
_adapterUnavailableHandler: function bt__adapterUnavailableHandler() {
|
|
this.debug('default adapter is removed');
|
|
// unbind headset connected cases
|
|
this._adapter.removeEventListener('hfpstatuschanged',
|
|
this._bindHfpStatusChangedHandler);
|
|
this._adapter.removeEventListener('a2dpstatuschanged',
|
|
this._bindA2dpStatusChangedHandler);
|
|
this._adapter.removeEventListener('scostatuschanged',
|
|
this._bindScoStatusChangedHandler);
|
|
|
|
// unbind adapter
|
|
this._adapter.removeEventListener('attributechanged',
|
|
this._bindBtAdapterHandler);
|
|
},
|
|
|
|
/**
|
|
* Update settings value and enable bluetooth hardware.
|
|
*
|
|
* @private
|
|
*/
|
|
_requestEnableHandler: function bt__requestEnableHandler() {
|
|
this.debug('enabling bluetooth');
|
|
if (this._adapter) {
|
|
// the state will be dispatched in _btAdapterHandler
|
|
this._adapter.enable().then(() => { //resolve
|
|
this.debug('bluetooth enabled');
|
|
}, () => { //reject
|
|
this.debug('can not get bluetooth adapter');
|
|
});
|
|
} else { // return current state since we can't process the request
|
|
this.debug('adapter is not available');
|
|
this._dispatchEnableState();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Update settings value and disable bluetooth hardware.
|
|
*
|
|
* @private
|
|
*/
|
|
_requestDisableHandler: function bt__requestDisableHandler() {
|
|
this.debug('disabling bluetooth');
|
|
if (this._adapter) {
|
|
// the state will be dispatched in _btAdapterHandler
|
|
this._adapter.disable().then(() => { //resolve
|
|
this.debug('bluetooth disabled');
|
|
}, () => { //reject
|
|
this.debug('can not get bluetooth adapter');
|
|
});
|
|
} else { // return current state since we can't process the request
|
|
this.debug('adapter is not available');
|
|
this._dispatchEnableState();
|
|
}
|
|
},
|
|
|
|
/*
|
|
* In file transfering case:
|
|
* since System Message can't be listened in two js files within a app,
|
|
* so we listen here but dispatch events to bluetooth_transfer.js
|
|
* while getting bluetooth file transfer start system messages
|
|
*
|
|
* @private
|
|
*/
|
|
_oppTransferStartHandler: function(transferInfo) {
|
|
this._setProfileConnected('opp', true);
|
|
window.dispatchEvent(new CustomEvent('bluetooth-opp-transfer-start',
|
|
{
|
|
detail: { transferInfo: transferInfo }
|
|
}
|
|
));
|
|
},
|
|
|
|
/*
|
|
* In file transfering case:
|
|
* since System Message can't be listened in two js files within a app,
|
|
* so we listen here but dispatch events to bluetooth_transfer.js
|
|
* while getting bluetooth file transfer complete system messages
|
|
*
|
|
* @private
|
|
*/
|
|
_oppTransferCompleteHandler: function(transferInfo) {
|
|
this._setProfileConnected('opp', false);
|
|
window.dispatchEvent(new CustomEvent('bluetooth-opp-transfer-complete',
|
|
{
|
|
detail: { transferInfo: transferInfo }
|
|
}
|
|
));
|
|
},
|
|
|
|
/**
|
|
* BT APIv2: Watch 'onattributechanged' event from
|
|
* mozBluetooth.defaultAdapter for updating state information.
|
|
*
|
|
* @private
|
|
* @param {Object} evt event object
|
|
*/
|
|
_btAdapterHandler:
|
|
function bt__btAdapterHandler(evt) {
|
|
for (var i in evt.attrs) {
|
|
switch (evt.attrs[i]) {
|
|
case 'state':
|
|
if (this._adapter.state === 'enabled') {
|
|
this.debug('state true');
|
|
this._isEnabled = true;
|
|
navigator.mozSettings.createLock()
|
|
.set({'bluetooth.enabled': true});
|
|
window.dispatchEvent(new CustomEvent('bluetooth-enabled'));
|
|
this.icon && this.icon.update();
|
|
} else if (this._adapter.state === 'disabled') {
|
|
this.debug('state false');
|
|
this._isEnabled = false;
|
|
navigator.mozSettings.createLock()
|
|
.set({'bluetooth.enabled': false});
|
|
window.dispatchEvent(new CustomEvent('bluetooth-disabled'));
|
|
this.icon && this.icon.update();
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Watch 'onattributechanged' event from mozBluetooth for updating default
|
|
* adapter information.
|
|
*
|
|
* 'onattributechanged' event description:
|
|
* A handler to trigger when bluetooth manager's only property
|
|
* defaultAdapter has changed.
|
|
*
|
|
* Here are three adapter change cases:
|
|
*
|
|
* null -> adapter: set new adapter and dispatch adapter state.
|
|
* adapter -> null: clear defaultAdapter and listener.
|
|
* adapterA -> adapterB: clean defaultAdapter and listener,
|
|
* then set new adapter and dispatch adapter state.
|
|
*
|
|
* @private
|
|
* @param {Object} evt event object
|
|
*/
|
|
_btManagerHandler:
|
|
function bt__btManagerHandler(evt) {
|
|
for (var i in evt.attrs) {
|
|
switch (evt.attrs[i]) {
|
|
// Default adapter attribute change.
|
|
// Usually, it means that we reach new default adapter.
|
|
case 'defaultAdapter':
|
|
this.debug('defaultAdapter changed.');
|
|
if (this._bluetooth.defaultAdapter) {
|
|
if (this._adapter !== this._bluetooth.defaultAdapter) {
|
|
if (this._adapter !== null) { // adapter A -> adapter B
|
|
this.debug('origin adapter is removed');
|
|
this._adapterUnavailableHandler();
|
|
this._adapter = null;
|
|
}
|
|
// set new adapter and dispatch adapter state
|
|
this.debug('new adapter is added');
|
|
this._adapter = this._bluetooth.defaultAdapter;
|
|
this._isEnabled = (this._adapter.state === 'enabled');
|
|
// listen states when the adapter is available
|
|
this._adapterAvailableHandler();
|
|
}
|
|
} else { // adapter -> null
|
|
this.debug('default adapter is removed');
|
|
this._adapterUnavailableHandler();
|
|
this._adapter = null;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Dispatch bluetooth enable/disable state to system.
|
|
*
|
|
* @private
|
|
*/
|
|
_dispatchEnableState: function bt__dispatchEnableState() {
|
|
if (this._isEnabled) {
|
|
window.dispatchEvent(new CustomEvent('bluetooth-enabled'));
|
|
} else {
|
|
window.dispatchEvent(new CustomEvent('bluetooth-disabled'));
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get adapter from bluetooth through promise interface.
|
|
* XXX: the function abstract the Bluetooth API difference.
|
|
* We can remove it and use service query once BTv1 is deprecated.
|
|
*
|
|
* @public
|
|
* @return {Promise} A promise that resolve the Bluetooth Adapter
|
|
*/
|
|
adapter: function bt__adapter() {
|
|
return new Promise((resolve, reject) => {
|
|
if (this._adapter !== null) {
|
|
resolve(this._adapter);
|
|
} else {
|
|
this.debug('No BT adapter retrieved');
|
|
reject();
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Return device pairing result.
|
|
* XXX: the function abstract the Bluetooth API difference.
|
|
*
|
|
* @public
|
|
* @param {string} mac target device address
|
|
* @return {Promise} A promise that resolve when pair successfully,
|
|
* reject when pair failed
|
|
*/
|
|
pair: function bt__pair(mac) {
|
|
return this._adapter.pair(mac);
|
|
},
|
|
|
|
/**
|
|
* Return paired devices list.
|
|
* XXX: the function abstract the Bluetooth API difference.
|
|
* We can use service query to return list once BTv1 is deprecated.
|
|
*
|
|
* @public
|
|
* @returns {Object[]} sequence of BluetoothDevice
|
|
*/
|
|
getPairedDevices: function bt__getPairedDevices() {
|
|
return this._adapter.getPairedDevices();
|
|
},
|
|
|
|
/**
|
|
* Return bluetooth adapter.
|
|
*
|
|
* @public
|
|
*/
|
|
get getAdapter() {
|
|
return this._adapter;
|
|
},
|
|
|
|
/**
|
|
* Maintain bluetooth enable/disable state.
|
|
*
|
|
* @public
|
|
*/
|
|
get isEnabled() {
|
|
return this._isEnabled;
|
|
},
|
|
|
|
/**
|
|
* Check if bluetooth OPP profile is connected.
|
|
*
|
|
* @public
|
|
* @return {Boolean} connected state
|
|
*/
|
|
get isOPPProfileConnected() {
|
|
return this._isProfileConnected('opp');
|
|
},
|
|
|
|
/**
|
|
* Check if bluetooth A2DP profile is connected.
|
|
*
|
|
* @public
|
|
* @return {Boolean} connected state
|
|
*/
|
|
get isA2DPProfileConnected() {
|
|
return this._isProfileConnected('a2dp');
|
|
},
|
|
|
|
/**
|
|
* Check if bluetooth SCO profile is connected.
|
|
*
|
|
* @public
|
|
* @return {Boolean} connected state
|
|
*/
|
|
get isSCOProfileConnected() {
|
|
return this._isProfileConnected('sco');
|
|
},
|
|
|
|
/**
|
|
* Check if any of bluetooth profiles is connected.
|
|
* Referenced by Bluetooth icon update
|
|
*
|
|
* @public
|
|
* @return {Boolean} connected state
|
|
*/
|
|
get connected() {
|
|
return this._isProfileConnected('hfp') ||
|
|
this._isProfileConnected('a2dp') ||
|
|
this._isProfileConnected('opp');
|
|
},
|
|
|
|
/**
|
|
* Console log.
|
|
*
|
|
* @private
|
|
* @param {Object} msg debug message
|
|
*/
|
|
debug: function bt_debug(msg) {
|
|
if (!this.onDebug) {
|
|
return;
|
|
}
|
|
|
|
console.log('[System Bluetooth]: ' + msg);
|
|
}
|
|
};
|
|
|
|
exports.Bluetooth2 = Bluetooth;
|
|
})(window);
|