The Tor Browser / file revision

 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */

 /* vim: set ts=2 et sw=2 tw=80: */

 /*

 ** Copyright 2006, The Android Open Source Project

 **

 ** Licensed under the Apache License, Version 2.0 (the "License");

 ** you may not use this file except in compliance with the License.

 ** You may obtain a copy of the License at

 **

 **     http://www.apache.org/licenses/LICENSE-2.0

 **

 ** Unless required by applicable law or agreed to in writing, software

 ** distributed under the License is distributed on an "AS IS" BASIS,

 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 ** See the License for the specific language governing permissions and

 ** limitations under the License.

 */

 #include "BluetoothServiceBluedroid.h"

 #include <hardware/hardware.h>

 #include "BluetoothA2dpManager.h"

 #include "BluetoothHfpManager.h"

 #include "BluetoothOppManager.h"

 #include "BluetoothProfileController.h"

 #include "BluetoothReplyRunnable.h"

 #include "BluetoothUtils.h"

 #include "BluetoothUuid.h"

 #include "mozilla/dom/bluetooth/BluetoothTypes.h"

 #include "mozilla/ipc/UnixSocket.h"

 #include "mozilla/StaticMutex.h"

 #include "mozilla/StaticPtr.h"

 #include "mozilla/unused.h"

 using namespace mozilla;

 using namespace mozilla::ipc;

 USING_BLUETOOTH_NAMESPACE

 /**

  *  Static variables

  */

 static bluetooth_device_t* sBtDevice;

 static const bt_interface_t* sBtInterface;

 static bool sAdapterDiscoverable = false;

 static bool sIsBtEnabled = false;

 static nsString sAdapterBdAddress;

 static nsString sAdapterBdName;

 static uint32_t sAdapterDiscoverableTimeout;

 static InfallibleTArray<nsString> sAdapterBondedAddressArray;

 static InfallibleTArray<BluetoothNamedValue> sRemoteDevicesPack;

 static nsTArray<nsRefPtr<BluetoothProfileController> > sControllerArray;

 static nsTArray<nsRefPtr<BluetoothReplyRunnable> > sBondingRunnableArray;

 static nsTArray<nsRefPtr<BluetoothReplyRunnable> > sChangeDiscoveryRunnableArray;

 static nsTArray<nsRefPtr<BluetoothReplyRunnable> > sGetDeviceRunnableArray;

 static nsTArray<nsRefPtr<BluetoothReplyRunnable> > sSetPropertyRunnableArray;

 static nsTArray<nsRefPtr<BluetoothReplyRunnable> > sUnbondingRunnableArray;

 static nsTArray<int> sRequestedDeviceCountArray;

 /**

  *  Classes only used in this file

  */

 class DistributeBluetoothSignalTask : public nsRunnable {

 public:

   DistributeBluetoothSignalTask(const BluetoothSignal& aSignal) :

     mSignal(aSignal)

   {

   }

   NS_IMETHOD

   Run()

   {

     MOZ_ASSERT(NS_IsMainThread());

     BluetoothService* bs = BluetoothService::Get();

     NS_ENSURE_TRUE(bs, NS_ERROR_FAILURE);

     bs->DistributeSignal(mSignal);

     return NS_OK;

   }

 private:

   BluetoothSignal mSignal;

 };

 class SetupAfterEnabledTask : public nsRunnable

 {

 public:

   SetupAfterEnabledTask()

   { }

   NS_IMETHOD

   Run()

   {

     MOZ_ASSERT(NS_IsMainThread());

     // Bluetooth scan mode is NONE by default

     bt_scan_mode_t mode = BT_SCAN_MODE_CONNECTABLE;

     bt_property_t prop;

     prop.type = BT_PROPERTY_ADAPTER_SCAN_MODE;

     prop.val = (void*)&mode;

     prop.len = sizeof(mode);

     NS_ENSURE_TRUE(sBtInterface, NS_ERROR_FAILURE);

     int ret = sBtInterface->set_adapter_property(&prop);

     if (ret != BT_STATUS_SUCCESS) {

       BT_LOGR("Fail to set: BT_SCAN_MODE_CONNECTABLE");

     }

     // Try to fire event 'AdapterAdded' to fit the original behaviour when

     // we used BlueZ as backend.

     BluetoothService* bs = BluetoothService::Get();

     NS_ENSURE_TRUE(bs, NS_ERROR_FAILURE);

     bs->AdapterAddedReceived();

     bs->TryFiringAdapterAdded();

     // Trigger BluetoothOppManager to listen

     BluetoothOppManager* opp = BluetoothOppManager::Get();

     if (!opp || !opp->Listen()) {

       BT_LOGR("Fail to start BluetoothOppManager listening");

     }

     return NS_OK;

   }

 };

 /**

  *  Static callback functions

  */

 static void

 ClassToIcon(uint32_t aClass, nsAString& aRetIcon)

 {

   switch ((aClass & 0x1f00) >> 8) {

     case 0x01:

       aRetIcon.AssignLiteral("computer");

       break;

     case 0x02:

       switch ((aClass & 0xfc) >> 2) {

         case 0x01:

         case 0x02:

         case 0x03:

         case 0x05:

           aRetIcon.AssignLiteral("phone");

           break;

         case 0x04:

           aRetIcon.AssignLiteral("modem");

           break;

       }

       break;

     case 0x03:

       aRetIcon.AssignLiteral("network-wireless");

       break;

     case 0x04:

       switch ((aClass & 0xfc) >> 2) {

         case 0x01:

         case 0x02:

         case 0x06:

           aRetIcon.AssignLiteral("audio-card");

           break;

         case 0x0b:

         case 0x0c:

         case 0x0d:

           aRetIcon.AssignLiteral("camera-video");

           break;

         default:

           aRetIcon.AssignLiteral("audio-card");

           break;

       }

       break;

     case 0x05:

       switch ((aClass & 0xc0) >> 6) {

         case 0x00:

           switch ((aClass && 0x1e) >> 2) {

             case 0x01:

             case 0x02:

               aRetIcon.AssignLiteral("input-gaming");

               break;

           }

           break;

         case 0x01:

           aRetIcon.AssignLiteral("input-keyboard");

           break;

         case 0x02:

           switch ((aClass && 0x1e) >> 2) {

             case 0x05:

               aRetIcon.AssignLiteral("input-tablet");

               break;

             default:

               aRetIcon.AssignLiteral("input-mouse");

               break;

           }

       }

       break;

     case 0x06:

       if (aClass & 0x80) {

         aRetIcon.AssignLiteral("printer");

         break;

       }

       if (aClass & 0x20) {

         aRetIcon.AssignLiteral("camera-photo");

         break;

       }

       break;

   }

   if (aRetIcon.IsEmpty()) {

     if (HAS_AUDIO(aClass)) {

       /**

        * Property 'Icon' may be missed due to CoD of major class is TOY(0x08).

        * But we need to assign Icon as audio-card if service class is 'Audio'.

        * This is for PTS test case TC_AG_COD_BV_02_I. As HFP specification

        * defines that service class is 'Audio' can be considered as HFP HF.

        */

       aRetIcon.AssignLiteral("audio-card");

     } else {

       BT_LOGR("No icon to match class: %x", aClass);

     }

   }

 }

 static ControlPlayStatus

 PlayStatusStringToControlPlayStatus(const nsAString& aPlayStatus)

 {

   ControlPlayStatus playStatus = ControlPlayStatus::PLAYSTATUS_UNKNOWN;

   if (aPlayStatus.EqualsLiteral("STOPPED")) {

     playStatus = ControlPlayStatus::PLAYSTATUS_STOPPED;

   } else if (aPlayStatus.EqualsLiteral("PLAYING")) {

     playStatus = ControlPlayStatus::PLAYSTATUS_PLAYING;

   } else if (aPlayStatus.EqualsLiteral("PAUSED")) {

     playStatus = ControlPlayStatus::PLAYSTATUS_PAUSED;

   } else if (aPlayStatus.EqualsLiteral("FWD_SEEK")) {

     playStatus = ControlPlayStatus::PLAYSTATUS_FWD_SEEK;

   } else if (aPlayStatus.EqualsLiteral("REV_SEEK")) {

     playStatus = ControlPlayStatus::PLAYSTATUS_REV_SEEK;

   } else if (aPlayStatus.EqualsLiteral("ERROR")) {

     playStatus = ControlPlayStatus::PLAYSTATUS_ERROR;

   }

   return playStatus;

 }

 static bool

 IsReady()

 {

   if (!sBtInterface || !sIsBtEnabled) {

     BT_LOGR("Warning! Bluetooth Service is not ready");

     return false;

   }

   return true;

 }

 static void

 AdapterStateChangeCallback(bt_state_t aStatus)

 {

   MOZ_ASSERT(!NS_IsMainThread());

   BT_LOGR("BT_STATE %d", aStatus);

   sIsBtEnabled = (aStatus == BT_STATE_ON);

   nsRefPtr<nsRunnable> runnable =

     new BluetoothService::ToggleBtAck(sIsBtEnabled);

   if (NS_FAILED(NS_DispatchToMainThread(runnable))) {

     BT_WARNING("Failed to dispatch to main thread!");

     return;

   }

   if (sIsBtEnabled &&

       NS_FAILED(NS_DispatchToMainThread(new SetupAfterEnabledTask()))) {

     BT_WARNING("Failed to dispatch to main thread!");

   }

 }

 /**

  * AdapterPropertiesCallback will be called after enable() but before

  * AdapterStateChangeCallback sIsBtEnabled get updated. At that moment, both

  * BluetoothManager/BluetoothAdapter does not register observer yet.

  */

 static void

 AdapterPropertiesCallback(bt_status_t aStatus, int aNumProperties,

                           bt_property_t *aProperties)

 {

   MOZ_ASSERT(!NS_IsMainThread());

   BluetoothValue propertyValue;

   InfallibleTArray<BluetoothNamedValue> props;

   for (int i = 0; i < aNumProperties; i++) {

     bt_property_t p = aProperties[i];

     if (p.type == BT_PROPERTY_BDADDR) {

       BdAddressTypeToString((bt_bdaddr_t*)p.val, sAdapterBdAddress);

       propertyValue = sAdapterBdAddress;

       BT_APPEND_NAMED_VALUE(props, "Address", propertyValue);

     } else if (p.type == BT_PROPERTY_BDNAME) {

       // Construct nsCString here because Bd name returned from bluedroid

       // is missing a null terminated character after SetProperty.

       propertyValue = sAdapterBdName = NS_ConvertUTF8toUTF16(

         nsCString((char*)p.val, p.len));

       BT_APPEND_NAMED_VALUE(props, "Name", propertyValue);

     } else if (p.type == BT_PROPERTY_ADAPTER_SCAN_MODE) {

       bt_scan_mode_t newMode = *(bt_scan_mode_t*)p.val;

       if (newMode == BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE) {

         propertyValue = sAdapterDiscoverable = true;

       } else {

         propertyValue = sAdapterDiscoverable = false;

       }

       BT_APPEND_NAMED_VALUE(props, "Discoverable", propertyValue);

     } else if (p.type == BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT) {

       propertyValue = sAdapterDiscoverableTimeout = *(uint32_t*)p.val;

       BT_APPEND_NAMED_VALUE(props, "DiscoverableTimeout", propertyValue);

     } else if (p.type == BT_PROPERTY_ADAPTER_BONDED_DEVICES) {

       // We have to cache addresses of bonded devices. Unlike BlueZ,

       // bluedroid would not send an another BT_PROPERTY_ADAPTER_BONDED_DEVICES

       // event after bond completed

       bt_bdaddr_t* deviceBdAddressTypes = (bt_bdaddr_t*)p.val;

       int numOfAddresses = p.len / BLUETOOTH_ADDRESS_BYTES;

       BT_LOGD("Adapter property: BONDED_DEVICES. Count: %d", numOfAddresses);

       // Whenever reloading paired devices, force refresh

       sAdapterBondedAddressArray.Clear();

       for (int index = 0; index < numOfAddresses; index++) {

         nsAutoString deviceBdAddress;

         BdAddressTypeToString(deviceBdAddressTypes + index, deviceBdAddress);

         sAdapterBondedAddressArray.AppendElement(deviceBdAddress);

       }

       propertyValue = sAdapterBondedAddressArray;

       BT_APPEND_NAMED_VALUE(props, "Devices", propertyValue);

     } else if (p.type == BT_PROPERTY_UUIDS) {

       //FIXME: This will be implemented in the later patchset

       continue;

     } else {

       BT_LOGD("Unhandled adapter property type: %d", p.type);

       continue;

     }

   }

   NS_ENSURE_TRUE_VOID(props.Length() > 0);

   BluetoothValue value(props);

   BluetoothSignal signal(NS_LITERAL_STRING("PropertyChanged"),

                          NS_LITERAL_STRING(KEY_ADAPTER), value);

   nsRefPtr<DistributeBluetoothSignalTask>

     t = new DistributeBluetoothSignalTask(signal);

   if (NS_FAILED(NS_DispatchToMainThread(t))) {

     BT_WARNING("Failed to dispatch to main thread!");

   }

   // bluedroid BTU task was stored in the task queue, see GKI_send_msg

   if (!sSetPropertyRunnableArray.IsEmpty()) {

     DispatchBluetoothReply(sSetPropertyRunnableArray[0], BluetoothValue(true),

                            EmptyString());

     sSetPropertyRunnableArray.RemoveElementAt(0);

   }

 }

 /**

  * RemoteDevicePropertiesCallback will be called, as the following conditions:

  * 1. When BT is turning on, bluedroid automatically execute this callback

  * 2. When get_remote_device_properties()

  */

 static void

 RemoteDevicePropertiesCallback(bt_status_t aStatus, bt_bdaddr_t *aBdAddress,

                                int aNumProperties, bt_property_t *aProperties)

 {

   MOZ_ASSERT(!NS_IsMainThread());

   if (sRequestedDeviceCountArray.IsEmpty()) {

     MOZ_ASSERT(sGetDeviceRunnableArray.IsEmpty());

     return;

   }

   sRequestedDeviceCountArray[0]--;

   InfallibleTArray<BluetoothNamedValue> props;

   nsString remoteDeviceBdAddress;

   BdAddressTypeToString(aBdAddress, remoteDeviceBdAddress);

   BT_APPEND_NAMED_VALUE(props, "Address", remoteDeviceBdAddress);

   for (int i = 0; i < aNumProperties; ++i) {

     bt_property_t p = aProperties[i];

     if (p.type == BT_PROPERTY_BDNAME) {

       BluetoothValue propertyValue = NS_ConvertUTF8toUTF16((char*)p.val);

       BT_APPEND_NAMED_VALUE(props, "Name", propertyValue);

     } else if (p.type == BT_PROPERTY_CLASS_OF_DEVICE) {

       uint32_t cod = *(uint32_t*)p.val;

       BT_APPEND_NAMED_VALUE(props, "Class", cod);

       nsString icon;

       ClassToIcon(cod, icon);

       BT_APPEND_NAMED_VALUE(props, "Icon", icon);

     } else {

       BT_LOGD("Other non-handled device properties. Type: %d", p.type);

     }

   }

   // Update to registered BluetoothDevice objects

   BluetoothSignal signal(NS_LITERAL_STRING("PropertyChanged"),

                          remoteDeviceBdAddress, props);

   nsRefPtr<DistributeBluetoothSignalTask>

     t = new DistributeBluetoothSignalTask(signal);

   if (NS_FAILED(NS_DispatchToMainThread(t))) {

     BT_WARNING("Failed to dispatch to main thread!");

   }

   // Use address as the index

   sRemoteDevicesPack.AppendElement(

     BluetoothNamedValue(remoteDeviceBdAddress, props));

   if (sRequestedDeviceCountArray[0] == 0) {

     MOZ_ASSERT(!sGetDeviceRunnableArray.IsEmpty());

     if (sGetDeviceRunnableArray.IsEmpty()) {

       BT_LOGR("No runnable to return");

       return;

     }

     DispatchBluetoothReply(sGetDeviceRunnableArray[0],

                            sRemoteDevicesPack, EmptyString());

     // After firing it, clean up cache

     sRemoteDevicesPack.Clear();

     sRequestedDeviceCountArray.RemoveElementAt(0);

     sGetDeviceRunnableArray.RemoveElementAt(0);

   }

 }

 static void

 DeviceFoundCallback(int aNumProperties, bt_property_t *aProperties)

 {

   MOZ_ASSERT(!NS_IsMainThread());

   BluetoothValue propertyValue;

   InfallibleTArray<BluetoothNamedValue> propertiesArray;

   for (int i = 0; i < aNumProperties; i++) {

     bt_property_t p = aProperties[i];

     if (p.type == BT_PROPERTY_BDADDR) {

       nsString remoteDeviceBdAddress;

       BdAddressTypeToString((bt_bdaddr_t*)p.val, remoteDeviceBdAddress);

       propertyValue = remoteDeviceBdAddress;

       BT_APPEND_NAMED_VALUE(propertiesArray, "Address", propertyValue);

     } else if (p.type == BT_PROPERTY_BDNAME) {

       propertyValue = NS_ConvertUTF8toUTF16((char*)p.val);

       BT_APPEND_NAMED_VALUE(propertiesArray, "Name", propertyValue);

     } else if (p.type == BT_PROPERTY_CLASS_OF_DEVICE) {

       uint32_t cod = *(uint32_t*)p.val;

       propertyValue = cod;

       BT_APPEND_NAMED_VALUE(propertiesArray, "Class", propertyValue);

       nsString icon;

       ClassToIcon(cod, icon);

       propertyValue = icon;

       BT_APPEND_NAMED_VALUE(propertiesArray, "Icon", propertyValue);

     } else {

       BT_LOGD("Not handled remote device property: %d", p.type);

     }

   }

   BluetoothValue value = propertiesArray;

   BluetoothSignal signal(NS_LITERAL_STRING("DeviceFound"),

                          NS_LITERAL_STRING(KEY_ADAPTER), value);

   nsRefPtr<DistributeBluetoothSignalTask>

     t = new DistributeBluetoothSignalTask(signal);

   if (NS_FAILED(NS_DispatchToMainThread(t))) {

     BT_WARNING("Failed to dispatch to main thread!");

   }

 }

 static void

 DiscoveryStateChangedCallback(bt_discovery_state_t aState)

 {

   MOZ_ASSERT(!NS_IsMainThread());

   if (!sChangeDiscoveryRunnableArray.IsEmpty()) {

     BluetoothValue values(true);

     DispatchBluetoothReply(sChangeDiscoveryRunnableArray[0],

                            values, EmptyString());

     sChangeDiscoveryRunnableArray.RemoveElementAt(0);

   }

 }

 static void

 PinRequestCallback(bt_bdaddr_t* aRemoteBdAddress,

                    bt_bdname_t* aRemoteBdName, uint32_t aRemoteClass)

 {

   MOZ_ASSERT(!NS_IsMainThread());

   InfallibleTArray<BluetoothNamedValue> propertiesArray;

   nsAutoString remoteAddress;

   BdAddressTypeToString(aRemoteBdAddress, remoteAddress);

   BT_APPEND_NAMED_VALUE(propertiesArray, "address", remoteAddress);

   BT_APPEND_NAMED_VALUE(propertiesArray, "method",

                         NS_LITERAL_STRING("pincode"));

   BT_APPEND_NAMED_VALUE(propertiesArray, "name",

                         NS_ConvertUTF8toUTF16(

                           (const char*)aRemoteBdName->name));

   BluetoothValue value = propertiesArray;

   BluetoothSignal signal(NS_LITERAL_STRING("RequestPinCode"),

                          NS_LITERAL_STRING(KEY_LOCAL_AGENT), value);

   nsRefPtr<DistributeBluetoothSignalTask>

     t = new DistributeBluetoothSignalTask(signal);

   if (NS_FAILED(NS_DispatchToMainThread(t))) {

     BT_WARNING("Failed to dispatch to main thread!");

   }

 }

 static void

 SspRequestCallback(bt_bdaddr_t* aRemoteBdAddress, bt_bdname_t* aRemoteBdName,

                    uint32_t aRemoteClass, bt_ssp_variant_t aPairingVariant,

                    uint32_t aPasskey)

 {

   MOZ_ASSERT(!NS_IsMainThread());

   InfallibleTArray<BluetoothNamedValue> propertiesArray;

   nsAutoString remoteAddress;

   BdAddressTypeToString(aRemoteBdAddress, remoteAddress);

   BT_APPEND_NAMED_VALUE(propertiesArray, "address", remoteAddress);

   BT_APPEND_NAMED_VALUE(propertiesArray, "method",

                         NS_LITERAL_STRING("confirmation"));

   BT_APPEND_NAMED_VALUE(propertiesArray, "name",

                         NS_ConvertUTF8toUTF16(

                           (const char*)aRemoteBdName->name));

   BT_APPEND_NAMED_VALUE(propertiesArray, "passkey", aPasskey);

   BluetoothValue value = propertiesArray;

   BluetoothSignal signal(NS_LITERAL_STRING("RequestConfirmation"),

                          NS_LITERAL_STRING(KEY_LOCAL_AGENT), value);

   nsRefPtr<DistributeBluetoothSignalTask>

     t = new DistributeBluetoothSignalTask(signal);

   if (NS_FAILED(NS_DispatchToMainThread(t))) {

     BT_WARNING("Failed to dispatch to main thread!");

   }

 }

 static void

 BondStateChangedCallback(bt_status_t aStatus, bt_bdaddr_t* aRemoteBdAddress,

                          bt_bond_state_t aState)

 {

   MOZ_ASSERT(!NS_IsMainThread());

   nsAutoString remoteAddress;

   BdAddressTypeToString(aRemoteBdAddress, remoteAddress);

   // We don't need to handle bonding state

   NS_ENSURE_TRUE_VOID(aState != BT_BOND_STATE_BONDING);

   NS_ENSURE_FALSE_VOID(aState == BT_BOND_STATE_BONDED &&

                        sAdapterBondedAddressArray.Contains(remoteAddress));

   bool bonded;

   if (aState == BT_BOND_STATE_NONE) {

     bonded = false;

     sAdapterBondedAddressArray.RemoveElement(remoteAddress);

   } else if (aState == BT_BOND_STATE_BONDED) {

     bonded = true;

     sAdapterBondedAddressArray.AppendElement(remoteAddress);

   }

   // Update bonded address list to BluetoothAdapter

   InfallibleTArray<BluetoothNamedValue> propertiesChangeArray;

   BT_APPEND_NAMED_VALUE(propertiesChangeArray, "Devices",

                         sAdapterBondedAddressArray);

   BluetoothValue value(propertiesChangeArray);

   BluetoothSignal signal(NS_LITERAL_STRING("PropertyChanged"),

                          NS_LITERAL_STRING(KEY_ADAPTER),

                          BluetoothValue(propertiesChangeArray));

   NS_DispatchToMainThread(new DistributeBluetoothSignalTask(signal));

   // Update bonding status to gaia

   InfallibleTArray<BluetoothNamedValue> propertiesArray;

   BT_APPEND_NAMED_VALUE(propertiesArray, "address", remoteAddress);

   BT_APPEND_NAMED_VALUE(propertiesArray, "status", bonded);

   BluetoothSignal newSignal(NS_LITERAL_STRING(PAIRED_STATUS_CHANGED_ID),

                             NS_LITERAL_STRING(KEY_ADAPTER),

                             BluetoothValue(propertiesArray));

   NS_DispatchToMainThread(new DistributeBluetoothSignalTask(newSignal));

   if (bonded && !sBondingRunnableArray.IsEmpty()) {

     DispatchBluetoothReply(sBondingRunnableArray[0],

                            BluetoothValue(true), EmptyString());

     sBondingRunnableArray.RemoveElementAt(0);

   } else if (!bonded && !sUnbondingRunnableArray.IsEmpty()) {

     DispatchBluetoothReply(sUnbondingRunnableArray[0],

                            BluetoothValue(true), EmptyString());

     sUnbondingRunnableArray.RemoveElementAt(0);

   }

 }

 static void

 AclStateChangedCallback(bt_status_t aStatus, bt_bdaddr_t* aRemoteBdAddress,

                         bt_acl_state_t aState)

 {

   //FIXME: This will be implemented in the later patchset

 }

 static void

 CallbackThreadEvent(bt_cb_thread_evt evt)

 {

   //FIXME: This will be implemented in the later patchset

 }

 bt_callbacks_t sBluetoothCallbacks =

 {

   sizeof(sBluetoothCallbacks),

   AdapterStateChangeCallback,

   AdapterPropertiesCallback,

   RemoteDevicePropertiesCallback,

   DeviceFoundCallback,

   DiscoveryStateChangedCallback,

   PinRequestCallback,

   SspRequestCallback,

   BondStateChangedCallback,

   AclStateChangedCallback,

   CallbackThreadEvent

 };

 /**

  *  Static functions

  */

 static bool

 EnsureBluetoothHalLoad()

 {

   hw_module_t* module;

   hw_device_t* device;

   int err = hw_get_module(BT_HARDWARE_MODULE_ID, (hw_module_t const**)&module);

   if (err != 0) {

     BT_LOGR("Error: %s", strerror(err));

     return false;

   }

   module->methods->open(module, BT_HARDWARE_MODULE_ID, &device);

   sBtDevice = (bluetooth_device_t *)device;

   sBtInterface = sBtDevice->get_bluetooth_interface();

   int ret = sBtInterface->init(&sBluetoothCallbacks);

   if (ret != BT_STATUS_SUCCESS) {

     BT_LOGR("Error while setting the callbacks");

     sBtInterface = nullptr;

   }

   return true;

 }

 static nsresult

 StartStopGonkBluetooth(bool aShouldEnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   NS_ENSURE_TRUE(sBtInterface, NS_ERROR_FAILURE);

   if (sIsBtEnabled == aShouldEnable) {

     // Keep current enable status

     nsRefPtr<nsRunnable> runnable =

       new BluetoothService::ToggleBtAck(sIsBtEnabled);

     if (NS_FAILED(NS_DispatchToMainThread(runnable))) {

       BT_WARNING("Failed to dispatch to main thread!");

     }

     return NS_OK;

   }

   int ret = aShouldEnable ? sBtInterface->enable() : sBtInterface->disable();

   NS_ENSURE_TRUE(ret == BT_STATUS_SUCCESS, NS_ERROR_FAILURE);

   return NS_OK;

 }

 static void

 ReplyStatusError(BluetoothReplyRunnable* aBluetoothReplyRunnable,

                  int aStatusCode, const nsAString& aCustomMsg)

 {

   MOZ_ASSERT(aBluetoothReplyRunnable, "Reply runnable is nullptr");

   BT_LOGR("error code(%d)", aStatusCode);

   nsAutoString replyError;

   replyError.Assign(aCustomMsg);

   if (aStatusCode == BT_STATUS_BUSY) {

     replyError.AppendLiteral(":BT_STATUS_BUSY");

   } else if (aStatusCode == BT_STATUS_NOT_READY) {

     replyError.AppendLiteral(":BT_STATUS_NOT_READY");

   } else if (aStatusCode == BT_STATUS_DONE) {

     replyError.AppendLiteral(":BT_STATUS_DONE");

   } else if (aStatusCode == BT_STATUS_AUTH_FAILURE) {

     replyError.AppendLiteral(":BT_STATUS_AUTH_FAILURE");

   } else if (aStatusCode == BT_STATUS_RMT_DEV_DOWN) {

     replyError.AppendLiteral(":BT_STATUS_RMT_DEV_DOWN");

   } else if (aStatusCode == BT_STATUS_FAIL) {

     replyError.AppendLiteral(":BT_STATUS_FAIL");

   }

   DispatchBluetoothReply(aBluetoothReplyRunnable, BluetoothValue(true),

                          replyError);

 }

 /**

  *  Member functions

  */

 BluetoothServiceBluedroid::BluetoothServiceBluedroid()

 {

   if (!EnsureBluetoothHalLoad()) {

     BT_LOGR("Error! Failed to load bluedroid library.");

     return;

   }

   // Register all the bluedroid callbacks before enable() get called

   // It is required to register a2dp callbacks before a2dp media task starts up.

   BluetoothHfpManager::Get();

   BluetoothA2dpManager::Get();

 }

 BluetoothServiceBluedroid::~BluetoothServiceBluedroid()

 {

 }

 nsresult

 BluetoothServiceBluedroid::StartInternal()

 {

   MOZ_ASSERT(NS_IsMainThread());

   nsresult ret = StartStopGonkBluetooth(true);

   if (NS_FAILED(ret)) {

     nsRefPtr<nsRunnable> runnable =

       new BluetoothService::ToggleBtAck(false);

     if (NS_FAILED(NS_DispatchToMainThread(runnable))) {

       BT_WARNING("Failed to dispatch to main thread!");

     }

     BT_LOGR("Error");

   }

   return ret;

 }

 nsresult

 BluetoothServiceBluedroid::StopInternal()

 {

   MOZ_ASSERT(NS_IsMainThread());

   nsresult ret = StartStopGonkBluetooth(false);

   if (NS_FAILED(ret)) {

     nsRefPtr<nsRunnable> runnable =

       new BluetoothService::ToggleBtAck(true);

     if (NS_FAILED(NS_DispatchToMainThread(runnable))) {

       BT_WARNING("Failed to dispatch to main thread!");

     }

     BT_LOGR("Error");

   }

   return ret;

 }

 nsresult

 BluetoothServiceBluedroid::GetDefaultAdapterPathInternal(

   BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   nsRefPtr<BluetoothReplyRunnable> runnable(aRunnable);

   BluetoothValue v = InfallibleTArray<BluetoothNamedValue>();

   BT_APPEND_NAMED_VALUE(v.get_ArrayOfBluetoothNamedValue(),

                         "Address", sAdapterBdAddress);

   BT_APPEND_NAMED_VALUE(v.get_ArrayOfBluetoothNamedValue(),

                         "Name", sAdapterBdName);

   BT_APPEND_NAMED_VALUE(v.get_ArrayOfBluetoothNamedValue(),

                         "Discoverable", sAdapterDiscoverable);

   BT_APPEND_NAMED_VALUE(v.get_ArrayOfBluetoothNamedValue(),

                         "DiscoverableTimeout", sAdapterDiscoverableTimeout);

   BT_APPEND_NAMED_VALUE(v.get_ArrayOfBluetoothNamedValue(),

                         "Devices", sAdapterBondedAddressArray);

   nsAutoString replyError;

   DispatchBluetoothReply(runnable.get(), v, replyError);

   unused << runnable.forget(); // picked up in DispatchBluetoothReply

   return NS_OK;

 }

 nsresult

 BluetoothServiceBluedroid::GetConnectedDevicePropertiesInternal(

   uint16_t aServiceUuid, BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   if (!IsReady()) {

     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);

     return NS_OK;

   }

   BluetoothProfileManagerBase* profile =

     BluetoothUuidHelper::GetBluetoothProfileManager(aServiceUuid);

   if (!profile) {

     InfallibleTArray<BluetoothNamedValue> emptyArr;

     DispatchBluetoothReply(aRunnable, emptyArr,

                            NS_LITERAL_STRING(ERR_UNKNOWN_PROFILE));

     return NS_OK;

   }

   nsTArray<nsString> deviceAddresses;

   if (profile->IsConnected()) {

     nsString address;

     profile->GetAddress(address);

     deviceAddresses.AppendElement(address);

   }

   int requestedDeviceCount = deviceAddresses.Length();

   if (requestedDeviceCount == 0) {

     InfallibleTArray<BluetoothNamedValue> emptyArr;

     DispatchBluetoothReply(aRunnable, emptyArr, EmptyString());

     return NS_OK;

   }

   for (int i = 0; i < requestedDeviceCount; i++) {

     // Retrieve all properties of devices

     bt_bdaddr_t addressType;

     StringToBdAddressType(deviceAddresses[i], &addressType);

     int ret = sBtInterface->get_remote_device_properties(&addressType);

     if (ret != BT_STATUS_SUCCESS) {

       DispatchBluetoothReply(aRunnable, BluetoothValue(true),

                              NS_LITERAL_STRING("GetConnectedDeviceFailed"));

       return NS_OK;

     }

   }

   sRequestedDeviceCountArray.AppendElement(requestedDeviceCount);

   sGetDeviceRunnableArray.AppendElement(aRunnable);

   return NS_OK;

 }

 nsresult

 BluetoothServiceBluedroid::GetPairedDevicePropertiesInternal(

   const nsTArray<nsString>& aDeviceAddress, BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   if (!IsReady()) {

     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);

     return NS_OK;

   }

   int requestedDeviceCount = aDeviceAddress.Length();

   if (requestedDeviceCount == 0) {

     InfallibleTArray<BluetoothNamedValue> emptyArr;

     DispatchBluetoothReply(aRunnable, BluetoothValue(emptyArr), EmptyString());

     return NS_OK;

   }

   for (int i = 0; i < requestedDeviceCount; i++) {

     // Retrieve all properties of devices

     bt_bdaddr_t addressType;

     StringToBdAddressType(aDeviceAddress[i], &addressType);

     int ret = sBtInterface->get_remote_device_properties(&addressType);

     if (ret != BT_STATUS_SUCCESS) {

       DispatchBluetoothReply(aRunnable, BluetoothValue(true),

                              NS_LITERAL_STRING("GetPairedDeviceFailed"));

       return NS_OK;

     }

   }

   sRequestedDeviceCountArray.AppendElement(requestedDeviceCount);

   sGetDeviceRunnableArray.AppendElement(aRunnable);

   return NS_OK;

 }

 nsresult

 BluetoothServiceBluedroid::StartDiscoveryInternal(

   BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   if (!IsReady()) {

     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);

     return NS_OK;

   }

   int ret = sBtInterface->start_discovery();

   if (ret != BT_STATUS_SUCCESS) {

     ReplyStatusError(aRunnable, ret, NS_LITERAL_STRING("StartDiscovery"));

     return NS_OK;

   }

   sChangeDiscoveryRunnableArray.AppendElement(aRunnable);

   return NS_OK;

 }

 nsresult

 BluetoothServiceBluedroid::StopDiscoveryInternal(

   BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   if (!IsReady()) {

     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);

     return NS_OK;

   }

   int ret = sBtInterface->cancel_discovery();

   if (ret != BT_STATUS_SUCCESS) {

     ReplyStatusError(aRunnable, ret, NS_LITERAL_STRING("StopDiscovery"));

     return NS_OK;

   }

   sChangeDiscoveryRunnableArray.AppendElement(aRunnable);

   return NS_OK;

 }

 nsresult

 BluetoothServiceBluedroid::SetProperty(BluetoothObjectType aType,

                                        const BluetoothNamedValue& aValue,

                                        BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   if (!IsReady()) {

     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);

     return NS_OK;

   }

   const nsString propName = aValue.name();

   bt_property_t prop;

   bt_scan_mode_t scanMode;

   nsCString str;

   // For Bluedroid, it's necessary to check property name for SetProperty

   if (propName.EqualsLiteral("Name")) {

     prop.type = BT_PROPERTY_BDNAME;

   } else if (propName.EqualsLiteral("Discoverable")) {

     prop.type = BT_PROPERTY_ADAPTER_SCAN_MODE;

   } else if (propName.EqualsLiteral("DiscoverableTimeout")) {

     prop.type = BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT;

   } else {

     BT_LOGR("Warning: Property type is not supported yet, type: %d", prop.type);

   }

   if (aValue.value().type() == BluetoothValue::Tuint32_t) {

     // Set discoverable timeout

     prop.val = (void*)aValue.value().get_uint32_t();

   } else if (aValue.value().type() == BluetoothValue::TnsString) {

     // Set name

     str = NS_ConvertUTF16toUTF8(aValue.value().get_nsString());

     const char* name = str.get();

     prop.val = (void*)name;

     prop.len = strlen(name);

   } else if (aValue.value().type() == BluetoothValue::Tbool) {

     scanMode = aValue.value().get_bool() ?

                  BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE :

                  BT_SCAN_MODE_CONNECTABLE;

     prop.val = (void*)&scanMode;

     prop.len = sizeof(scanMode);

   } else {

     BT_LOGR("SetProperty but the property cannot be recognized correctly.");

     return NS_OK;

   }

   sSetPropertyRunnableArray.AppendElement(aRunnable);

   int ret = sBtInterface->set_adapter_property(&prop);

   if (ret != BT_STATUS_SUCCESS) {

     ReplyStatusError(aRunnable, ret, NS_LITERAL_STRING("SetProperty"));

   }

   return NS_OK;

 }

 nsresult

 BluetoothServiceBluedroid::GetServiceChannel(

   const nsAString& aDeviceAddress,

   const nsAString& aServiceUuid,

   BluetoothProfileManagerBase* aManager)

 {

   return NS_OK;

 }

 bool

 BluetoothServiceBluedroid::UpdateSdpRecords(

   const nsAString& aDeviceAddress,

   BluetoothProfileManagerBase* aManager)

 {

   return true;

 }

 nsresult

 BluetoothServiceBluedroid::CreatePairedDeviceInternal(

   const nsAString& aDeviceAddress, int aTimeout,

   BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   if (!IsReady()) {

     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);

     return NS_OK;

   }

   bt_bdaddr_t remoteAddress;

   StringToBdAddressType(aDeviceAddress, &remoteAddress);

   int ret = sBtInterface->create_bond(&remoteAddress);

   if (ret != BT_STATUS_SUCCESS) {

     ReplyStatusError(aRunnable, ret, NS_LITERAL_STRING("CreatedPairedDevice"));

   } else {

     sBondingRunnableArray.AppendElement(aRunnable);

   }

   return NS_OK;

 }

 nsresult

 BluetoothServiceBluedroid::RemoveDeviceInternal(

   const nsAString& aDeviceAddress, BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   if (!IsReady()) {

     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);

     return NS_OK;

   }

   bt_bdaddr_t remoteAddress;

   StringToBdAddressType(aDeviceAddress, &remoteAddress);

   int ret = sBtInterface->remove_bond(&remoteAddress);

   if (ret != BT_STATUS_SUCCESS) {

     ReplyStatusError(aRunnable, ret,

                      NS_LITERAL_STRING("RemoveDevice"));

   } else {

     sUnbondingRunnableArray.AppendElement(aRunnable);

   }

   return NS_OK;

 }

 bool

 BluetoothServiceBluedroid::SetPinCodeInternal(

   const nsAString& aDeviceAddress, const nsAString& aPinCode,

   BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   if (!IsReady()) {

     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);

     return false;

   }

   bt_bdaddr_t remoteAddress;

   StringToBdAddressType(aDeviceAddress, &remoteAddress);

   int ret = sBtInterface->pin_reply(

       &remoteAddress, true, aPinCode.Length(),

       (bt_pin_code_t*)NS_ConvertUTF16toUTF8(aPinCode).get());

   if (ret != BT_STATUS_SUCCESS) {

     ReplyStatusError(aRunnable, ret, NS_LITERAL_STRING("SetPinCode"));

   } else {

     DispatchBluetoothReply(aRunnable, BluetoothValue(true), EmptyString());

   }

   return true;

 }

 bool

 BluetoothServiceBluedroid::SetPasskeyInternal(

   const nsAString& aDeviceAddress, uint32_t aPasskey,

   BluetoothReplyRunnable* aRunnable)

 {

   return true;

 }

 bool

 BluetoothServiceBluedroid::SetPairingConfirmationInternal(

   const nsAString& aDeviceAddress, bool aConfirm,

   BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   if (!IsReady()) {

     NS_NAMED_LITERAL_STRING(errorStr, "Bluetooth service is not ready yet!");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr);

     return false;

   }

   bt_bdaddr_t remoteAddress;

   StringToBdAddressType(aDeviceAddress, &remoteAddress);

   int ret = sBtInterface->ssp_reply(&remoteAddress, (bt_ssp_variant_t)0,

                                     aConfirm, 0);

   if (ret != BT_STATUS_SUCCESS) {

     ReplyStatusError(aRunnable, ret,

                      NS_LITERAL_STRING("SetPairingConfirmation"));

   } else {

     DispatchBluetoothReply(aRunnable, BluetoothValue(true), EmptyString());

   }

   return true;

 }

 bool

 BluetoothServiceBluedroid::SetAuthorizationInternal(

   const nsAString& aDeviceAddress, bool aAllow,

   BluetoothReplyRunnable* aRunnable)

 {

   return true;

 }

 nsresult

 BluetoothServiceBluedroid::PrepareAdapterInternal()

 {

   return NS_OK;

 }

 static void

 NextBluetoothProfileController()

 {

   MOZ_ASSERT(NS_IsMainThread());

   // First, remove the task at the front which has been already done.

   NS_ENSURE_FALSE_VOID(sControllerArray.IsEmpty());

   sControllerArray.RemoveElementAt(0);

   // Re-check if the task array is empty, if it's not, the next task will begin.

   NS_ENSURE_FALSE_VOID(sControllerArray.IsEmpty());

   sControllerArray[0]->StartSession();

 }

 static void

 ConnectDisconnect(bool aConnect, const nsAString& aDeviceAddress,

                   BluetoothReplyRunnable* aRunnable,

                   uint16_t aServiceUuid, uint32_t aCod = 0)

 {

   MOZ_ASSERT(NS_IsMainThread());

   MOZ_ASSERT(aRunnable);

   BluetoothProfileController* controller =

     new BluetoothProfileController(aConnect, aDeviceAddress, aRunnable,

                                    NextBluetoothProfileController,

                                    aServiceUuid, aCod);

   sControllerArray.AppendElement(controller);

   /**

    * If the request is the first element of the quene, start from here. Note

    * that other request is pushed into the quene and is popped out after the

    * first one is completed. See NextBluetoothProfileController() for details.

    */

   if (sControllerArray.Length() == 1) {

     sControllerArray[0]->StartSession();

   }

 }

 const bt_interface_t*

 BluetoothServiceBluedroid::GetBluetoothInterface()

 {

   return sBtInterface;

 }

 void

 BluetoothServiceBluedroid::Connect(const nsAString& aDeviceAddress,

                                    uint32_t aCod,

                                    uint16_t aServiceUuid,

                                    BluetoothReplyRunnable* aRunnable)

 {

   ConnectDisconnect(true, aDeviceAddress, aRunnable, aServiceUuid, aCod);

 }

 bool

 BluetoothServiceBluedroid::IsConnected(uint16_t aProfileId)

 {

   return true;

 }

 void

 BluetoothServiceBluedroid::Disconnect(

   const nsAString& aDeviceAddress, uint16_t aServiceUuid,

   BluetoothReplyRunnable* aRunnable)

 {

   ConnectDisconnect(false, aDeviceAddress, aRunnable, aServiceUuid);

 }

 void

 BluetoothServiceBluedroid::SendFile(const nsAString& aDeviceAddress,

                                     BlobParent* aBlobParent,

                                     BlobChild* aBlobChild,

                                     BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   // Currently we only support one device sending one file at a time,

   // so we don't need aDeviceAddress here because the target device

   // has been determined when calling 'Connect()'. Nevertheless, keep

   // it for future use.

   BluetoothOppManager* opp = BluetoothOppManager::Get();

   nsAutoString errorStr;

   if (!opp || !opp->SendFile(aDeviceAddress, aBlobParent)) {

     errorStr.AssignLiteral("Calling SendFile() failed");

   }

   DispatchBluetoothReply(aRunnable, BluetoothValue(true), errorStr);

 }

 void

 BluetoothServiceBluedroid::SendFile(const nsAString& aDeviceAddress,

                                     nsIDOMBlob* aBlob,

                                     BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   // Currently we only support one device sending one file at a time,

   // so we don't need aDeviceAddress here because the target device

   // has been determined when calling 'Connect()'. Nevertheless, keep

   // it for future use.

   BluetoothOppManager* opp = BluetoothOppManager::Get();

   nsAutoString errorStr;

   if (!opp || !opp->SendFile(aDeviceAddress, aBlob)) {

     errorStr.AssignLiteral("Calling SendFile() failed");

   }

   DispatchBluetoothReply(aRunnable, BluetoothValue(true), errorStr);

 }

 void

 BluetoothServiceBluedroid::StopSendingFile(const nsAString& aDeviceAddress,

                                            BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   // Currently we only support one device sending one file at a time,

   // so we don't need aDeviceAddress here because the target device

   // has been determined when calling 'Connect()'. Nevertheless, keep

   // it for future use.

   BluetoothOppManager* opp = BluetoothOppManager::Get();

   nsAutoString errorStr;

   if (!opp || !opp->StopSendingFile()) {

     errorStr.AssignLiteral("Calling StopSendingFile() failed");

   }

   DispatchBluetoothReply(aRunnable, BluetoothValue(true), errorStr);

 }

 void

 BluetoothServiceBluedroid::ConfirmReceivingFile(

   const nsAString& aDeviceAddress, bool aConfirm,

   BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread(), "Must be called from main thread!");

   // Currently we only support one device sending one file at a time,

   // so we don't need aDeviceAddress here because the target device

   // has been determined when calling 'Connect()'. Nevertheless, keep

   // it for future use.

   BluetoothOppManager* opp = BluetoothOppManager::Get();

   nsAutoString errorStr;

   if (!opp || !opp->ConfirmReceivingFile(aConfirm)) {

     errorStr.AssignLiteral("Calling ConfirmReceivingFile() failed");

   }

   DispatchBluetoothReply(aRunnable, BluetoothValue(true), errorStr);

 }

 void

 BluetoothServiceBluedroid::ConnectSco(BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();

   if (!hfp || !hfp->ConnectSco()) {

     NS_NAMED_LITERAL_STRING(replyError, "Calling ConnectSco() failed");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), replyError);

     return;

   }

   DispatchBluetoothReply(aRunnable, BluetoothValue(true), EmptyString());

 }

 void

 BluetoothServiceBluedroid::DisconnectSco(BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();

   if (!hfp || !hfp->DisconnectSco()) {

     NS_NAMED_LITERAL_STRING(replyError, "Calling DisconnectSco() failed");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), replyError);

     return;

   }

   DispatchBluetoothReply(aRunnable, BluetoothValue(true), EmptyString());

 }

 void

 BluetoothServiceBluedroid::IsScoConnected(BluetoothReplyRunnable* aRunnable)

 {

   MOZ_ASSERT(NS_IsMainThread());

   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();

   if (!hfp) {

     NS_NAMED_LITERAL_STRING(replyError, "Fail to get BluetoothHfpManager");

     DispatchBluetoothReply(aRunnable, BluetoothValue(), replyError);

     return;

   }

   DispatchBluetoothReply(aRunnable, hfp->IsScoConnected(), EmptyString());

 }

 void

 BluetoothServiceBluedroid::SendMetaData(const nsAString& aTitle,

                                         const nsAString& aArtist,

                                         const nsAString& aAlbum,

                                         int64_t aMediaNumber,

                                         int64_t aTotalMediaCount,

                                         int64_t aDuration,

                                         BluetoothReplyRunnable* aRunnable)

 {

   BluetoothA2dpManager* a2dp = BluetoothA2dpManager::Get();

   if (a2dp) {

     a2dp->UpdateMetaData(aTitle, aArtist, aAlbum, aMediaNumber,

                          aTotalMediaCount, aDuration);

   }

   DispatchBluetoothReply(aRunnable, BluetoothValue(true), EmptyString());

 }

 void

 BluetoothServiceBluedroid::SendPlayStatus(

   int64_t aDuration, int64_t aPosition,

   const nsAString& aPlayStatus,

   BluetoothReplyRunnable* aRunnable)

 {

   BluetoothA2dpManager* a2dp = BluetoothA2dpManager::Get();

   if (a2dp) {

     ControlPlayStatus playStatus =

       PlayStatusStringToControlPlayStatus(aPlayStatus);

     a2dp->UpdatePlayStatus(aDuration, aPosition, playStatus);

   }

   DispatchBluetoothReply(aRunnable, BluetoothValue(true), EmptyString());

 }

 void

 BluetoothServiceBluedroid::UpdatePlayStatus(

   uint32_t aDuration, uint32_t aPosition, ControlPlayStatus aPlayStatus)

 {

   // We don't need this function for bluedroid.

   // In bluez, it only calls dbus api

   // But it does not update BluetoothA2dpManager member fields

   MOZ_ASSERT(false);

 }

 nsresult

 BluetoothServiceBluedroid::SendSinkMessage(const nsAString& aDeviceAddresses,

                                            const nsAString& aMessage)

 {

   return NS_OK;

 }

 nsresult

 BluetoothServiceBluedroid::SendInputMessage(const nsAString& aDeviceAddresses,

                                             const nsAString& aMessage)

 {

   return NS_OK;

 }

 void

 BluetoothServiceBluedroid::AnswerWaitingCall(BluetoothReplyRunnable* aRunnable)

 {

 }

 void

 BluetoothServiceBluedroid::IgnoreWaitingCall(BluetoothReplyRunnable* aRunnable)

 {

 }

 void

 BluetoothServiceBluedroid::ToggleCalls(BluetoothReplyRunnable* aRunnable)

 {

 }