dom/bluetooth/BluetoothProfileController.cpp

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "BluetoothProfileController.h"
   8
   9 #include "BluetoothA2dpManager.h"
  10 #include "BluetoothHfpManager.h"
  11 #include "BluetoothHidManager.h"
  12 #include "BluetoothReplyRunnable.h"
  13 #include "BluetoothService.h"
  14 #include "BluetoothUtils.h"
  15
  16 #include "mozilla/dom/bluetooth/BluetoothTypes.h"
  17 #include "nsComponentManagerUtils.h"
  18
  19 USING_BLUETOOTH_NAMESPACE
  20
  21 #define BT_LOGR_PROFILE(mgr, msg, ...)               \
  22   do {                                               \
  23     nsCString name;                                  \
  24     mgr->GetName(name);                              \
  25     BT_LOGR("[%s] " msg, name.get(), ##__VA_ARGS__); \
  26   } while(0)
  27
  28 #define CONNECTION_TIMEOUT_MS 15000
  29
  30 class CheckProfileStatusCallback : public nsITimerCallback
  31 {
  32 public:
  33   NS_DECL_ISUPPORTS
  34   NS_DECL_NSITIMERCALLBACK
  35
  36   CheckProfileStatusCallback(BluetoothProfileController* aController)
  37     : mController(aController)
  38   {
  39     MOZ_ASSERT(aController);
  40   }
  41
  42   virtual ~CheckProfileStatusCallback()
  43   {
  44     mController = nullptr;
  45   }
  46
  47 private:
  48   nsRefPtr<BluetoothProfileController> mController;
  49 };
  50
  51 BluetoothProfileController::BluetoothProfileController(
  52                                    bool aConnect,
  53                                    const nsAString& aDeviceAddress,
  54                                    BluetoothReplyRunnable* aRunnable,
  55                                    BluetoothProfileControllerCallback aCallback,
  56                                    uint16_t aServiceUuid,
  57                                    uint32_t aCod)
  58   : mConnect(aConnect)
  59   , mDeviceAddress(aDeviceAddress)
  60   , mRunnable(aRunnable)
  61   , mCallback(aCallback)
  62   , mCurrentProfileFinished(false)
  63   , mSuccess(false)
  64   , mProfilesIndex(-1)
  65 {
  66   MOZ_ASSERT(!aDeviceAddress.IsEmpty());
  67   MOZ_ASSERT(aRunnable);
  68   MOZ_ASSERT(aCallback);
  69
  70   mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
  71   MOZ_ASSERT(mTimer);
  72
  73   mProfiles.Clear();
  74
  75   /**
  76    * If the service uuid is not specified, either connect multiple profiles
  77    * based on Cod, or disconnect all connected profiles.
  78    */
  79   if (!aServiceUuid) {
  80     mTarget.cod = aCod;
  81     SetupProfiles(false);
  82   } else {
  83     BluetoothServiceClass serviceClass =
  84       BluetoothUuidHelper::GetBluetoothServiceClass(aServiceUuid);
  85     mTarget.service = serviceClass;
  86     SetupProfiles(true);
  87   }
  88 }
  89
  90 BluetoothProfileController::~BluetoothProfileController()
  91 {
  92   mProfiles.Clear();
  93   mRunnable = nullptr;
  94   mCallback = nullptr;
  95
  96   if (mTimer) {
  97     mTimer->Cancel();
  98   }
  99 }
 100
 101 void
 102 BluetoothProfileController::AddProfileWithServiceClass(
 103                                                    BluetoothServiceClass aClass)
 104 {
 105   BluetoothProfileManagerBase* profile;
 106   switch (aClass) {
 107     case BluetoothServiceClass::HANDSFREE:
 108     case BluetoothServiceClass::HEADSET:
 109       profile = BluetoothHfpManager::Get();
 110       break;
 111     case BluetoothServiceClass::A2DP:
 112       profile = BluetoothA2dpManager::Get();
 113       break;
 114     case BluetoothServiceClass::HID:
 115       profile = BluetoothHidManager::Get();
 116       break;
 117     default:
 118       DispatchBluetoothReply(mRunnable, BluetoothValue(),
 119                              NS_LITERAL_STRING(ERR_UNKNOWN_PROFILE));
 120       mCallback();
 121       return;
 122   }
 123
 124   AddProfile(profile);
 125 }
 126
 127 void
 128 BluetoothProfileController::AddProfile(BluetoothProfileManagerBase* aProfile,
 129                                        bool aCheckConnected)
 130 {
 131   if (!aProfile) {
 132     DispatchBluetoothReply(mRunnable, BluetoothValue(),
 133                            NS_LITERAL_STRING(ERR_NO_AVAILABLE_RESOURCE));
 134     mCallback();
 135     return;
 136   }
 137
 138   if (aCheckConnected && !aProfile->IsConnected()) {
 139     BT_WARNING("The profile is not connected.");
 140     return;
 141   }
 142
 143   mProfiles.AppendElement(aProfile);
 144 }
 145
 146 void
 147 BluetoothProfileController::SetupProfiles(bool aAssignServiceClass)
 148 {
 149   MOZ_ASSERT(NS_IsMainThread());
 150
 151   /**
 152    * When a service class is assigned, only its corresponding profile is put
 153    * into array.
 154    */
 155   if (aAssignServiceClass) {
 156     AddProfileWithServiceClass(mTarget.service);
 157     return;
 158   }
 159
 160   // For a disconnect request, all connected profiles are put into array.
 161   if (!mConnect) {
 162     AddProfile(BluetoothHidManager::Get(), true);
 163     AddProfile(BluetoothA2dpManager::Get(), true);
 164     AddProfile(BluetoothHfpManager::Get(), true);
 165     return;
 166   }
 167
 168   /**
 169    * For a connect request, put multiple profiles into array and connect to
 170    * all of them sequencely.
 171    */
 172   bool hasAudio = HAS_AUDIO(mTarget.cod);
 173   bool hasRendering = HAS_RENDERING(mTarget.cod);
 174   bool isPeripheral = IS_PERIPHERAL(mTarget.cod);
 175   bool isRemoteControl = IS_REMOTE_CONTROL(mTarget.cod);
 176   bool isKeyboard = IS_KEYBOARD(mTarget.cod);
 177   bool isPointingDevice = IS_POINTING_DEVICE(mTarget.cod);
 178
 179   NS_ENSURE_TRUE_VOID(hasAudio || hasRendering || isPeripheral);
 180
 181   // Audio bit should be set if remote device supports HFP/HSP.
 182   if (hasAudio) {
 183     AddProfile(BluetoothHfpManager::Get());
 184   }
 185
 186   // Rendering bit should be set if remote device supports A2DP.
 187   // A device which supports AVRCP should claim that it's a peripheral and it's
 188   // a remote control.
 189   if (hasRendering || (isPeripheral && isRemoteControl)) {
 190     AddProfile(BluetoothA2dpManager::Get());
 191   }
 192
 193   // A device which supports HID should claim that it's a peripheral and it's
 194   // either a keyboard, a pointing device, or both.
 195   if (isPeripheral && (isKeyboard || isPointingDevice)) {
 196     AddProfile(BluetoothHidManager::Get());
 197   }
 198 }
 199
 200 NS_IMPL_ISUPPORTS(CheckProfileStatusCallback, nsITimerCallback)
 201
 202 NS_IMETHODIMP
 203 CheckProfileStatusCallback::Notify(nsITimer* aTimer)
 204 {
 205   MOZ_ASSERT(mController);
 206   // Continue on the next profile since we haven't got the callback after
 207   // timeout.
 208   mController->GiveupAndContinue();
 209
 210   return NS_OK;
 211 }
 212
 213 void
 214 BluetoothProfileController::StartSession()
 215 {
 216   MOZ_ASSERT(NS_IsMainThread());
 217   MOZ_ASSERT(!mDeviceAddress.IsEmpty());
 218   MOZ_ASSERT(mProfilesIndex == -1);
 219   MOZ_ASSERT(mTimer);
 220
 221   if (!IsBtServiceAvailable()) {
 222     EndSession();
 223     return;
 224   }
 225
 226   if (mProfiles.Length() < 1) {
 227     BT_LOGR("No queued profile.");
 228     EndSession();
 229     return;
 230   }
 231
 232   if (mTimer) {
 233     mTimer->InitWithCallback(new CheckProfileStatusCallback(this),
 234                              CONNECTION_TIMEOUT_MS, nsITimer::TYPE_ONE_SHOT);
 235   }
 236
 237   BT_LOGR("%s", mConnect ? "connecting" : "disconnecting");
 238
 239   Next();
 240 }
 241
 242 void
 243 BluetoothProfileController::EndSession()
 244 {
 245   MOZ_ASSERT(mRunnable && mCallback);
 246
 247   BT_LOGR("mSuccess %d", mSuccess);
 248
 249   // Don't have to check profile status and retrigger session after connection
 250   // timeout, since session is end.
 251   if (mTimer) {
 252     mTimer->Cancel();
 253   }
 254
 255   // The action has completed, so the DOM request should be replied then invoke
 256   // the callback.
 257   if (mSuccess) {
 258     DispatchBluetoothReply(mRunnable, BluetoothValue(true), EmptyString());
 259   } else if (mConnect) {
 260     DispatchBluetoothReply(mRunnable, BluetoothValue(true),
 261                            NS_LITERAL_STRING(ERR_CONNECTION_FAILED));
 262   } else {
 263     DispatchBluetoothReply(mRunnable, BluetoothValue(true),
 264                            NS_LITERAL_STRING(ERR_DISCONNECTION_FAILED));
 265   }
 266
 267   mCallback();
 268 }
 269
 270 void
 271 BluetoothProfileController::Next()
 272 {
 273   MOZ_ASSERT(NS_IsMainThread());
 274   MOZ_ASSERT(!mDeviceAddress.IsEmpty());
 275   MOZ_ASSERT(mProfilesIndex < (int)mProfiles.Length());
 276   MOZ_ASSERT(mTimer);
 277
 278   mCurrentProfileFinished = false;
 279
 280   if (!IsBtServiceAvailable()) {
 281     EndSession();
 282     return;
 283   }
 284
 285   if (++mProfilesIndex >= (int)mProfiles.Length()) {
 286     EndSession();
 287     return;
 288   }
 289
 290   BT_LOGR_PROFILE(mProfiles[mProfilesIndex], "");
 291
 292   if (mConnect) {
 293     mProfiles[mProfilesIndex]->Connect(mDeviceAddress, this);
 294   } else {
 295     mProfiles[mProfilesIndex]->Disconnect(this);
 296   }
 297 }
 298
 299 bool
 300 BluetoothProfileController::IsBtServiceAvailable() const
 301 {
 302   BluetoothService* bs = BluetoothService::Get();
 303   return (bs && bs->IsEnabled() && !bs->IsToggling());
 304 }
 305
 306 void
 307 BluetoothProfileController::NotifyCompletion(const nsAString& aErrorStr)
 308 {
 309   MOZ_ASSERT(NS_IsMainThread());
 310   MOZ_ASSERT(mTimer);
 311   MOZ_ASSERT(mProfiles.Length() > 0);
 312
 313   BT_LOGR_PROFILE(mProfiles[mProfilesIndex], "<%s>",
 314                   NS_ConvertUTF16toUTF8(aErrorStr).get());
 315
 316   mCurrentProfileFinished = true;
 317
 318   if (mTimer) {
 319     mTimer->Cancel();
 320   }
 321
 322   mSuccess |= aErrorStr.IsEmpty();
 323
 324   Next();
 325 }
 326
 327 void
 328 BluetoothProfileController::GiveupAndContinue()
 329 {
 330   MOZ_ASSERT(!mCurrentProfileFinished);
 331   MOZ_ASSERT(mProfilesIndex < (int)mProfiles.Length());
 332
 333   BT_LOGR_PROFILE(mProfiles[mProfilesIndex], ERR_OPERATION_TIMEOUT);
 334   mProfiles[mProfilesIndex]->Reset();
 335
 336   if (IsBtServiceAvailable()) {
 337     Next();
 338   } else {
 339     EndSession();
 340   }
 341 }
 342