dom/bluetooth/BluetoothRilListener.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 "BluetoothRilListener.h"
   8
   9 #include "BluetoothHfpManager.h"
  10 #include "nsIMobileConnectionInfo.h"
  11 #include "nsIRadioInterfaceLayer.h"
  12 #include "nsRadioInterfaceLayer.h"
  13 #include "nsServiceManagerUtils.h"
  14 #include "nsString.h"
  15
  16 USING_BLUETOOTH_NAMESPACE
  17
  18 /**
  19  *  IccListener
  20  */
  21 NS_IMPL_ISUPPORTS(IccListener, nsIIccListener)
  22
  23 NS_IMETHODIMP
  24 IccListener::NotifyIccInfoChanged()
  25 {
  26   // mOwner would be set to nullptr only in the dtor of BluetoothRilListener
  27   NS_ENSURE_TRUE(mOwner, NS_ERROR_FAILURE);
  28
  29   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
  30   NS_ENSURE_TRUE(hfp, NS_ERROR_FAILURE);
  31
  32   hfp->HandleIccInfoChanged(mOwner->mClientId);
  33
  34   return NS_OK;
  35 }
  36
  37 NS_IMETHODIMP
  38 IccListener::NotifyStkCommand(const nsAString & aMessage)
  39 {
  40   return NS_OK;
  41 }
  42
  43 NS_IMETHODIMP
  44 IccListener::NotifyStkSessionEnd()
  45 {
  46   return NS_OK;
  47 }
  48
  49 NS_IMETHODIMP
  50 IccListener::NotifyCardStateChanged()
  51 {
  52   return NS_OK;
  53 }
  54
  55 bool
  56 IccListener::Listen(bool aStart)
  57 {
  58   NS_ENSURE_TRUE(mOwner, false);
  59
  60   nsCOMPtr<nsIIccProvider> provider =
  61     do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
  62   NS_ENSURE_TRUE(provider, false);
  63
  64   nsresult rv;
  65   if (aStart) {
  66     rv = provider->RegisterIccMsg(mOwner->mClientId, this);
  67   } else {
  68     rv = provider->UnregisterIccMsg(mOwner->mClientId, this);
  69   }
  70
  71   return NS_SUCCEEDED(rv);
  72 }
  73
  74 void
  75 IccListener::SetOwner(BluetoothRilListener *aOwner)
  76 {
  77   mOwner = aOwner;
  78 }
  79
  80 /**
  81  *  MobileConnectionListener
  82  */
  83 NS_IMPL_ISUPPORTS(MobileConnectionListener, nsIMobileConnectionListener)
  84
  85 NS_IMETHODIMP
  86 MobileConnectionListener::NotifyVoiceChanged()
  87 {
  88   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
  89   NS_ENSURE_TRUE(hfp, NS_OK);
  90
  91   hfp->HandleVoiceConnectionChanged(mClientId);
  92
  93   return NS_OK;
  94 }
  95
  96 NS_IMETHODIMP
  97 MobileConnectionListener::NotifyDataChanged()
  98 {
  99   return NS_OK;
 100 }
 101
 102 NS_IMETHODIMP
 103 MobileConnectionListener::NotifyUssdReceived(const nsAString & message,
 104                                              bool sessionEnded)
 105 {
 106   return NS_OK;
 107 }
 108
 109 NS_IMETHODIMP
 110 MobileConnectionListener::NotifyDataError(const nsAString & message)
 111 {
 112   return NS_OK;
 113 }
 114
 115 NS_IMETHODIMP
 116 MobileConnectionListener::NotifyCFStateChange(bool success,
 117                                               uint16_t action,
 118                                               uint16_t reason,
 119                                               const nsAString& number,
 120                                               uint16_t timeSeconds,
 121                                               uint16_t serviceClass)
 122 {
 123   return NS_OK;
 124 }
 125
 126 NS_IMETHODIMP
 127 MobileConnectionListener::NotifyEmergencyCbModeChanged(bool active,
 128                                                        uint32_t timeoutMs)
 129 {
 130   return NS_OK;
 131 }
 132
 133 NS_IMETHODIMP
 134 MobileConnectionListener::NotifyOtaStatusChanged(const nsAString & status)
 135 {
 136   return NS_OK;
 137 }
 138
 139 NS_IMETHODIMP
 140 MobileConnectionListener::NotifyIccChanged()
 141 {
 142   return NS_OK;
 143 }
 144
 145 NS_IMETHODIMP
 146 MobileConnectionListener::NotifyRadioStateChanged()
 147 {
 148   return NS_OK;
 149 }
 150
 151 NS_IMETHODIMP
 152 MobileConnectionListener::NotifyClirModeChanged(uint32_t aMode)
 153 {
 154   return NS_OK;
 155 }
 156
 157 bool
 158 MobileConnectionListener::Listen(bool aStart)
 159 {
 160   nsCOMPtr<nsIMobileConnectionProvider> provider =
 161     do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
 162   NS_ENSURE_TRUE(provider, false);
 163
 164   nsresult rv;
 165   if (aStart) {
 166     rv = provider->RegisterMobileConnectionMsg(mClientId, this);
 167   } else {
 168     rv = provider->UnregisterMobileConnectionMsg(mClientId, this);
 169   }
 170
 171   return NS_SUCCEEDED(rv);
 172 }
 173
 174 /**
 175  *  TelephonyListener Implementation
 176  */
 177 NS_IMPL_ISUPPORTS(TelephonyListener, nsITelephonyListener)
 178
 179 NS_IMETHODIMP
 180 TelephonyListener::CallStateChanged(uint32_t aServiceId,
 181                                     uint32_t aCallIndex,
 182                                     uint16_t aCallState,
 183                                     const nsAString& aNumber,
 184                                     uint16_t aNumberPresentation,
 185                                     const nsAString& aName,
 186                                     uint16_t aNamePresentation,
 187                                     bool aIsOutgoing,
 188                                     bool aIsEmergency,
 189                                     bool aIsConference,
 190                                     bool aIsSwitchable,
 191                                     bool aIsMergeable)
 192 {
 193   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
 194   NS_ENSURE_TRUE(hfp, NS_ERROR_FAILURE);
 195
 196   hfp->HandleCallStateChanged(aCallIndex, aCallState, EmptyString(), aNumber,
 197                               aIsOutgoing, aIsConference, true);
 198   return NS_OK;
 199 }
 200
 201 NS_IMETHODIMP
 202 TelephonyListener::EnumerateCallState(uint32_t aServiceId,
 203                                       uint32_t aCallIndex,
 204                                       uint16_t aCallState,
 205                                       const nsAString_internal& aNumber,
 206                                       uint16_t aNumberPresentation,
 207                                       const nsAString& aName,
 208                                       uint16_t aNamePresentation,
 209                                       bool aIsOutgoing,
 210                                       bool aIsEmergency,
 211                                       bool aIsConference,
 212                                       bool aIsSwitchable,
 213                                       bool aIsMergeable)
 214 {
 215   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
 216   NS_ENSURE_TRUE(hfp, NS_ERROR_FAILURE);
 217
 218   hfp->HandleCallStateChanged(aCallIndex, aCallState, EmptyString(), aNumber,
 219                               aIsOutgoing, aIsConference, false);
 220   return NS_OK;
 221 }
 222
 223 NS_IMETHODIMP
 224 TelephonyListener::NotifyError(uint32_t aServiceId,
 225                                int32_t aCallIndex,
 226                                const nsAString& aError)
 227 {
 228   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
 229   NS_ENSURE_TRUE(hfp, NS_ERROR_FAILURE);
 230
 231   if (aCallIndex > 0) {
 232     // In order to not miss any related call state transition.
 233     // It's possible that 3G network signal lost for unknown reason.
 234     // If a call is released abnormally, NotifyError() will be called,
 235     // instead of CallStateChanged(). We need to reset the call array state
 236     // via setting CALL_STATE_DISCONNECTED
 237     hfp->HandleCallStateChanged(aCallIndex,
 238                                 nsITelephonyService::CALL_STATE_DISCONNECTED,
 239                                 aError, EmptyString(), false, false, true);
 240     BT_WARNING("Reset the call state due to call transition ends abnormally");
 241   }
 242
 243   BT_WARNING(NS_ConvertUTF16toUTF8(aError).get());
 244   return NS_OK;
 245 }
 246
 247 NS_IMETHODIMP
 248 TelephonyListener::ConferenceCallStateChanged(uint16_t aCallState)
 249 {
 250   return NS_OK;
 251 }
 252
 253 NS_IMETHODIMP
 254 TelephonyListener::EnumerateCallStateComplete()
 255 {
 256   return NS_OK;
 257 }
 258
 259 NS_IMETHODIMP
 260 TelephonyListener::SupplementaryServiceNotification(uint32_t aServiceId,
 261                                                     int32_t aCallIndex,
 262                                                     uint16_t aNotification)
 263 {
 264   return NS_OK;
 265 }
 266
 267 NS_IMETHODIMP
 268 TelephonyListener::NotifyConferenceError(const nsAString& aName,
 269                                          const nsAString& aMessage)
 270 {
 271   BT_WARNING(NS_ConvertUTF16toUTF8(aName).get());
 272   BT_WARNING(NS_ConvertUTF16toUTF8(aMessage).get());
 273
 274   return NS_OK;
 275 }
 276
 277 NS_IMETHODIMP
 278 TelephonyListener::NotifyCdmaCallWaiting(uint32_t aServiceId,
 279                                          const nsAString& aNumber,
 280                                          uint16_t aNumberPresentation,
 281                                          const nsAString& aName,
 282                                          uint16_t aNamePresentation)
 283 {
 284   BluetoothHfpManager* hfp = BluetoothHfpManager::Get();
 285   NS_ENSURE_TRUE(hfp, NS_ERROR_FAILURE);
 286
 287   hfp->UpdateSecondNumber(aNumber);
 288
 289   return NS_OK;
 290 }
 291
 292 bool
 293 TelephonyListener::Listen(bool aStart)
 294 {
 295   nsCOMPtr<nsITelephonyService> service =
 296     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 297   NS_ENSURE_TRUE(service, false);
 298
 299   nsresult rv;
 300   if (aStart) {
 301     rv = service->RegisterListener(this);
 302   } else {
 303     rv = service->UnregisterListener(this);
 304   }
 305
 306   return NS_SUCCEEDED(rv);
 307 }
 308
 309 /**
 310  *  BluetoothRilListener
 311  */
 312 BluetoothRilListener::BluetoothRilListener()
 313 {
 314   // Query number of total clients (sim slots)
 315   uint32_t numOfClients;
 316   nsCOMPtr<nsIRadioInterfaceLayer> radioInterfaceLayer =
 317     do_GetService(NS_RADIOINTERFACELAYER_CONTRACTID);
 318   NS_ENSURE_TRUE_VOID(radioInterfaceLayer);
 319
 320   radioInterfaceLayer->GetNumRadioInterfaces(&numOfClients);
 321
 322   // Init MobileConnectionListener array and IccInfoListener
 323   for (uint32_t i = 0; i < numOfClients; i++) {
 324     mMobileConnListeners.AppendElement(new MobileConnectionListener(i));
 325   }
 326
 327   mTelephonyListener = new TelephonyListener();
 328   mIccListener = new IccListener();
 329   mIccListener->SetOwner(this);
 330
 331   // Probe for available client
 332   SelectClient();
 333 }
 334
 335 BluetoothRilListener::~BluetoothRilListener()
 336 {
 337   mIccListener->SetOwner(nullptr);
 338 }
 339
 340 bool
 341 BluetoothRilListener::Listen(bool aStart)
 342 {
 343   NS_ENSURE_TRUE(ListenMobileConnAndIccInfo(aStart), false);
 344   NS_ENSURE_TRUE(mTelephonyListener->Listen(aStart), false);
 345
 346   return true;
 347 }
 348
 349 void
 350 BluetoothRilListener::SelectClient()
 351 {
 352   // Reset mClientId
 353   mClientId = mMobileConnListeners.Length();
 354
 355   nsCOMPtr<nsIMobileConnectionProvider> connection =
 356     do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
 357   NS_ENSURE_TRUE_VOID(connection);
 358
 359   for (uint32_t i = 0; i < mMobileConnListeners.Length(); i++) {
 360     nsCOMPtr<nsIMobileConnectionInfo> voiceInfo;
 361     connection->GetVoiceConnectionInfo(i, getter_AddRefs(voiceInfo));
 362     if (!voiceInfo) {
 363       BT_WARNING("%s: Failed to get voice connection info", __FUNCTION__);
 364       continue;
 365     }
 366
 367     nsString regState;
 368     voiceInfo->GetState(regState);
 369     if (regState.EqualsLiteral("registered")) {
 370       // Found available client
 371       mClientId = i;
 372       return;
 373     }
 374   }
 375 }
 376
 377 void
 378 BluetoothRilListener::ServiceChanged(uint32_t aClientId, bool aRegistered)
 379 {
 380   // Stop listening
 381   ListenMobileConnAndIccInfo(false);
 382
 383   /**
 384    * aRegistered:
 385    * - TRUE:  service becomes registered. We were listening to all clients
 386    *          and one of them becomes available. Select it to listen.
 387    * - FALSE: service becomes un-registered. The client we were listening
 388    *          becomes unavailable. Select another registered one to listen.
 389    */
 390   if (aRegistered) {
 391     mClientId = aClientId;
 392   } else {
 393     SelectClient();
 394   }
 395
 396   // Restart listening
 397   ListenMobileConnAndIccInfo(true);
 398
 399   BT_LOGR("%d client %d. new mClientId %d", aRegistered, aClientId,
 400           (mClientId < mMobileConnListeners.Length()) ? mClientId : -1);
 401 }
 402
 403 void
 404 BluetoothRilListener::EnumerateCalls()
 405 {
 406   nsCOMPtr<nsITelephonyService> service =
 407     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 408   NS_ENSURE_TRUE_VOID(service);
 409
 410   nsCOMPtr<nsITelephonyListener> listener(
 411     do_QueryObject(mTelephonyListener));
 412
 413   service->EnumerateCalls(listener);
 414 }
 415
 416 bool
 417 BluetoothRilListener::ListenMobileConnAndIccInfo(bool aStart)
 418 {
 419   /**
 420    * mClientId < number of total clients:
 421    *   The client with mClientId is available. Start/Stop listening
 422    *   mobile connection and icc info of this client only.
 423    *
 424    * mClientId >= number of total clients:
 425    *   All clients are unavailable. Start/Stop listening mobile
 426    *   connections of all clients.
 427    */
 428   if (mClientId < mMobileConnListeners.Length()) {
 429     NS_ENSURE_TRUE(mMobileConnListeners[mClientId]->Listen(aStart), false);
 430     NS_ENSURE_TRUE(mIccListener->Listen(aStart), false);
 431   } else {
 432     for (uint32_t i = 0; i < mMobileConnListeners.Length(); i++) {
 433       NS_ENSURE_TRUE(mMobileConnListeners[i]->Listen(aStart), false);
 434     }
 435   }
 436
 437   return true;
 438 }