Backed out changeset a74d1c644c84 (bug 1153796)
authorCarsten "Tomcat" Book <cbook@mozilla.com>
Wed, 15 Apr 2015 11:32:16 +0200
changeset 269104 d0ee6524d4ce2512611650caa9a185db17a0fcf6
parent 269103 f1cc9e12a4154a758366d211ef1d0fd57588983f
child 269105 a1ecd8ddd186bad3ec972f00e7e7fc1c09cec946
push id4830
push userjlund@mozilla.com
push dateMon, 29 Jun 2015 20:18:48 +0000
treeherdermozilla-beta@4c2175bb0420 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1153796
milestone40.0a1
backs outa74d1c644c84c5e5b5062bff70860dc0b2763533
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out changeset a74d1c644c84 (bug 1153796)
dom/bluetooth/BluetoothInterface.cpp
dom/bluetooth/BluetoothInterface.h
dom/bluetooth/bluedroid/BluetoothDaemonInterface.cpp
dom/bluetooth/bluedroid/BluetoothDaemonInterface.h
dom/bluetooth/bluedroid/BluetoothHALInterface.cpp
dom/bluetooth/bluedroid/BluetoothHALInterface.h
dom/bluetooth/bluetooth1/BluetoothInterface.cpp
dom/bluetooth/bluetooth1/BluetoothInterface.h
dom/bluetooth/moz.build
--- a/dom/bluetooth/BluetoothInterface.cpp
+++ b/dom/bluetooth/BluetoothInterface.cpp
@@ -125,75 +125,46 @@ BluetoothNotificationHandler::~Bluetooth
 
 // Interface
 //
 
 BluetoothInterface*
 BluetoothInterface::GetInstance()
 {
 #if ANDROID_VERSION >= 17
-  /* We pick a default backend from the available ones. The options are
-   * ordered by preference. If a backend is supported but not available
-   * on the current system, we pick the next one. The selected default
-   * can be overriden manually by storing the respective string in the
-   * system property 'ro.moz.bluetooth.backend'.
+  /* We pick a default backend from the available ones. The branches
+   * are ordered by preference.
    */
-
-  static const char* const sDefaultBackend[] = {
-#if MOZ_B2G_BT_API_V2
 #ifdef MOZ_B2G_BT_BLUEDROID
-    "bluedroid",
-#endif
-#ifdef MOZ_B2G_BT_DAEMON
-    "bluetoothd",
-#endif
+  static const char sDefaultBackend[] = "bluedroid";
 #else
 #ifdef MOZ_B2G_BT_DAEMON
-    "bluetoothd",
-#endif
-#ifdef MOZ_B2G_BT_BLUEDROID
-    "bluedroid",
+  static const char sDefaultBackend[] = "bluetoothd";
+#else
+  static const char* const sDefaultBackend = nullptr;
 #endif
 #endif
-    nullptr // no default backend; must be final element in array
-  };
 
-  const char* defaultBackend;
-
-  for (size_t i = 0; i < MOZ_ARRAY_LENGTH(sDefaultBackend); ++i) {
-
-    /* select current backend */
-    defaultBackend = sDefaultBackend[i];
-
-    if (defaultBackend) {
-      if (!strcmp(defaultBackend, "bluetoothd") &&
-          access("/init.bluetooth.rc", F_OK) == -1) {
-        continue; /* bluetoothd not available */
-      }
-    }
-    break;
-  }
+  /* Here's where we decide which implementation to use. Currently
+   * there is only Bluedroid and the Bluetooth daemon, but others are
+   * possible. Having multiple interfaces built-in and selecting the
+   * correct one at runtime is also an option.
+   */
 
   char value[PROPERTY_VALUE_MAX];
   int len;
 
-  len = property_get("ro.moz.bluetooth.backend", value, defaultBackend);
+  len = property_get("ro.moz.bluetooth.backend", value, sDefaultBackend);
   if (len < 0) {
     BT_WARNING("No Bluetooth backend available.");
     return nullptr;
   }
 
   const nsDependentCString backend(value, len);
 
-  /* Here's where we decide which implementation to use. Currently
-   * there is only Bluedroid and the Bluetooth daemon, but others are
-   * possible. Having multiple interfaces built-in and selecting the
-   * correct one at runtime is also an option.
-   */
-
 #ifdef MOZ_B2G_BT_BLUEDROID
   if (backend.LowerCaseEqualsLiteral("bluedroid")) {
     return BluetoothHALInterface::GetInstance();
   } else
 #endif
 #ifdef MOZ_B2G_BT_DAEMON
   if (backend.LowerCaseEqualsLiteral("bluetoothd")) {
     return BluetoothDaemonInterface::GetInstance();
--- a/dom/bluetooth/BluetoothInterface.h
+++ b/dom/bluetooth/BluetoothInterface.h
@@ -491,16 +491,18 @@ protected:
 
 //
 // GATT Interface
 //
 
 class BluetoothGattClientNotificationHandler
 {
 public:
+  virtual ~BluetoothGattClientNotificationHandler();
+
   virtual void
   RegisterClientNotification(BluetoothGattStatus aStatus,
                              int aClientIf,
                              const BluetoothUuid& aAppUuid)
   { }
 
   virtual void
   ScanResultNotification(const nsAString& aBdAddr,
@@ -519,17 +521,16 @@ public:
   DisconnectNotification(int aConnId,
                          BluetoothGattStatus aStatus,
                          int aClientIf,
                          const nsAString& aBdAddr)
   { }
 
   virtual void
   SearchCompleteNotification(int aConnId, BluetoothGattStatus aStatus) { }
-
   virtual void
   SearchResultNotification(int aConnId,
                            const BluetoothGattServiceId& aServiceId)
   { }
 
   virtual void
   GetCharacteristicNotification(int aConnId,
                                 BluetoothGattStatus aStatus,
@@ -600,18 +601,16 @@ public:
   { }
 
   virtual void
   ListenNotification(BluetoothGattStatus aStatus, int aServerIf) { }
 
 protected:
   BluetoothGattClientNotificationHandler()
   { }
-
-  virtual ~BluetoothGattClientNotificationHandler();
 };
 
 class BluetoothGattServerNotificationHandler
 {
 public:
   virtual ~BluetoothGattServerNotificationHandler();
   // TODO: Add server notifications
 
@@ -632,16 +631,18 @@ protected:
   { }
 };
 
 class BluetoothGattClientResultHandler
 {
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BluetoothGattClientResultHandler)
 
+  virtual ~BluetoothGattClientResultHandler() { }
+
   virtual void OnError(BluetoothStatus aStatus)
   {
     BT_WARNING("Received error code %d", (int)aStatus);
   }
 
   virtual void RegisterClient() { }
   virtual void UnregisterClient() { }
 
@@ -666,38 +667,34 @@ public:
   virtual void ExecuteWrite() { }
 
   virtual void RegisterNotification() { }
   virtual void DeregisterNotification() { }
 
   virtual void ReadRemoteRssi() { }
   virtual void GetDeviceType() { }
   virtual void SetAdvData() { }
-
-protected:
-  virtual ~BluetoothGattClientResultHandler() { }
 };
 
 // TODO: Add GattServerResultHandler
 
 class BluetoothGattResultHandler
 {
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BluetoothGattResultHandler)
 
+  virtual ~BluetoothGattResultHandler() { }
+
   virtual void OnError(BluetoothStatus aStatus)
   {
     BT_WARNING("Received error code %d", (int)aStatus);
   }
 
   virtual void Init() { }
   virtual void Cleanup() { }
-
-protected:
-  virtual ~BluetoothGattResultHandler() { }
 };
 
 class BluetoothGattClientInterface
 {
 public:
   /* Register / Unregister */
   virtual void RegisterClient(const BluetoothUuid& aUuid,
                               BluetoothGattClientResultHandler* aRes) = 0;
--- a/dom/bluetooth/bluedroid/BluetoothDaemonInterface.cpp
+++ b/dom/bluetooth/bluedroid/BluetoothDaemonInterface.cpp
@@ -2532,15 +2532,19 @@ BluetoothDaemonInterface::GetBluetoothAv
     return mAvrcpInterface;
   }
 
   mAvrcpInterface = new BluetoothDaemonAvrcpInterface(mProtocol);
 
   return mAvrcpInterface;
 }
 
+#ifdef MOZ_B2G_BT_API_V2
 BluetoothGattInterface*
 BluetoothDaemonInterface::GetBluetoothGattInterface()
 {
   return nullptr;
 }
+#else
+// TODO: Support GATT
+#endif
 
 END_BLUETOOTH_NAMESPACE
--- a/dom/bluetooth/bluedroid/BluetoothDaemonInterface.h
+++ b/dom/bluetooth/bluedroid/BluetoothDaemonInterface.h
@@ -109,17 +109,22 @@ public:
   void ReadEnergyInfo(BluetoothResultHandler* aRes);
 
   /* Profile Interfaces */
 
   BluetoothSocketInterface* GetBluetoothSocketInterface() override;
   BluetoothHandsfreeInterface* GetBluetoothHandsfreeInterface() override;
   BluetoothA2dpInterface* GetBluetoothA2dpInterface() override;
   BluetoothAvrcpInterface* GetBluetoothAvrcpInterface() override;
+
+#ifdef MOZ_B2G_BT_API_V2
   BluetoothGattInterface* GetBluetoothGattInterface() override;
+#else
+// TODO: Support GATT
+#endif
 
 protected:
   enum Channel {
     LISTEN_SOCKET,
     CMD_CHANNEL,
     NTF_CHANNEL
   };
 
--- a/dom/bluetooth/bluedroid/BluetoothHALInterface.cpp
+++ b/dom/bluetooth/bluedroid/BluetoothHALInterface.cpp
@@ -1074,20 +1074,19 @@ BluetoothHALInterface::GetBluetoothA2dpI
 }
 
 BluetoothAvrcpInterface*
 BluetoothHALInterface::GetBluetoothAvrcpInterface()
 {
   return GetProfileInterface<BluetoothAvrcpHALInterface>();
 }
 
+#ifdef MOZ_B2G_BT_API_V2
 BluetoothGattInterface*
 BluetoothHALInterface::GetBluetoothGattInterface()
 {
-#ifdef MOZ_B2G_BT_API_V2
   return GetProfileInterface<BluetoothGattHALInterface>();
+}
 #else
-  // TODO: Support GATT
-  return nullptr;
+// TODO: Support GATT
 #endif
-}
 
 END_BLUETOOTH_NAMESPACE
--- a/dom/bluetooth/bluedroid/BluetoothHALInterface.h
+++ b/dom/bluetooth/bluedroid/BluetoothHALInterface.h
@@ -95,17 +95,22 @@ public:
   void ReadEnergyInfo(BluetoothResultHandler* aRes);
 
   /* Profile Interfaces */
 
   BluetoothSocketInterface* GetBluetoothSocketInterface();
   BluetoothHandsfreeInterface* GetBluetoothHandsfreeInterface();
   BluetoothA2dpInterface* GetBluetoothA2dpInterface();
   BluetoothAvrcpInterface* GetBluetoothAvrcpInterface();
+
+#ifdef MOZ_B2G_BT_API_V2
   BluetoothGattInterface* GetBluetoothGattInterface();
+#else
+// TODO: Support GATT
+#endif
 
 protected:
   BluetoothHALInterface(const bt_interface_t* aInterface);
   ~BluetoothHALInterface();
 
 private:
   template <class T>
   T* CreateProfileInterface();
new file mode 100644
--- /dev/null
+++ b/dom/bluetooth/bluetooth1/BluetoothInterface.cpp
@@ -0,0 +1,179 @@
+/* -*- Mode: c++; c-basic-offset: 3; indent-tabs-mode: nil; tab-width: 40 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "BluetoothInterface.h"
+#if ANDROID_VERSION >= 17
+#include <cutils/properties.h>
+#endif
+#ifdef MOZ_B2G_BT_BLUEDROID
+#include "BluetoothHALInterface.h"
+#endif
+#ifdef MOZ_B2G_BT_DAEMON
+#include "BluetoothDaemonInterface.h"
+#endif
+
+BEGIN_BLUETOOTH_NAMESPACE
+
+//
+// Socket Interface
+//
+
+BluetoothSocketInterface::~BluetoothSocketInterface()
+{ }
+
+//
+// Handsfree Interface
+//
+
+// Notification handling
+//
+
+BluetoothHandsfreeNotificationHandler::
+  ~BluetoothHandsfreeNotificationHandler()
+{ }
+
+// Interface
+//
+
+BluetoothHandsfreeInterface::BluetoothHandsfreeInterface()
+{ }
+
+BluetoothHandsfreeInterface::~BluetoothHandsfreeInterface()
+{ }
+
+//
+// Bluetooth Advanced Audio Interface
+//
+
+// Notification handling
+//
+
+BluetoothA2dpNotificationHandler::~BluetoothA2dpNotificationHandler()
+{ }
+
+// Interface
+//
+
+BluetoothA2dpInterface::BluetoothA2dpInterface()
+{ }
+
+BluetoothA2dpInterface::~BluetoothA2dpInterface()
+{ }
+
+//
+// Bluetooth AVRCP Interface
+//
+
+// Notification handling
+//
+
+BluetoothAvrcpNotificationHandler::~BluetoothAvrcpNotificationHandler()
+{ }
+
+// Interface
+//
+
+BluetoothAvrcpInterface::BluetoothAvrcpInterface()
+{ }
+
+BluetoothAvrcpInterface::~BluetoothAvrcpInterface()
+{ }
+
+// Notification handling
+//
+
+BluetoothNotificationHandler::~BluetoothNotificationHandler()
+{ }
+
+// Interface
+//
+
+BluetoothInterface*
+BluetoothInterface::GetInstance()
+{
+#if ANDROID_VERSION >= 17
+  /* We pick a default backend from the available ones. The options are
+   * ordered by preference. If a backend is supported but not available
+   * on the current system, we pick the next one. The selected default
+   * can be overriden manually by storing the respective string in the
+   * system property 'ro.moz.bluetooth.backend'.
+   */
+
+  static const char* const sDefaultBackend[] = {
+#ifdef MOZ_B2G_BT_DAEMON
+    "bluetoothd",
+#endif
+#ifdef MOZ_B2G_BT_BLUEDROID
+    "bluedroid",
+#endif
+    nullptr // no default backend; must be final element in array
+  };
+
+  const char* defaultBackend;
+
+  for (size_t i = 0; i < MOZ_ARRAY_LENGTH(sDefaultBackend); ++i) {
+
+    /* select current backend */
+    defaultBackend = sDefaultBackend[i];
+
+    if (defaultBackend) {
+      if (!strcmp(defaultBackend, "bluetoothd") &&
+          access("/init.bluetooth.rc", F_OK) == -1) {
+        continue; /* bluetoothd not available */
+      }
+    }
+    break;
+  }
+
+  char value[PROPERTY_VALUE_MAX];
+  int len;
+
+  len = property_get("ro.moz.bluetooth.backend", value, defaultBackend);
+  if (len < 0) {
+    BT_WARNING("No Bluetooth backend available.");
+    return nullptr;
+  }
+
+  const nsDependentCString backend(value, len);
+
+  /* Here's where we decide which implementation to use. Currently
+   * there is only Bluedroid and the Bluetooth daemon, but others are
+   * possible. Having multiple interfaces built-in and selecting the
+   * correct one at runtime is also an option.
+   */
+
+#ifdef MOZ_B2G_BT_BLUEDROID
+  if (backend.LowerCaseEqualsLiteral("bluedroid")) {
+    return BluetoothHALInterface::GetInstance();
+  } else
+#endif
+#ifdef MOZ_B2G_BT_DAEMON
+  if (backend.LowerCaseEqualsLiteral("bluetoothd")) {
+    return BluetoothDaemonInterface::GetInstance();
+  } else
+#endif
+  {
+    BT_WARNING("Bluetooth backend '%s' is unknown or not available.",
+               backend.get());
+  }
+  return nullptr;
+
+#else
+  /* Anything that's not Android 4.2 or later uses BlueZ instead. The
+   * code should actually never reach this point.
+   */
+  BT_WARNING("No Bluetooth backend available for your system.");
+  return nullptr;
+#endif
+}
+
+BluetoothInterface::BluetoothInterface()
+{ }
+
+BluetoothInterface::~BluetoothInterface()
+{ }
+
+END_BLUETOOTH_NAMESPACE
new file mode 100644
--- /dev/null
+++ b/dom/bluetooth/bluetooth1/BluetoothInterface.h
@@ -0,0 +1,691 @@
+/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_bluetooth_bluetoothinterface_h__
+#define mozilla_dom_bluetooth_bluetoothinterface_h__
+
+#include "BluetoothCommon.h"
+#include "mozilla/dom/bluetooth/BluetoothTypes.h"
+
+BEGIN_BLUETOOTH_NAMESPACE
+
+//
+// Socket Interface
+//
+
+class BluetoothSocketResultHandler
+{
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BluetoothSocketResultHandler)
+
+  virtual void OnError(BluetoothStatus aStatus)
+  {
+    BT_WARNING("Received error code %d", (int)aStatus);
+  }
+
+  virtual void Listen(int aSockFd) { }
+  virtual void Connect(int aSockFd, const nsAString& aBdAddress,
+                       int aConnectionState) { }
+  virtual void Accept(int aSockFd, const nsAString& aBdAddress,
+                      int aConnectionState) { }
+
+protected:
+  virtual ~BluetoothSocketResultHandler() { }
+};
+
+class BluetoothSocketInterface
+{
+public:
+  // Init and Cleanup is handled by BluetoothInterface
+
+  virtual void Listen(BluetoothSocketType aType,
+                      const nsAString& aServiceName,
+                      const uint8_t aServiceUuid[16],
+                      int aChannel, bool aEncrypt, bool aAuth,
+                      BluetoothSocketResultHandler* aRes) = 0;
+
+  virtual void Connect(const nsAString& aBdAddr,
+                       BluetoothSocketType aType,
+                       const uint8_t aUuid[16],
+                       int aChannel, bool aEncrypt, bool aAuth,
+                       BluetoothSocketResultHandler* aRes) = 0;
+
+  virtual void Accept(int aFd, BluetoothSocketResultHandler* aRes) = 0;
+
+  virtual void Close(BluetoothSocketResultHandler* aRes) = 0;
+
+protected:
+  virtual ~BluetoothSocketInterface();
+};
+
+//
+// Handsfree Interface
+//
+
+class BluetoothHandsfreeNotificationHandler
+{
+public:
+  virtual void
+  ConnectionStateNotification(BluetoothHandsfreeConnectionState aState,
+                              const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  AudioStateNotification(BluetoothHandsfreeAudioState aState,
+                         const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  VoiceRecognitionNotification(BluetoothHandsfreeVoiceRecognitionState aState,
+                               const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  AnswerCallNotification(const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  HangupCallNotification(const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  VolumeNotification(BluetoothHandsfreeVolumeType aType,
+                     int aVolume,
+                     const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  DialCallNotification(const nsAString& aNumber,
+                       const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  DtmfNotification(char aDtmf,
+                   const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  NRECNotification(BluetoothHandsfreeNRECState aNrec,
+                   const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  WbsNotification(BluetoothHandsfreeWbsConfig aWbs,
+                  const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  CallHoldNotification(BluetoothHandsfreeCallHoldType aChld,
+                       const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  CnumNotification(const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  CindNotification(const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  CopsNotification(const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  ClccNotification(const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  UnknownAtNotification(const nsACString& aAtString,
+                        const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  KeyPressedNotification(const nsAString& aBdAddr)
+  { }
+
+protected:
+  BluetoothHandsfreeNotificationHandler()
+  { }
+
+  virtual ~BluetoothHandsfreeNotificationHandler();
+};
+
+class BluetoothHandsfreeResultHandler
+{
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BluetoothHandsfreeResultHandler)
+
+  virtual void OnError(BluetoothStatus aStatus)
+  {
+    BT_WARNING("Received error code %d", (int)aStatus);
+  }
+
+  virtual void Init() { }
+  virtual void Cleanup() { }
+
+  virtual void Connect() { }
+  virtual void Disconnect() { }
+  virtual void ConnectAudio() { }
+  virtual void DisconnectAudio() { }
+
+  virtual void StartVoiceRecognition() { }
+  virtual void StopVoiceRecognition() { }
+
+  virtual void VolumeControl() { }
+
+  virtual void DeviceStatusNotification() { }
+
+  virtual void CopsResponse() { }
+  virtual void CindResponse() { }
+  virtual void FormattedAtResponse() { }
+  virtual void AtResponse() { }
+  virtual void ClccResponse() { }
+  virtual void PhoneStateChange() { }
+
+  virtual void ConfigureWbs() { }
+
+protected:
+  virtual ~BluetoothHandsfreeResultHandler() { }
+};
+
+class BluetoothHandsfreeInterface
+{
+public:
+  virtual void Init(
+    BluetoothHandsfreeNotificationHandler* aNotificationHandler,
+    int aMaxNumClients, BluetoothHandsfreeResultHandler* aRes) = 0;
+  virtual void Cleanup(BluetoothHandsfreeResultHandler* aRes) = 0;
+
+  /* Connect / Disconnect */
+
+  virtual void Connect(const nsAString& aBdAddr,
+                       BluetoothHandsfreeResultHandler* aRes) = 0;
+  virtual void Disconnect(const nsAString& aBdAddr,
+                          BluetoothHandsfreeResultHandler* aRes) = 0;
+  virtual void ConnectAudio(const nsAString& aBdAddr,
+                            BluetoothHandsfreeResultHandler* aRes) = 0;
+  virtual void DisconnectAudio(const nsAString& aBdAddr,
+                               BluetoothHandsfreeResultHandler* aRes) = 0;
+
+  /* Voice Recognition */
+
+  virtual void StartVoiceRecognition(const nsAString& aBdAddr,
+                                     BluetoothHandsfreeResultHandler* aRes) = 0;
+  virtual void StopVoiceRecognition(const nsAString& aBdAddr,
+                                    BluetoothHandsfreeResultHandler* aRes) = 0;
+
+  /* Volume */
+
+  virtual void VolumeControl(BluetoothHandsfreeVolumeType aType, int aVolume,
+                             const nsAString& aBdAddr,
+                             BluetoothHandsfreeResultHandler* aRes) = 0;
+
+  /* Device status */
+
+  virtual void DeviceStatusNotification(
+    BluetoothHandsfreeNetworkState aNtkState,
+    BluetoothHandsfreeServiceType aSvcType,
+    int aSignal, int aBattChg, BluetoothHandsfreeResultHandler* aRes) = 0;
+
+  /* Responses */
+
+  virtual void CopsResponse(const char* aCops, const nsAString& aBdAddr,
+                            BluetoothHandsfreeResultHandler* aRes) = 0;
+  virtual void CindResponse(int aSvc, int aNumActive, int aNumHeld,
+                            BluetoothHandsfreeCallState aCallSetupState,
+                            int aSignal, int aRoam, int aBattChg,
+                            const nsAString& aBdAddr,
+                            BluetoothHandsfreeResultHandler* aRes) = 0;
+  virtual void FormattedAtResponse(const char* aRsp, const nsAString& aBdAddr,
+                                   BluetoothHandsfreeResultHandler* aRes) = 0;
+  virtual void AtResponse(BluetoothHandsfreeAtResponse aResponseCode,
+                          int aErrorCode, const nsAString& aBdAddr,
+                          BluetoothHandsfreeResultHandler* aRes) = 0;
+  virtual void ClccResponse(int aIndex, BluetoothHandsfreeCallDirection aDir,
+                            BluetoothHandsfreeCallState aState,
+                            BluetoothHandsfreeCallMode aMode,
+                            BluetoothHandsfreeCallMptyType aMpty,
+                            const nsAString& aNumber,
+                            BluetoothHandsfreeCallAddressType aType,
+                            const nsAString& aBdAddr,
+                            BluetoothHandsfreeResultHandler* aRes) = 0;
+
+  /* Phone State */
+
+  virtual void PhoneStateChange(int aNumActive, int aNumHeld,
+                                BluetoothHandsfreeCallState aCallSetupState,
+                                const nsAString& aNumber,
+                                BluetoothHandsfreeCallAddressType aType,
+                                BluetoothHandsfreeResultHandler* aRes) = 0;
+
+  /* Wide Band Speech */
+  virtual void ConfigureWbs(const nsAString& aBdAddr,
+                            BluetoothHandsfreeWbsConfig aConfig,
+                            BluetoothHandsfreeResultHandler* aRes) = 0;
+
+protected:
+  BluetoothHandsfreeInterface();
+  virtual ~BluetoothHandsfreeInterface();
+};
+
+//
+// Bluetooth Advanced Audio Interface
+//
+
+class BluetoothA2dpNotificationHandler
+{
+public:
+  virtual void
+  ConnectionStateNotification(BluetoothA2dpConnectionState aState,
+                              const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  AudioStateNotification(BluetoothA2dpAudioState aState,
+                         const nsAString& aBdAddr)
+  { }
+
+  virtual void
+  AudioConfigNotification(const nsAString& aBdAddr,
+                          uint32_t aSampleRate,
+                          uint8_t aChannelCount)
+  { }
+
+protected:
+  BluetoothA2dpNotificationHandler()
+  { }
+
+  virtual ~BluetoothA2dpNotificationHandler();
+};
+
+class BluetoothA2dpResultHandler
+{
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BluetoothA2dpResultHandler)
+
+  virtual void OnError(BluetoothStatus aStatus)
+  {
+    BT_WARNING("Received error code %d", (int)aStatus);
+  }
+
+  virtual void Init() { }
+  virtual void Cleanup() { }
+  virtual void Connect() { }
+  virtual void Disconnect() { }
+
+protected:
+  virtual ~BluetoothA2dpResultHandler() { }
+};
+
+class BluetoothA2dpInterface
+{
+public:
+  virtual void Init(BluetoothA2dpNotificationHandler* aNotificationHandler,
+                    BluetoothA2dpResultHandler* aRes) = 0;
+  virtual void Cleanup(BluetoothA2dpResultHandler* aRes) = 0;
+
+  virtual void Connect(const nsAString& aBdAddr,
+                       BluetoothA2dpResultHandler* aRes) = 0;
+  virtual void Disconnect(const nsAString& aBdAddr,
+                          BluetoothA2dpResultHandler* aRes) = 0;
+
+protected:
+  BluetoothA2dpInterface();
+  virtual ~BluetoothA2dpInterface();
+};
+
+//
+// Bluetooth AVRCP Interface
+//
+
+class BluetoothAvrcpNotificationHandler
+{
+public:
+  virtual void
+  GetPlayStatusNotification()
+  { }
+
+  virtual void
+  ListPlayerAppAttrNotification()
+  { }
+
+  virtual void
+  ListPlayerAppValuesNotification(BluetoothAvrcpPlayerAttribute aAttrId)
+  { }
+
+  virtual void
+  GetPlayerAppValueNotification(uint8_t aNumAttrs,
+                                const BluetoothAvrcpPlayerAttribute* aAttrs)
+  { }
+
+  virtual void
+  GetPlayerAppAttrsTextNotification(uint8_t aNumAttrs,
+                                    const BluetoothAvrcpPlayerAttribute* aAttrs)
+  { }
+
+  virtual void
+  GetPlayerAppValuesTextNotification(uint8_t aAttrId, uint8_t aNumVals,
+                                     const uint8_t* aValues)
+  { }
+
+  virtual void
+  SetPlayerAppValueNotification(const BluetoothAvrcpPlayerSettings& aSettings)
+  { }
+
+  virtual void
+  GetElementAttrNotification(uint8_t aNumAttrs,
+                             const BluetoothAvrcpMediaAttribute* aAttrs)
+  { }
+
+  virtual void
+  RegisterNotificationNotification(BluetoothAvrcpEvent aEvent,
+                                   uint32_t aParam)
+  { }
+
+  virtual void
+  RemoteFeatureNotification(const nsAString& aBdAddr, unsigned long aFeatures)
+  { }
+
+  virtual void
+  VolumeChangeNotification(uint8_t aVolume, uint8_t aCType)
+  { }
+
+  virtual void
+  PassthroughCmdNotification(int aId, int aKeyState)
+  { }
+
+protected:
+  BluetoothAvrcpNotificationHandler()
+  { }
+
+  virtual ~BluetoothAvrcpNotificationHandler();
+};
+
+class BluetoothAvrcpResultHandler
+{
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BluetoothAvrcpResultHandler)
+
+  virtual void OnError(BluetoothStatus aStatus)
+  {
+    BT_WARNING("Received error code %d", (int)aStatus);
+  }
+
+  virtual void Init() { }
+  virtual void Cleanup() { }
+
+  virtual void GetPlayStatusRsp() { }
+
+  virtual void ListPlayerAppAttrRsp() { }
+  virtual void ListPlayerAppValueRsp() { }
+
+  virtual void GetPlayerAppValueRsp() { }
+  virtual void GetPlayerAppAttrTextRsp() { }
+  virtual void GetPlayerAppValueTextRsp() { }
+
+  virtual void GetElementAttrRsp() { }
+
+  virtual void SetPlayerAppValueRsp() { }
+
+  virtual void RegisterNotificationRsp() { }
+
+  virtual void SetVolume() { }
+
+protected:
+  virtual ~BluetoothAvrcpResultHandler() { }
+};
+
+class BluetoothAvrcpInterface
+{
+public:
+  virtual void Init(BluetoothAvrcpNotificationHandler* aNotificationHandler,
+                    BluetoothAvrcpResultHandler* aRes) = 0;
+  virtual void Cleanup(BluetoothAvrcpResultHandler* aRes) = 0;
+
+  virtual void GetPlayStatusRsp(ControlPlayStatus aPlayStatus,
+                                uint32_t aSongLen, uint32_t aSongPos,
+                                BluetoothAvrcpResultHandler* aRes) = 0;
+
+  virtual void ListPlayerAppAttrRsp(
+    int aNumAttr, const BluetoothAvrcpPlayerAttribute* aPAttrs,
+    BluetoothAvrcpResultHandler* aRes) = 0;
+  virtual void ListPlayerAppValueRsp(int aNumVal, uint8_t* aPVals,
+                                     BluetoothAvrcpResultHandler* aRes) = 0;
+
+  /* TODO: redesign this interface once we actually use it */
+  virtual void GetPlayerAppValueRsp(uint8_t aNumAttrs, const uint8_t* aIds,
+                                    const uint8_t* aValues,
+                                    BluetoothAvrcpResultHandler* aRes) = 0;
+  /* TODO: redesign this interface once we actually use it */
+  virtual void GetPlayerAppAttrTextRsp(int aNumAttr, const uint8_t* aIds,
+                                       const char** aTexts,
+                                       BluetoothAvrcpResultHandler* aRes) = 0;
+  /* TODO: redesign this interface once we actually use it */
+  virtual void GetPlayerAppValueTextRsp(int aNumVal, const uint8_t* aIds,
+                                        const char** aTexts,
+                                        BluetoothAvrcpResultHandler* aRes) = 0;
+
+  virtual void GetElementAttrRsp(uint8_t aNumAttr,
+                                 const BluetoothAvrcpElementAttribute* aAttr,
+                                 BluetoothAvrcpResultHandler* aRes) = 0;
+
+  virtual void SetPlayerAppValueRsp(BluetoothAvrcpStatus aRspStatus,
+                                    BluetoothAvrcpResultHandler* aRes) = 0;
+
+  virtual void RegisterNotificationRsp(
+    BluetoothAvrcpEvent aEvent, BluetoothAvrcpNotification aType,
+    const BluetoothAvrcpNotificationParam& aParam,
+    BluetoothAvrcpResultHandler* aRes) = 0;
+
+  virtual void SetVolume(uint8_t aVolume, BluetoothAvrcpResultHandler* aRes) = 0;
+
+protected:
+  BluetoothAvrcpInterface();
+  virtual ~BluetoothAvrcpInterface();
+};
+
+//
+// Bluetooth Core Interface
+//
+
+class BluetoothNotificationHandler
+{
+public:
+  virtual void AdapterStateChangedNotification(bool aState) { }
+  virtual void AdapterPropertiesNotification(
+    BluetoothStatus aStatus, int aNumProperties,
+    const BluetoothProperty* aProperties) { }
+
+  virtual void RemoteDevicePropertiesNotification(
+    BluetoothStatus aStatus, const nsAString& aBdAddr,
+    int aNumProperties, const BluetoothProperty* aProperties) { }
+
+  virtual void DeviceFoundNotification(
+    int aNumProperties, const BluetoothProperty* aProperties) { }
+
+  virtual void DiscoveryStateChangedNotification(bool aState) { }
+
+  virtual void PinRequestNotification(const nsAString& aRemoteBdAddr,
+                                      const nsAString& aBdName, uint32_t aCod) { }
+  virtual void SspRequestNotification(const nsAString& aRemoteBdAddr,
+                                      const nsAString& aBdName,
+                                      uint32_t aCod,
+                                      BluetoothSspVariant aPairingVariant,
+                                      uint32_t aPassKey) { }
+
+  virtual void BondStateChangedNotification(BluetoothStatus aStatus,
+                                            const nsAString& aRemoteBdAddr,
+                                            BluetoothBondState aState) { }
+  virtual void AclStateChangedNotification(BluetoothStatus aStatus,
+                                           const nsAString& aRemoteBdAddr,
+                                           bool aState) { }
+
+  virtual void DutModeRecvNotification(uint16_t aOpcode,
+                                       const uint8_t* aBuf, uint8_t aLen) { }
+  virtual void LeTestModeNotification(BluetoothStatus aStatus,
+                                      uint16_t aNumPackets) { }
+
+  virtual void EnergyInfoNotification(const BluetoothActivityEnergyInfo& aInfo)
+  { }
+
+protected:
+  BluetoothNotificationHandler()
+  { }
+
+  virtual ~BluetoothNotificationHandler();
+};
+
+class BluetoothResultHandler
+{
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BluetoothResultHandler)
+
+  virtual void OnError(BluetoothStatus aStatus)
+  {
+    BT_LOGR("Received error code %d", aStatus);
+  }
+
+  virtual void Init() { }
+  virtual void Cleanup() { }
+  virtual void Enable() { }
+  virtual void Disable() { }
+
+  virtual void GetAdapterProperties() { }
+  virtual void GetAdapterProperty() { }
+  virtual void SetAdapterProperty() { }
+
+  virtual void GetRemoteDeviceProperties() { }
+  virtual void GetRemoteDeviceProperty() { }
+  virtual void SetRemoteDeviceProperty() { }
+
+  virtual void GetRemoteServiceRecord() { }
+  virtual void GetRemoteServices() { }
+
+  virtual void StartDiscovery() { }
+  virtual void CancelDiscovery() { }
+
+  virtual void CreateBond() { }
+  virtual void RemoveBond() { }
+  virtual void CancelBond() { }
+
+  virtual void GetConnectionState() { }
+
+  virtual void PinReply() { }
+  virtual void SspReply() { }
+
+  virtual void DutModeConfigure() { }
+  virtual void DutModeSend() { }
+
+  virtual void LeTestMode() { }
+
+  virtual void ReadEnergyInfo() { }
+
+protected:
+  virtual ~BluetoothResultHandler() { }
+};
+
+class BluetoothInterface
+{
+public:
+  static BluetoothInterface* GetInstance();
+
+  virtual void Init(BluetoothNotificationHandler* aNotificationHandler,
+                    BluetoothResultHandler* aRes) = 0;
+  virtual void Cleanup(BluetoothResultHandler* aRes) = 0;
+
+  virtual void Enable(BluetoothResultHandler* aRes) = 0;
+  virtual void Disable(BluetoothResultHandler* aRes) = 0;
+
+  /* Adapter Properties */
+
+  virtual void GetAdapterProperties(BluetoothResultHandler* aRes) = 0;
+  virtual void GetAdapterProperty(const nsAString& aName,
+                                  BluetoothResultHandler* aRes) = 0;
+  virtual void SetAdapterProperty(const BluetoothNamedValue& aProperty,
+                                  BluetoothResultHandler* aRes) = 0;
+
+  /* Remote Device Properties */
+
+  virtual void GetRemoteDeviceProperties(const nsAString& aRemoteAddr,
+                                         BluetoothResultHandler* aRes) = 0;
+  virtual void GetRemoteDeviceProperty(const nsAString& aRemoteAddr,
+                                       const nsAString& aName,
+                                       BluetoothResultHandler* aRes) = 0;
+  virtual void SetRemoteDeviceProperty(const nsAString& aRemoteAddr,
+                                       const BluetoothNamedValue& aProperty,
+                                       BluetoothResultHandler* aRes) = 0;
+
+  /* Remote Services */
+
+  virtual void GetRemoteServiceRecord(const nsAString& aRemoteAddr,
+                                      const uint8_t aUuid[16],
+                                      BluetoothResultHandler* aRes) = 0;
+  virtual void GetRemoteServices(const nsAString& aRemoteAddr,
+                                 BluetoothResultHandler* aRes) = 0;
+
+  /* Discovery */
+
+  virtual void StartDiscovery(BluetoothResultHandler* aRes) = 0;
+  virtual void CancelDiscovery(BluetoothResultHandler* aRes) = 0;
+
+  /* Bonds */
+
+  virtual void CreateBond(const nsAString& aBdAddr,
+                          BluetoothTransport aTransport,
+                          BluetoothResultHandler* aRes) = 0;
+  virtual void RemoveBond(const nsAString& aBdAddr,
+                          BluetoothResultHandler* aRes) = 0;
+  virtual void CancelBond(const nsAString& aBdAddr,
+                          BluetoothResultHandler* aRes) = 0;
+
+  /* Connection */
+
+  virtual void GetConnectionState(const nsAString& aBdAddr,
+                                  BluetoothResultHandler* aRes) = 0;
+
+  /* Authentication */
+
+  virtual void PinReply(const nsAString& aBdAddr, bool aAccept,
+                        const nsAString& aPinCode,
+                        BluetoothResultHandler* aRes) = 0;
+
+  virtual void SspReply(const nsAString& aBdAddr,
+                        BluetoothSspVariant aVariant,
+                        bool aAccept, uint32_t aPasskey,
+                        BluetoothResultHandler* aRes) = 0;
+
+  /* DUT Mode */
+
+  virtual void DutModeConfigure(bool aEnable,
+                                BluetoothResultHandler* aRes) = 0;
+  virtual void DutModeSend(uint16_t aOpcode, uint8_t* aBuf, uint8_t aLen,
+                           BluetoothResultHandler* aRes) = 0;
+
+  /* LE Mode */
+
+  virtual void LeTestMode(uint16_t aOpcode, uint8_t* aBuf, uint8_t aLen,
+                          BluetoothResultHandler* aRes) = 0;
+
+  /* Energy Info */
+
+  virtual void ReadEnergyInfo(BluetoothResultHandler* aRes) = 0;
+
+  /* Profile Interfaces */
+
+  virtual BluetoothSocketInterface* GetBluetoothSocketInterface() = 0;
+  virtual BluetoothHandsfreeInterface* GetBluetoothHandsfreeInterface() = 0;
+  virtual BluetoothA2dpInterface* GetBluetoothA2dpInterface() = 0;
+  virtual BluetoothAvrcpInterface* GetBluetoothAvrcpInterface() = 0;
+
+protected:
+  BluetoothInterface();
+  virtual ~BluetoothInterface();
+};
+
+END_BLUETOOTH_NAMESPACE
+
+#endif
--- a/dom/bluetooth/moz.build
+++ b/dom/bluetooth/moz.build
@@ -5,31 +5,28 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 if CONFIG['MOZ_B2G_BT']:
 
     #
     # Generic code
     #
 
-    SOURCES += [
-        'BluetoothInterface.cpp'
-    ]
-
     if CONFIG['MOZ_B2G_BT_API_V2']:
         SOURCES += [
             'bluetooth2/BluetoothAdapter.cpp',
             'bluetooth2/BluetoothClassOfDevice.cpp',
             'bluetooth2/BluetoothDevice.cpp',
             'bluetooth2/BluetoothDiscoveryHandle.cpp',
             'bluetooth2/BluetoothGatt.cpp',
             'bluetooth2/BluetoothGattCharacteristic.cpp',
             'bluetooth2/BluetoothGattDescriptor.cpp',
             'bluetooth2/BluetoothGattService.cpp',
             'bluetooth2/BluetoothHidManager.cpp',
+            'bluetooth2/BluetoothInterface.cpp',
             'bluetooth2/BluetoothManager.cpp',
             'bluetooth2/BluetoothPairingHandle.cpp',
             'bluetooth2/BluetoothPairingListener.cpp',
             'bluetooth2/BluetoothProfileController.cpp',
             'bluetooth2/BluetoothReplyRunnable.cpp',
             'bluetooth2/BluetoothService.cpp',
             'bluetooth2/BluetoothUtils.cpp',
             'bluetooth2/BluetoothUuid.cpp',
@@ -47,16 +44,17 @@ if CONFIG['MOZ_B2G_BT']:
             'bluetooth2/ipc',
         ]
         DEFINES['MOZ_B2G_BT_API_V2'] = True
     else:
         SOURCES += [
             'bluetooth1/BluetoothAdapter.cpp',
             'bluetooth1/BluetoothDevice.cpp',
             'bluetooth1/BluetoothHidManager.cpp',
+            'bluetooth1/BluetoothInterface.cpp',
             'bluetooth1/BluetoothInterfaceHelpers.cpp',
             'bluetooth1/BluetoothManager.cpp',
             'bluetooth1/BluetoothProfileController.cpp',
             'bluetooth1/BluetoothPropertyContainer.cpp',
             'bluetooth1/BluetoothReplyRunnable.cpp',
             'bluetooth1/BluetoothService.cpp',
             'bluetooth1/BluetoothUtils.cpp',
             'bluetooth1/BluetoothUuid.cpp',