dom/mobileconnection/MobileConnection.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "mozilla/dom/MobileConnection.h"
   6
   7 #include "MobileConnectionCallback.h"
   8 #include "mozilla/AsyncEventDispatcher.h"
   9 #include "mozilla/dom/CFStateChangeEvent.h"
  10 #include "mozilla/dom/DataErrorEvent.h"
  11 #include "mozilla/dom/ImsRegHandler.h"
  12 #include "mozilla/dom/MozClirModeEvent.h"
  13 #include "mozilla/dom/MozEmergencyCbModeEvent.h"
  14 #include "mozilla/dom/MozOtaStatusEvent.h"
  15 #include "mozilla/dom/ToJSValue.h"
  16 #include "mozilla/Preferences.h"
  17 #include "mozilla/Services.h"
  18 #include "nsIDOMDOMRequest.h"
  19 #include "nsIPermissionManager.h"
  20 #include "nsIVariant.h"
  21 #include "nsJSON.h"
  22 #include "nsJSUtils.h"
  23 #include "nsRadioInterfaceLayer.h"
  24 #include "nsServiceManagerUtils.h"
  25
  26 #ifdef MOZ_B2G_RIL
  27 #include "nsIIccInfo.h"
  28 #endif // MOZ_B2G_RIL
  29
  30 #define MOBILECONN_ERROR_INVALID_PARAMETER NS_LITERAL_STRING("InvalidParameter")
  31 #define MOBILECONN_ERROR_INVALID_PASSWORD  NS_LITERAL_STRING("InvalidPassword")
  32
  33 #ifdef CONVERT_STRING_TO_NULLABLE_ENUM
  34 #undef CONVERT_STRING_TO_NULLABLE_ENUM
  35 #endif
  36 #define CONVERT_STRING_TO_NULLABLE_ENUM(_string, _enumType, _enum)      \
  37 {                                                                       \
  38   uint32_t i = 0;                                                       \
  39   for (const EnumEntry* entry = _enumType##Values::strings;             \
  40        entry->value;                                                    \
  41        ++entry, ++i) {                                                  \
  42     if (_string.EqualsASCII(entry->value)) {                            \
  43       _enum.SetValue(static_cast<_enumType>(i));                        \
  44     }                                                                   \
  45   }                                                                     \
  46 }
  47
  48 using mozilla::ErrorResult;
  49 using namespace mozilla::dom;
  50 using namespace mozilla::dom::mobileconnection;
  51
  52 class MobileConnection::Listener MOZ_FINAL : public nsIMobileConnectionListener
  53 #ifdef MOZ_B2G_RIL
  54                                            , public nsIIccListener
  55 #endif // MOZ_B2G_RIL
  56 {
  57   MobileConnection* mMobileConnection;
  58
  59 public:
  60   NS_DECL_ISUPPORTS
  61   NS_FORWARD_SAFE_NSIMOBILECONNECTIONLISTENER(mMobileConnection)
  62 #ifdef MOZ_B2G_RIL
  63   NS_FORWARD_SAFE_NSIICCLISTENER(mMobileConnection)
  64 #endif // MOZ_B2G_RIL
  65
  66   explicit Listener(MobileConnection* aMobileConnection)
  67     : mMobileConnection(aMobileConnection)
  68   {
  69     MOZ_ASSERT(mMobileConnection);
  70   }
  71
  72   void Disconnect()
  73   {
  74     MOZ_ASSERT(mMobileConnection);
  75     mMobileConnection = nullptr;
  76   }
  77
  78 private:
  79   ~Listener()
  80   {
  81     MOZ_ASSERT(!mMobileConnection);
  82   }
  83 };
  84
  85 #ifdef MOZ_B2G_RIL
  86 NS_IMPL_ISUPPORTS(MobileConnection::Listener, nsIMobileConnectionListener,
  87                   nsIIccListener)
  88 #else
  89 NS_IMPL_ISUPPORTS(MobileConnection::Listener, nsIMobileConnectionListener)
  90 #endif // MOZ_B2G_RIL
  91
  92 NS_IMPL_CYCLE_COLLECTION_CLASS(MobileConnection)
  93
  94 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(MobileConnection,
  95                                                   DOMEventTargetHelper)
  96   // Don't traverse mListener because it doesn't keep any reference to
  97   // MobileConnection but a raw pointer instead. Neither does mMobileConnection
  98   // because it's an xpcom service owned object and is only released at shutting
  99   // down.
 100   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mVoice)
 101   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mData)
 102   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mImsHandler)
 103 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 104
 105 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(MobileConnection,
 106                                                 DOMEventTargetHelper)
 107   tmp->Shutdown();
 108   NS_IMPL_CYCLE_COLLECTION_UNLINK(mVoice)
 109   NS_IMPL_CYCLE_COLLECTION_UNLINK(mData)
 110   NS_IMPL_CYCLE_COLLECTION_UNLINK(mImsHandler)
 111 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 112
 113 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(MobileConnection)
 114   // MobileConnection does not expose nsIMobileConnectionListener. mListener is
 115   // the exposed nsIMobileConnectionListener and forwards the calls it receives
 116   // to us.
 117 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
 118
 119 NS_IMPL_ADDREF_INHERITED(MobileConnection, DOMEventTargetHelper)
 120 NS_IMPL_RELEASE_INHERITED(MobileConnection, DOMEventTargetHelper)
 121
 122 MobileConnection::MobileConnection(nsPIDOMWindow* aWindow, uint32_t aClientId)
 123   : DOMEventTargetHelper(aWindow)
 124   , mClientId(aClientId)
 125 {
 126   nsCOMPtr<nsIMobileConnectionService> service =
 127     do_GetService(NS_MOBILE_CONNECTION_SERVICE_CONTRACTID);
 128
 129   // Per WebAPI design, mIccId should be null instead of an empty string when no
 130   // SIM card is inserted. Set null as default value.
 131   mIccId.SetIsVoid(true);
 132
 133   // Not being able to acquire the service isn't fatal since we check
 134   // for it explicitly below.
 135   if (!service) {
 136     NS_WARNING("Could not acquire nsIMobileConnectionService!");
 137     return;
 138   }
 139
 140   nsresult rv = service->GetItemByServiceId(mClientId,
 141                                             getter_AddRefs(mMobileConnection));
 142 #ifdef MOZ_B2G_RIL
 143   mIcc = do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
 144
 145   if (NS_FAILED(rv) || !mMobileConnection || !mIcc) {
 146     NS_WARNING("Could not acquire nsIMobileConnection or nsIIccProvider!");
 147 #else
 148   if (NS_FAILED(rv) || !mMobileConnection) {
 149     NS_WARNING("Could not acquire nsIMobileConnection!");
 150 #endif // MOZ_B2G_RIL
 151     return;
 152   }
 153
 154   mListener = new Listener(this);
 155   mVoice = new MobileConnectionInfo(GetOwner());
 156   mData = new MobileConnectionInfo(GetOwner());
 157
 158   if (CheckPermission("mobileconnection")) {
 159     DebugOnly<nsresult> rv = mMobileConnection->RegisterListener(mListener);
 160     NS_WARN_IF_FALSE(NS_SUCCEEDED(rv),
 161                      "Failed registering mobile connection messages with service");
 162     UpdateVoice();
 163     UpdateData();
 164
 165 #ifdef MOZ_B2G_RIL
 166     rv = mIcc->RegisterIccMsg(mClientId, mListener);
 167     NS_WARN_IF_FALSE(NS_SUCCEEDED(rv),
 168                      "Failed registering icc messages with service");
 169     UpdateIccId();
 170 #endif // MOZ_B2G_RIL
 171   }
 172 }
 173
 174 void
 175 MobileConnection::Shutdown()
 176 {
 177   if (mListener) {
 178     if (mMobileConnection) {
 179       mMobileConnection->UnregisterListener(mListener);
 180     }
 181
 182 #ifdef MOZ_B2G_RIL
 183     if (mIcc) {
 184       mIcc->UnregisterIccMsg(mClientId, mListener);
 185     }
 186 #endif // MOZ_B2G_RIL
 187
 188     mListener->Disconnect();
 189     mListener = nullptr;
 190   }
 191 }
 192
 193 MobileConnection::~MobileConnection()
 194 {
 195   Shutdown();
 196 }
 197
 198 void
 199 MobileConnection::DisconnectFromOwner()
 200 {
 201   DOMEventTargetHelper::DisconnectFromOwner();
 202   // Event listeners can't be handled anymore, so we can shutdown
 203   // the MobileConnection.
 204   Shutdown();
 205 }
 206
 207 JSObject*
 208 MobileConnection::WrapObject(JSContext* aCx)
 209 {
 210   return MozMobileConnectionBinding::Wrap(aCx, this);
 211 }
 212
 213 bool
 214 MobileConnection::CheckPermission(const char* aType) const
 215 {
 216   nsCOMPtr<nsIPermissionManager> permMgr =
 217     mozilla::services::GetPermissionManager();
 218   NS_ENSURE_TRUE(permMgr, false);
 219
 220   uint32_t permission = nsIPermissionManager::DENY_ACTION;
 221   permMgr->TestPermissionFromWindow(GetOwner(), aType, &permission);
 222   return permission == nsIPermissionManager::ALLOW_ACTION;
 223 }
 224
 225 void
 226 MobileConnection::UpdateVoice()
 227 {
 228   if (!mMobileConnection) {
 229     return;
 230   }
 231
 232   nsCOMPtr<nsIMobileConnectionInfo> info;
 233   mMobileConnection->GetVoice(getter_AddRefs(info));
 234   mVoice->Update(info);
 235 }
 236
 237 void
 238 MobileConnection::UpdateData()
 239 {
 240   if (!mMobileConnection) {
 241     return;
 242   }
 243
 244   nsCOMPtr<nsIMobileConnectionInfo> info;
 245   mMobileConnection->GetData(getter_AddRefs(info));
 246   mData->Update(info);
 247 }
 248
 249 bool
 250 MobileConnection::UpdateIccId()
 251 {
 252 #ifdef MOZ_B2G_RIL
 253   nsAutoString iccId;
 254   nsCOMPtr<nsIIccInfo> iccInfo;
 255   if (mIcc &&
 256       NS_SUCCEEDED(mIcc->GetIccInfo(mClientId, getter_AddRefs(iccInfo))) &&
 257       iccInfo) {
 258     iccInfo->GetIccid(iccId);
 259   } else {
 260     iccId.SetIsVoid(true);
 261   }
 262
 263   if (!mIccId.Equals(iccId)) {
 264     mIccId = iccId;
 265     return true;
 266   }
 267 #endif // MOZ_B2G_RIL
 268
 269   return false;
 270 }
 271
 272 nsresult
 273 MobileConnection::NotifyError(nsIDOMDOMRequest* aRequest, const nsAString& aMessage)
 274 {
 275   nsCOMPtr<nsIDOMRequestService> rs = do_GetService(DOMREQUEST_SERVICE_CONTRACTID);
 276   NS_ENSURE_TRUE(rs, NS_ERROR_FAILURE);
 277
 278   return rs->FireErrorAsync(aRequest, aMessage);
 279 }
 280
 281 bool
 282 MobileConnection::IsValidPassword(const nsAString& aPassword)
 283 {
 284   // Check valid PIN for supplementary services. See TS.22.004 clause 5.2.
 285   if (aPassword.IsEmpty() || aPassword.Length() != 4) {
 286     return false;
 287   }
 288
 289   nsresult rv;
 290   int32_t password = nsString(aPassword).ToInteger(&rv);
 291   return NS_SUCCEEDED(rv) && password >= 0 && password <= 9999;
 292 }
 293
 294 bool
 295 MobileConnection::IsValidCallForwardingReason(int32_t aReason)
 296 {
 297   return aReason >= nsIMobileConnection::CALL_FORWARD_REASON_UNCONDITIONAL &&
 298          aReason <= nsIMobileConnection::CALL_FORWARD_REASON_ALL_CONDITIONAL_CALL_FORWARDING;
 299 }
 300
 301 bool
 302 MobileConnection::IsValidCallForwardingAction(int32_t aAction)
 303 {
 304   return aAction >= nsIMobileConnection::CALL_FORWARD_ACTION_DISABLE &&
 305          aAction <= nsIMobileConnection::CALL_FORWARD_ACTION_ERASURE &&
 306          // Set operation doesn't allow "query" action.
 307          aAction != nsIMobileConnection::CALL_FORWARD_ACTION_QUERY_STATUS;
 308 }
 309
 310 bool
 311 MobileConnection::IsValidCallBarringProgram(int32_t aProgram)
 312 {
 313   return aProgram >= nsIMobileConnection::CALL_BARRING_PROGRAM_ALL_OUTGOING &&
 314          aProgram <= nsIMobileConnection::CALL_BARRING_PROGRAM_INCOMING_ROAMING;
 315 }
 316
 317 bool
 318 MobileConnection::IsValidCallBarringOptions(const MozCallBarringOptions& aOptions,
 319                                            bool isSetting)
 320 {
 321   if (!aOptions.mServiceClass.WasPassed() || aOptions.mServiceClass.Value().IsNull() ||
 322       !aOptions.mProgram.WasPassed() || aOptions.mProgram.Value().IsNull() ||
 323       !IsValidCallBarringProgram(aOptions.mProgram.Value().Value())) {
 324     return false;
 325   }
 326
 327   // For setting callbarring options, |enabled| and |password| are required.
 328   if (isSetting &&
 329       (!aOptions.mEnabled.WasPassed() || aOptions.mEnabled.Value().IsNull() ||
 330        !aOptions.mPassword.WasPassed() || aOptions.mPassword.Value().IsVoid())) {
 331     return false;
 332   }
 333
 334   return true;
 335 }
 336
 337 bool
 338 MobileConnection::IsValidCallForwardingOptions(const MozCallForwardingOptions& aOptions)
 339 {
 340   if (!aOptions.mReason.WasPassed() || aOptions.mReason.Value().IsNull() ||
 341       !aOptions.mAction.WasPassed() || aOptions.mAction.Value().IsNull() ||
 342       !IsValidCallForwardingReason(aOptions.mReason.Value().Value()) ||
 343       !IsValidCallForwardingAction(aOptions.mAction.Value().Value())) {
 344     return false;
 345   }
 346
 347   return true;
 348 }
 349
 350 // WebIDL interface
 351
 352 void
 353 MobileConnection::GetLastKnownNetwork(nsString& aRetVal) const
 354 {
 355   aRetVal.SetIsVoid(true);
 356
 357   if (!mMobileConnection) {
 358     return;
 359   }
 360
 361   mMobileConnection->GetLastKnownNetwork(aRetVal);
 362 }
 363
 364 void
 365 MobileConnection::GetLastKnownHomeNetwork(nsString& aRetVal) const
 366 {
 367   aRetVal.SetIsVoid(true);
 368
 369   if (!mMobileConnection) {
 370     return;
 371   }
 372
 373   mMobileConnection->GetLastKnownHomeNetwork(aRetVal);
 374 }
 375
 376 // All fields below require the "mobileconnection" permission.
 377
 378 MobileConnectionInfo*
 379 MobileConnection::Voice() const
 380 {
 381   return mVoice;
 382 }
 383
 384 MobileConnectionInfo*
 385 MobileConnection::Data() const
 386 {
 387   return mData;
 388 }
 389
 390 void
 391 MobileConnection::GetIccId(nsString& aRetVal) const
 392 {
 393   aRetVal = mIccId;
 394 }
 395
 396 Nullable<MobileNetworkSelectionMode>
 397 MobileConnection::GetNetworkSelectionMode() const
 398 {
 399   Nullable<MobileNetworkSelectionMode> retVal =
 400     Nullable<MobileNetworkSelectionMode>();
 401
 402   if (!mMobileConnection) {
 403     return retVal;
 404   }
 405
 406   int32_t mode = nsIMobileConnection::NETWORK_SELECTION_MODE_UNKNOWN;
 407   if (NS_SUCCEEDED(mMobileConnection->GetNetworkSelectionMode(&mode)) &&
 408       mode != nsIMobileConnection::NETWORK_SELECTION_MODE_UNKNOWN) {
 409     MOZ_ASSERT(mode < static_cast<int32_t>(MobileNetworkSelectionMode::EndGuard_));
 410     retVal.SetValue(static_cast<MobileNetworkSelectionMode>(mode));
 411   }
 412
 413   return retVal;
 414 }
 415
 416 Nullable<MobileRadioState>
 417 MobileConnection::GetRadioState() const
 418 {
 419   Nullable<MobileRadioState> retVal = Nullable<MobileRadioState>();
 420
 421   if (!mMobileConnection) {
 422     return retVal;
 423   }
 424
 425   int32_t state = nsIMobileConnection::MOBILE_RADIO_STATE_UNKNOWN;
 426   if (NS_SUCCEEDED(mMobileConnection->GetRadioState(&state)) &&
 427       state != nsIMobileConnection::MOBILE_RADIO_STATE_UNKNOWN) {
 428     MOZ_ASSERT(state < static_cast<int32_t>(MobileRadioState::EndGuard_));
 429     retVal.SetValue(static_cast<MobileRadioState>(state));
 430   }
 431
 432   return retVal;
 433 }
 434
 435 void
 436 MobileConnection::GetSupportedNetworkTypes(nsTArray<MobileNetworkType>& aTypes) const
 437 {
 438   if (!mMobileConnection) {
 439     return;
 440   }
 441
 442   int32_t* types = nullptr;
 443   uint32_t length = 0;
 444
 445   nsresult rv = mMobileConnection->GetSupportedNetworkTypes(&types, &length);
 446   NS_ENSURE_SUCCESS_VOID(rv);
 447
 448   for (uint32_t i = 0; i < length; ++i) {
 449     int32_t type = types[i];
 450
 451     MOZ_ASSERT(type < static_cast<int32_t>(MobileNetworkType::EndGuard_));
 452     aTypes.AppendElement(static_cast<MobileNetworkType>(type));
 453   }
 454
 455   nsMemory::Free(types);
 456 }
 457
 458 already_AddRefed<ImsRegHandler>
 459 MobileConnection::GetImsHandler() const
 460 {
 461   if (!mMobileConnection) {
 462     return nullptr;
 463   }
 464
 465   if (mImsHandler) {
 466     nsRefPtr<ImsRegHandler> handler = mImsHandler;
 467     return handler.forget();
 468   }
 469
 470   nsCOMPtr<nsIImsRegService> imsService = do_GetService(IMS_REG_SERVICE_CONTRACTID);
 471   if (!imsService) {
 472     NS_WARNING("Could not acquire nsIImsRegService!");
 473     return nullptr;
 474   }
 475
 476   nsCOMPtr<nsIImsRegHandler> internalHandler;
 477   imsService->GetHandlerByServiceId(mClientId, getter_AddRefs(internalHandler));
 478   // ImsRegHandler is optional, always check even if it was retreived successfully.
 479   if (!internalHandler) {
 480     NS_WARNING("Could not acquire nsIImsRegHandler!");
 481     return nullptr;
 482   }
 483
 484   mImsHandler = new ImsRegHandler(GetOwner(), internalHandler);
 485   nsRefPtr<ImsRegHandler> handler = mImsHandler;
 486
 487   return handler.forget();
 488 }
 489
 490 already_AddRefed<DOMRequest>
 491 MobileConnection::GetNetworks(ErrorResult& aRv)
 492 {
 493   if (!mMobileConnection) {
 494     aRv.Throw(NS_ERROR_FAILURE);
 495     return nullptr;
 496   }
 497
 498   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 499   nsRefPtr<MobileConnectionCallback> requestCallback =
 500     new MobileConnectionCallback(GetOwner(), request);
 501
 502   nsresult rv = mMobileConnection->GetNetworks(requestCallback);
 503   if (NS_FAILED(rv)) {
 504     aRv.Throw(rv);
 505     return nullptr;
 506   }
 507
 508   return request.forget();
 509 }
 510
 511 already_AddRefed<DOMRequest>
 512 MobileConnection::SelectNetwork(MobileNetworkInfo& aNetwork, ErrorResult& aRv)
 513 {
 514   if (!mMobileConnection) {
 515     aRv.Throw(NS_ERROR_FAILURE);
 516     return nullptr;
 517   }
 518
 519   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 520   nsRefPtr<MobileConnectionCallback> requestCallback =
 521     new MobileConnectionCallback(GetOwner(), request);
 522
 523   nsresult rv = mMobileConnection->SelectNetwork(&aNetwork, requestCallback);
 524   if (NS_FAILED(rv)) {
 525     aRv.Throw(rv);
 526     return nullptr;
 527   }
 528
 529   return request.forget();
 530 }
 531
 532 already_AddRefed<DOMRequest>
 533 MobileConnection::SelectNetworkAutomatically(ErrorResult& aRv)
 534 {
 535   if (!mMobileConnection) {
 536     aRv.Throw(NS_ERROR_FAILURE);
 537     return nullptr;
 538   }
 539
 540   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 541   nsRefPtr<MobileConnectionCallback> requestCallback =
 542     new MobileConnectionCallback(GetOwner(), request);
 543
 544   nsresult rv =
 545     mMobileConnection->SelectNetworkAutomatically(requestCallback);
 546   if (NS_FAILED(rv)) {
 547     aRv.Throw(rv);
 548     return nullptr;
 549   }
 550
 551   return request.forget();
 552 }
 553
 554 already_AddRefed<DOMRequest>
 555 MobileConnection::SetPreferredNetworkType(MobilePreferredNetworkType& aType,
 556                                           ErrorResult& aRv)
 557 {
 558   if (!mMobileConnection) {
 559     aRv.Throw(NS_ERROR_FAILURE);
 560     return nullptr;
 561   }
 562
 563   int32_t type = static_cast<int32_t>(aType);
 564
 565   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 566   nsRefPtr<MobileConnectionCallback> requestCallback =
 567     new MobileConnectionCallback(GetOwner(), request);
 568
 569   nsresult rv =
 570     mMobileConnection->SetPreferredNetworkType(type, requestCallback);
 571   if (NS_FAILED(rv)) {
 572     aRv.Throw(rv);
 573     return nullptr;
 574   }
 575
 576   return request.forget();
 577 }
 578
 579 already_AddRefed<DOMRequest>
 580 MobileConnection::GetPreferredNetworkType(ErrorResult& aRv)
 581 {
 582   if (!mMobileConnection) {
 583     aRv.Throw(NS_ERROR_FAILURE);
 584     return nullptr;
 585   }
 586
 587   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 588   nsRefPtr<MobileConnectionCallback> requestCallback =
 589     new MobileConnectionCallback(GetOwner(), request);
 590
 591   nsresult rv = mMobileConnection->GetPreferredNetworkType(requestCallback);
 592   if (NS_FAILED(rv)) {
 593     aRv.Throw(rv);
 594     return nullptr;
 595   }
 596
 597   return request.forget();
 598 }
 599
 600 already_AddRefed<DOMRequest>
 601 MobileConnection::SetRoamingPreference(MobileRoamingMode& aMode,
 602                                        ErrorResult& aRv)
 603 {
 604   if (!mMobileConnection) {
 605     aRv.Throw(NS_ERROR_FAILURE);
 606     return nullptr;
 607   }
 608
 609   int32_t mode = static_cast<int32_t>(aMode);
 610
 611   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 612   nsRefPtr<MobileConnectionCallback> requestCallback =
 613     new MobileConnectionCallback(GetOwner(), request);
 614
 615   nsresult rv = mMobileConnection->SetRoamingPreference(mode, requestCallback);
 616   if (NS_FAILED(rv)) {
 617     aRv.Throw(rv);
 618     return nullptr;
 619   }
 620
 621   return request.forget();
 622 }
 623
 624 already_AddRefed<DOMRequest>
 625 MobileConnection::GetRoamingPreference(ErrorResult& aRv)
 626 {
 627   if (!mMobileConnection) {
 628     aRv.Throw(NS_ERROR_FAILURE);
 629     return nullptr;
 630   }
 631
 632   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 633   nsRefPtr<MobileConnectionCallback> requestCallback =
 634     new MobileConnectionCallback(GetOwner(), request);
 635
 636   nsresult rv = mMobileConnection->GetRoamingPreference(requestCallback);
 637   if (NS_FAILED(rv)) {
 638     aRv.Throw(rv);
 639     return nullptr;
 640   }
 641
 642   return request.forget();
 643 }
 644
 645 already_AddRefed<DOMRequest>
 646 MobileConnection::SetVoicePrivacyMode(bool aEnabled, ErrorResult& aRv)
 647 {
 648   if (!mMobileConnection) {
 649     aRv.Throw(NS_ERROR_FAILURE);
 650     return nullptr;
 651   }
 652
 653   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 654   nsRefPtr<MobileConnectionCallback> requestCallback =
 655     new MobileConnectionCallback(GetOwner(), request);
 656
 657   nsresult rv =
 658     mMobileConnection->SetVoicePrivacyMode(aEnabled, requestCallback);
 659   if (NS_FAILED(rv)) {
 660     aRv.Throw(rv);
 661     return nullptr;
 662   }
 663
 664   return request.forget();
 665 }
 666
 667 already_AddRefed<DOMRequest>
 668 MobileConnection::GetVoicePrivacyMode(ErrorResult& aRv)
 669 {
 670   if (!mMobileConnection) {
 671     aRv.Throw(NS_ERROR_FAILURE);
 672     return nullptr;
 673   }
 674
 675   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 676   nsRefPtr<MobileConnectionCallback> requestCallback =
 677     new MobileConnectionCallback(GetOwner(), request);
 678
 679   nsresult rv = mMobileConnection->GetVoicePrivacyMode(requestCallback);
 680   if (NS_FAILED(rv)) {
 681     aRv.Throw(rv);
 682     return nullptr;
 683   }
 684
 685   return request.forget();
 686 }
 687
 688 already_AddRefed<DOMRequest>
 689 MobileConnection::GetCallForwardingOption(uint16_t aReason, ErrorResult& aRv)
 690 {
 691   if (!mMobileConnection) {
 692     aRv.Throw(NS_ERROR_FAILURE);
 693     return nullptr;
 694   }
 695
 696   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 697
 698   if (!IsValidCallForwardingReason(aReason)) {
 699     nsresult rv = NotifyError(request, MOBILECONN_ERROR_INVALID_PARAMETER);
 700     if (NS_FAILED(rv)) {
 701       aRv.Throw(rv);
 702       return nullptr;
 703     }
 704     return request.forget();
 705   }
 706
 707   nsRefPtr<MobileConnectionCallback> requestCallback =
 708     new MobileConnectionCallback(GetOwner(), request);
 709
 710   nsresult rv = mMobileConnection->GetCallForwarding(aReason, requestCallback);
 711   if (NS_FAILED(rv)) {
 712     aRv.Throw(rv);
 713     return nullptr;
 714   }
 715
 716   return request.forget();
 717 }
 718
 719 already_AddRefed<DOMRequest>
 720 MobileConnection::SetCallForwardingOption(const MozCallForwardingOptions& aOptions,
 721                                           ErrorResult& aRv)
 722 {
 723   if (!mMobileConnection) {
 724     aRv.Throw(NS_ERROR_FAILURE);
 725     return nullptr;
 726   }
 727
 728   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 729
 730   if (!IsValidCallForwardingOptions(aOptions)) {
 731     nsresult rv = NotifyError(request, MOBILECONN_ERROR_INVALID_PARAMETER);
 732     if (NS_FAILED(rv)) {
 733       aRv.Throw(rv);
 734       return nullptr;
 735     }
 736     return request.forget();
 737   }
 738
 739   // Fill in optional attributes.
 740   uint16_t timeSeconds = 0;
 741   if (aOptions.mTimeSeconds.WasPassed() && !aOptions.mTimeSeconds.Value().IsNull()) {
 742     timeSeconds = aOptions.mTimeSeconds.Value().Value();
 743   }
 744   uint16_t serviceClass = nsIMobileConnection::ICC_SERVICE_CLASS_NONE;
 745   if (aOptions.mServiceClass.WasPassed() && !aOptions.mServiceClass.Value().IsNull()) {
 746     serviceClass = aOptions.mServiceClass.Value().Value();
 747   }
 748   nsAutoString number;
 749   if (aOptions.mNumber.WasPassed()) {
 750     number = aOptions.mNumber.Value();
 751   } else {
 752     number.SetIsVoid(true);
 753   }
 754
 755   nsRefPtr<MobileConnectionCallback> requestCallback =
 756     new MobileConnectionCallback(GetOwner(), request);
 757
 758   nsresult rv = mMobileConnection->SetCallForwarding(aOptions.mAction.Value().Value(),
 759                                                      aOptions.mReason.Value().Value(),
 760                                                      number,
 761                                                      timeSeconds,
 762                                                      serviceClass,
 763                                                      requestCallback);
 764   if (NS_FAILED(rv)) {
 765     aRv.Throw(rv);
 766     return nullptr;
 767   }
 768
 769   return request.forget();
 770 }
 771
 772 already_AddRefed<DOMRequest>
 773 MobileConnection::GetCallBarringOption(const MozCallBarringOptions& aOptions,
 774                                        ErrorResult& aRv)
 775 {
 776   if (!mMobileConnection) {
 777     aRv.Throw(NS_ERROR_FAILURE);
 778     return nullptr;
 779   }
 780
 781   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 782
 783   if (!IsValidCallBarringOptions(aOptions, false)) {
 784     nsresult rv = NotifyError(request, MOBILECONN_ERROR_INVALID_PARAMETER);
 785     if (NS_FAILED(rv)) {
 786       aRv.Throw(rv);
 787       return nullptr;
 788     }
 789     return request.forget();
 790   }
 791
 792   // Fill in optional attributes.
 793   nsAutoString password;
 794   if (aOptions.mPassword.WasPassed()) {
 795     password = aOptions.mPassword.Value();
 796   } else {
 797     password.SetIsVoid(true);
 798   }
 799
 800   nsRefPtr<MobileConnectionCallback> requestCallback =
 801     new MobileConnectionCallback(GetOwner(), request);
 802
 803   nsresult rv = mMobileConnection->GetCallBarring(aOptions.mProgram.Value().Value(),
 804                                                   password,
 805                                                   aOptions.mServiceClass.Value().Value(),
 806                                                   requestCallback);
 807   if (NS_FAILED(rv)) {
 808     aRv.Throw(rv);
 809     return nullptr;
 810   }
 811
 812   return request.forget();
 813 }
 814
 815 already_AddRefed<DOMRequest>
 816 MobileConnection::SetCallBarringOption(const MozCallBarringOptions& aOptions,
 817                                        ErrorResult& aRv)
 818 {
 819   if (!mMobileConnection) {
 820     aRv.Throw(NS_ERROR_FAILURE);
 821     return nullptr;
 822   }
 823
 824   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 825
 826   if (!IsValidCallBarringOptions(aOptions, true)) {
 827     nsresult rv = NotifyError(request, MOBILECONN_ERROR_INVALID_PARAMETER);
 828     if (NS_FAILED(rv)) {
 829       aRv.Throw(rv);
 830       return nullptr;
 831     }
 832     return request.forget();
 833   }
 834
 835   nsRefPtr<MobileConnectionCallback> requestCallback =
 836     new MobileConnectionCallback(GetOwner(), request);
 837
 838   nsresult rv = mMobileConnection->SetCallBarring(aOptions.mProgram.Value().Value(),
 839                                                   aOptions.mEnabled.Value().Value(),
 840                                                   aOptions.mPassword.Value(),
 841                                                   aOptions.mServiceClass.Value().Value(),
 842                                                   requestCallback);
 843   if (NS_FAILED(rv)) {
 844     aRv.Throw(rv);
 845     return nullptr;
 846   }
 847
 848   return request.forget();
 849 }
 850
 851 already_AddRefed<DOMRequest>
 852 MobileConnection::ChangeCallBarringPassword(const MozCallBarringOptions& aOptions,
 853                                             ErrorResult& aRv)
 854 {
 855   if (!mMobileConnection) {
 856     aRv.Throw(NS_ERROR_FAILURE);
 857     return nullptr;
 858   }
 859
 860   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 861
 862   if (!aOptions.mPin.WasPassed() || aOptions.mPin.Value().IsVoid() ||
 863       !aOptions.mNewPin.WasPassed() || aOptions.mNewPin.Value().IsVoid() ||
 864       !IsValidPassword(aOptions.mPin.Value()) ||
 865       !IsValidPassword(aOptions.mNewPin.Value())) {
 866     nsresult rv = NotifyError(request, MOBILECONN_ERROR_INVALID_PASSWORD);
 867     if (NS_FAILED(rv)) {
 868       aRv.Throw(rv);
 869       return nullptr;
 870     }
 871     return request.forget();
 872   }
 873
 874   nsRefPtr<MobileConnectionCallback> requestCallback =
 875     new MobileConnectionCallback(GetOwner(), request);
 876
 877   nsresult rv =
 878     mMobileConnection->ChangeCallBarringPassword(aOptions.mPin.Value(),
 879                                                  aOptions.mNewPin.Value(),
 880                                                  requestCallback);
 881   if (NS_FAILED(rv)) {
 882     aRv.Throw(rv);
 883     return nullptr;
 884   }
 885
 886   return request.forget();
 887 }
 888
 889 already_AddRefed<DOMRequest>
 890 MobileConnection::GetCallWaitingOption(ErrorResult& aRv)
 891 {
 892   if (!mMobileConnection) {
 893     aRv.Throw(NS_ERROR_FAILURE);
 894     return nullptr;
 895   }
 896
 897   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 898   nsRefPtr<MobileConnectionCallback> requestCallback =
 899     new MobileConnectionCallback(GetOwner(), request);
 900
 901   nsresult rv = mMobileConnection->GetCallWaiting(requestCallback);
 902   if (NS_FAILED(rv)) {
 903     aRv.Throw(rv);
 904     return nullptr;
 905   }
 906
 907   return request.forget();
 908 }
 909
 910 already_AddRefed<DOMRequest>
 911 MobileConnection::SetCallWaitingOption(bool aEnabled, ErrorResult& aRv)
 912 {
 913   if (!mMobileConnection) {
 914     aRv.Throw(NS_ERROR_FAILURE);
 915     return nullptr;
 916   }
 917
 918   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 919   nsRefPtr<MobileConnectionCallback> requestCallback =
 920     new MobileConnectionCallback(GetOwner(), request);
 921
 922   nsresult rv = mMobileConnection->SetCallWaiting(aEnabled, requestCallback);
 923   if (NS_FAILED(rv)) {
 924     aRv.Throw(rv);
 925     return nullptr;
 926   }
 927
 928   return request.forget();
 929 }
 930
 931 already_AddRefed<DOMRequest>
 932 MobileConnection::GetCallingLineIdRestriction(ErrorResult& aRv)
 933 {
 934   if (!mMobileConnection) {
 935     aRv.Throw(NS_ERROR_FAILURE);
 936     return nullptr;
 937   }
 938
 939   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 940   nsRefPtr<MobileConnectionCallback> requestCallback =
 941     new MobileConnectionCallback(GetOwner(), request);
 942
 943   nsresult rv =
 944     mMobileConnection->GetCallingLineIdRestriction(requestCallback);
 945   if (NS_FAILED(rv)) {
 946     aRv.Throw(rv);
 947     return nullptr;
 948   }
 949
 950   return request.forget();
 951 }
 952
 953 already_AddRefed<DOMRequest>
 954 MobileConnection::SetCallingLineIdRestriction(uint16_t aMode,
 955                                               ErrorResult& aRv)
 956 {
 957   if (!mMobileConnection) {
 958     aRv.Throw(NS_ERROR_FAILURE);
 959     return nullptr;
 960   }
 961
 962   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 963   nsRefPtr<MobileConnectionCallback> requestCallback =
 964     new MobileConnectionCallback(GetOwner(), request);
 965
 966   nsresult rv =
 967     mMobileConnection->SetCallingLineIdRestriction(aMode, requestCallback);
 968   if (NS_FAILED(rv)) {
 969     aRv.Throw(rv);
 970     return nullptr;
 971   }
 972
 973   return request.forget();
 974 }
 975
 976 already_AddRefed<DOMRequest>
 977 MobileConnection::ExitEmergencyCbMode(ErrorResult& aRv)
 978 {
 979   if (!mMobileConnection) {
 980     aRv.Throw(NS_ERROR_FAILURE);
 981     return nullptr;
 982   }
 983
 984   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 985   nsRefPtr<MobileConnectionCallback> requestCallback =
 986     new MobileConnectionCallback(GetOwner(), request);
 987
 988   nsresult rv = mMobileConnection->ExitEmergencyCbMode(requestCallback);
 989   if (NS_FAILED(rv)) {
 990     aRv.Throw(rv);
 991     return nullptr;
 992   }
 993
 994   return request.forget();
 995 }
 996
 997 already_AddRefed<DOMRequest>
 998 MobileConnection::SetRadioEnabled(bool aEnabled, ErrorResult& aRv)
 999 {
1000   if (!mMobileConnection) {
1001     aRv.Throw(NS_ERROR_FAILURE);
1002     return nullptr;
1003   }
1004
1005   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
1006   nsRefPtr<MobileConnectionCallback> requestCallback =
1007     new MobileConnectionCallback(GetOwner(), request);
1008
1009   nsresult rv = mMobileConnection->SetRadioEnabled(aEnabled, requestCallback);
1010   if (NS_FAILED(rv)) {
1011     aRv.Throw(rv);
1012     return nullptr;
1013   }
1014
1015   return request.forget();
1016 }
1017
1018 // nsIMobileConnectionListener
1019
1020 NS_IMETHODIMP
1021 MobileConnection::NotifyVoiceChanged()
1022 {
1023   if (!CheckPermission("mobileconnection")) {
1024     return NS_OK;
1025   }
1026
1027   UpdateVoice();
1028
1029   return DispatchTrustedEvent(NS_LITERAL_STRING("voicechange"));
1030 }
1031
1032 NS_IMETHODIMP
1033 MobileConnection::NotifyDataChanged()
1034 {
1035   if (!CheckPermission("mobileconnection")) {
1036     return NS_OK;
1037   }
1038
1039   UpdateData();
1040
1041   return DispatchTrustedEvent(NS_LITERAL_STRING("datachange"));
1042 }
1043
1044 NS_IMETHODIMP
1045 MobileConnection::NotifyDataError(const nsAString& aMessage)
1046 {
1047   if (!CheckPermission("mobileconnection")) {
1048     return NS_OK;
1049   }
1050
1051   DataErrorEventInit init;
1052   init.mBubbles = false;
1053   init.mCancelable = false;
1054   init.mMessage = aMessage;
1055
1056   nsRefPtr<DataErrorEvent> event =
1057     DataErrorEvent::Constructor(this, NS_LITERAL_STRING("dataerror"), init);
1058
1059   return DispatchTrustedEvent(event);
1060 }
1061
1062 NS_IMETHODIMP
1063 MobileConnection::NotifyCFStateChanged(unsigned short aAction,
1064                                        unsigned short aReason,
1065                                        const nsAString& aNumber,
1066                                        unsigned short aSeconds,
1067                                        unsigned short aServiceClass)
1068 {
1069   if (!CheckPermission("mobileconnection")) {
1070     return NS_OK;
1071   }
1072
1073   CFStateChangeEventInit init;
1074   init.mBubbles = false;
1075   init.mCancelable = false;
1076   init.mAction = aAction;
1077   init.mReason = aReason;
1078   init.mNumber = aNumber;
1079   init.mTimeSeconds = aSeconds;
1080   init.mServiceClass = aServiceClass;
1081
1082   nsRefPtr<CFStateChangeEvent> event =
1083     CFStateChangeEvent::Constructor(this, NS_LITERAL_STRING("cfstatechange"), init);
1084
1085   return DispatchTrustedEvent(event);
1086 }
1087
1088 NS_IMETHODIMP
1089 MobileConnection::NotifyEmergencyCbModeChanged(bool aActive,
1090                                                uint32_t aTimeoutMs)
1091 {
1092   if (!CheckPermission("mobileconnection")) {
1093     return NS_OK;
1094   }
1095
1096   MozEmergencyCbModeEventInit init;
1097   init.mBubbles = false;
1098   init.mCancelable = false;
1099   init.mActive = aActive;
1100   init.mTimeoutMs = aTimeoutMs;
1101
1102   nsRefPtr<MozEmergencyCbModeEvent> event =
1103     MozEmergencyCbModeEvent::Constructor(this, NS_LITERAL_STRING("emergencycbmodechange"), init);
1104
1105   return DispatchTrustedEvent(event);
1106 }
1107
1108 NS_IMETHODIMP
1109 MobileConnection::NotifyOtaStatusChanged(const nsAString& aStatus)
1110 {
1111   if (!CheckPermission("mobileconnection")) {
1112     return NS_OK;
1113   }
1114
1115   MozOtaStatusEventInit init;
1116   init.mBubbles = false;
1117   init.mCancelable = false;
1118   init.mStatus = aStatus;
1119
1120   nsRefPtr<MozOtaStatusEvent> event =
1121     MozOtaStatusEvent::Constructor(this, NS_LITERAL_STRING("otastatuschange"), init);
1122
1123   return DispatchTrustedEvent(event);
1124 }
1125
1126 NS_IMETHODIMP
1127 MobileConnection::NotifyRadioStateChanged()
1128 {
1129   if (!CheckPermission("mobileconnection")) {
1130     return NS_OK;
1131   }
1132
1133   return DispatchTrustedEvent(NS_LITERAL_STRING("radiostatechange"));
1134 }
1135
1136 NS_IMETHODIMP
1137 MobileConnection::NotifyClirModeChanged(uint32_t aMode)
1138 {
1139   if (!CheckPermission("mobileconnection")) {
1140     return NS_OK;
1141   }
1142
1143   MozClirModeEventInit init;
1144   init.mBubbles = false;
1145   init.mCancelable = false;
1146   init.mMode = aMode;
1147
1148   nsRefPtr<MozClirModeEvent> event =
1149     MozClirModeEvent::Constructor(this, NS_LITERAL_STRING("clirmodechange"), init);
1150
1151   return DispatchTrustedEvent(event);
1152 }
1153
1154 NS_IMETHODIMP
1155 MobileConnection::NotifyLastKnownNetworkChanged()
1156 {
1157   return NS_OK;
1158 }
1159
1160 NS_IMETHODIMP
1161 MobileConnection::NotifyLastKnownHomeNetworkChanged()
1162 {
1163   return NS_OK;
1164 }
1165
1166 NS_IMETHODIMP
1167 MobileConnection::NotifyNetworkSelectionModeChanged()
1168 {
1169   return NS_OK;
1170 }
1171
1172 #ifdef MOZ_B2G_RIL
1173 // nsIIccListener
1174
1175 NS_IMETHODIMP
1176 MobileConnection::NotifyStkCommand(const nsAString& aMessage)
1177 {
1178   return NS_OK;
1179 }
1180
1181 NS_IMETHODIMP
1182 MobileConnection::NotifyStkSessionEnd()
1183 {
1184   return NS_OK;
1185 }
1186
1187 NS_IMETHODIMP
1188 MobileConnection::NotifyCardStateChanged()
1189 {
1190   return NS_OK;
1191 }
1192
1193 NS_IMETHODIMP
1194 MobileConnection::NotifyIccInfoChanged()
1195 {
1196   if (!CheckPermission("mobileconnection")) {
1197     return NS_OK;
1198   }
1199
1200   if (!UpdateIccId()) {
1201     return NS_OK;
1202   }
1203
1204   nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
1205     new AsyncEventDispatcher(this, NS_LITERAL_STRING("iccchange"), false);
1206
1207   return asyncDispatcher->PostDOMEvent();
1208 }
1209 #endif // MOZ_B2G_RIL