dom/mobilemessage/MobileMessageManager.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   4  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "MobileMessageManager.h"
   7
   8 #include "DeletedMessageInfo.h"
   9 #include "DOMCursor.h"
  10 #include "DOMRequest.h"
  11 #include "MobileMessageCallback.h"
  12 #include "MobileMessageCursorCallback.h"
  13 #include "mozilla/dom/mobilemessage/Constants.h" // For kSms*ObserverTopic
  14 #include "mozilla/dom/MozMessageDeletedEvent.h"
  15 #include "mozilla/dom/MozMmsEvent.h"
  16 #include "mozilla/dom/MozMobileMessageManagerBinding.h"
  17 #include "mozilla/dom/MozSmsEvent.h"
  18 #include "mozilla/dom/ToJSValue.h"
  19 #include "mozilla/Preferences.h"
  20 #include "mozilla/Services.h"
  21 #include "nsIDOMMozMmsMessage.h"
  22 #include "nsIDOMMozSmsMessage.h"
  23 #include "nsIMmsService.h"
  24 #include "nsIMobileMessageCallback.h"
  25 #include "nsIMobileMessageDatabaseService.h"
  26 #include "nsIObserverService.h"
  27 #include "nsISmsService.h"
  28 #include "nsServiceManagerUtils.h" // For do_GetService()
  29
  30 #define RECEIVED_EVENT_NAME         NS_LITERAL_STRING("received")
  31 #define RETRIEVING_EVENT_NAME       NS_LITERAL_STRING("retrieving")
  32 #define SENDING_EVENT_NAME          NS_LITERAL_STRING("sending")
  33 #define SENT_EVENT_NAME             NS_LITERAL_STRING("sent")
  34 #define FAILED_EVENT_NAME           NS_LITERAL_STRING("failed")
  35 #define DELIVERY_SUCCESS_EVENT_NAME NS_LITERAL_STRING("deliverysuccess")
  36 #define DELIVERY_ERROR_EVENT_NAME   NS_LITERAL_STRING("deliveryerror")
  37 #define READ_SUCCESS_EVENT_NAME     NS_LITERAL_STRING("readsuccess")
  38 #define READ_ERROR_EVENT_NAME       NS_LITERAL_STRING("readerror")
  39 #define DELETED_EVENT_NAME          NS_LITERAL_STRING("deleted")
  40
  41 using namespace mozilla::dom::mobilemessage;
  42
  43 namespace mozilla {
  44 namespace dom {
  45
  46 NS_INTERFACE_MAP_BEGIN(MobileMessageManager)
  47   NS_INTERFACE_MAP_ENTRY(nsIObserver)
  48 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
  49
  50 NS_IMPL_ADDREF_INHERITED(MobileMessageManager, DOMEventTargetHelper)
  51 NS_IMPL_RELEASE_INHERITED(MobileMessageManager, DOMEventTargetHelper)
  52
  53 MobileMessageManager::MobileMessageManager(nsPIDOMWindow *aWindow)
  54   : DOMEventTargetHelper(aWindow)
  55 {
  56 }
  57
  58 void
  59 MobileMessageManager::Init()
  60 {
  61   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
  62   // GetObserverService() can return null is some situations like shutdown.
  63   if (!obs) {
  64     return;
  65   }
  66
  67   obs->AddObserver(this, kSmsReceivedObserverTopic, false);
  68   obs->AddObserver(this, kSmsRetrievingObserverTopic, false);
  69   obs->AddObserver(this, kSmsSendingObserverTopic, false);
  70   obs->AddObserver(this, kSmsSentObserverTopic, false);
  71   obs->AddObserver(this, kSmsFailedObserverTopic, false);
  72   obs->AddObserver(this, kSmsDeliverySuccessObserverTopic, false);
  73   obs->AddObserver(this, kSmsDeliveryErrorObserverTopic, false);
  74   obs->AddObserver(this, kSmsReadSuccessObserverTopic, false);
  75   obs->AddObserver(this, kSmsReadErrorObserverTopic, false);
  76   obs->AddObserver(this, kSmsDeletedObserverTopic, false);
  77 }
  78
  79 void
  80 MobileMessageManager::Shutdown()
  81 {
  82   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
  83   // GetObserverService() can return null is some situations like shutdown.
  84   if (!obs) {
  85     return;
  86   }
  87
  88   obs->RemoveObserver(this, kSmsReceivedObserverTopic);
  89   obs->RemoveObserver(this, kSmsRetrievingObserverTopic);
  90   obs->RemoveObserver(this, kSmsSendingObserverTopic);
  91   obs->RemoveObserver(this, kSmsSentObserverTopic);
  92   obs->RemoveObserver(this, kSmsFailedObserverTopic);
  93   obs->RemoveObserver(this, kSmsDeliverySuccessObserverTopic);
  94   obs->RemoveObserver(this, kSmsDeliveryErrorObserverTopic);
  95   obs->RemoveObserver(this, kSmsReadSuccessObserverTopic);
  96   obs->RemoveObserver(this, kSmsReadErrorObserverTopic);
  97   obs->RemoveObserver(this, kSmsDeletedObserverTopic);
  98 }
  99
 100 JSObject*
 101 MobileMessageManager::WrapObject(JSContext* aCx)
 102 {
 103   return MozMobileMessageManagerBinding::Wrap(aCx, this);
 104 }
 105
 106 already_AddRefed<DOMRequest>
 107 MobileMessageManager::GetSegmentInfoForText(const nsAString& aText,
 108                                             ErrorResult& aRv)
 109 {
 110   nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
 111   if (!smsService) {
 112     aRv.Throw(NS_ERROR_FAILURE);
 113     return nullptr;
 114   }
 115
 116   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 117   nsCOMPtr<nsIMobileMessageCallback> msgCallback =
 118     new MobileMessageCallback(request);
 119   nsresult rv = smsService->GetSegmentInfoForText(aText, msgCallback);
 120   if (NS_FAILED(rv)) {
 121     aRv.Throw(rv);
 122     return nullptr;
 123   }
 124
 125   return request.forget();
 126 }
 127
 128 already_AddRefed<DOMRequest>
 129 MobileMessageManager::Send(nsISmsService* aSmsService,
 130                            uint32_t aServiceId,
 131                            const nsAString& aNumber,
 132                            const nsAString& aText,
 133                            ErrorResult& aRv)
 134 {
 135   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 136   nsCOMPtr<nsIMobileMessageCallback> msgCallback =
 137     new MobileMessageCallback(request);
 138
 139   // By default, we don't send silent messages via MobileMessageManager.
 140   nsresult rv = aSmsService->Send(aServiceId, aNumber, aText,
 141                                   false, msgCallback);
 142   if (NS_FAILED(rv)) {
 143     aRv.Throw(rv);
 144     return nullptr;
 145   }
 146
 147   return request.forget();
 148 }
 149
 150 already_AddRefed<DOMRequest>
 151 MobileMessageManager::Send(const nsAString& aNumber,
 152                            const nsAString& aText,
 153                            const SmsSendParameters& aSendParams,
 154                            ErrorResult& aRv)
 155 {
 156   nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
 157   if (!smsService) {
 158     aRv.Throw(NS_ERROR_FAILURE);
 159     return nullptr;
 160   }
 161
 162   // Use the default one unless |aSendParams.serviceId| is available.
 163   uint32_t serviceId;
 164   if (aSendParams.mServiceId.WasPassed()) {
 165     serviceId = aSendParams.mServiceId.Value();
 166   } else {
 167     nsresult rv = smsService->GetSmsDefaultServiceId(&serviceId);
 168     if (NS_FAILED(rv)) {
 169       aRv.Throw(rv);
 170       return nullptr;
 171     }
 172   }
 173
 174   return Send(smsService, serviceId, aNumber, aText, aRv);
 175 }
 176
 177 void
 178 MobileMessageManager::Send(const Sequence<nsString>& aNumbers,
 179                            const nsAString& aText,
 180                            const SmsSendParameters& aSendParams,
 181                            nsTArray<nsRefPtr<DOMRequest>>& aReturn,
 182                            ErrorResult& aRv)
 183 {
 184   nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
 185   if (!smsService) {
 186     aRv.Throw(NS_ERROR_FAILURE);
 187     return;
 188   }
 189
 190   // Use the default one unless |aSendParams.serviceId| is available.
 191   uint32_t serviceId;
 192   if (aSendParams.mServiceId.WasPassed()) {
 193     serviceId = aSendParams.mServiceId.Value();
 194   } else {
 195     nsresult rv = smsService->GetSmsDefaultServiceId(&serviceId);
 196     if (NS_FAILED(rv)) {
 197       aRv.Throw(rv);
 198       return;
 199     }
 200   }
 201
 202   const uint32_t size = aNumbers.Length();
 203   for (uint32_t i = 0; i < size; ++i) {
 204     nsRefPtr<DOMRequest> request = Send(smsService, serviceId, aNumbers[i], aText, aRv);
 205     if (aRv.Failed()) {
 206       return;
 207     }
 208     aReturn.AppendElement(request);
 209   }
 210 }
 211
 212 already_AddRefed<DOMRequest>
 213 MobileMessageManager::SendMMS(const MmsParameters& aParams,
 214                               const MmsSendParameters& aSendParams,
 215                               ErrorResult& aRv)
 216 {
 217   nsCOMPtr<nsIMmsService> mmsService = do_GetService(MMS_SERVICE_CONTRACTID);
 218   if (!mmsService) {
 219     aRv.Throw(NS_ERROR_FAILURE);
 220     return nullptr;
 221   }
 222
 223   // Use the default one unless |aSendParams.serviceId| is available.
 224   uint32_t serviceId;
 225   nsresult rv;
 226   if (aSendParams.mServiceId.WasPassed()) {
 227     serviceId = aSendParams.mServiceId.Value();
 228   } else {
 229     rv = mmsService->GetMmsDefaultServiceId(&serviceId);
 230     if (NS_FAILED(rv)) {
 231       aRv.Throw(rv);
 232       return nullptr;
 233     }
 234   }
 235
 236   AutoJSAPI jsapi;
 237   if (!NS_WARN_IF(jsapi.Init(GetOwner()))) {
 238     aRv.Throw(NS_ERROR_FAILURE);
 239     return nullptr;
 240   }
 241
 242   JSContext *cx = jsapi.cx();
 243   JS::Rooted<JS::Value> val(cx);
 244   if (!ToJSValue(cx, aParams, &val)) {
 245     aRv.Throw(NS_ERROR_TYPE_ERR);
 246     return nullptr;
 247   }
 248
 249   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 250   nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
 251   rv = mmsService->Send(serviceId, val, msgCallback);
 252   if (NS_FAILED(rv)) {
 253     aRv.Throw(rv);
 254     return nullptr;
 255   }
 256
 257   return request.forget();
 258 }
 259
 260 already_AddRefed<DOMRequest>
 261 MobileMessageManager::GetMessage(int32_t aId,
 262                                  ErrorResult& aRv)
 263 {
 264   nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
 265     do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
 266   if (!dbService) {
 267     aRv.Throw(NS_ERROR_FAILURE);
 268     return nullptr;
 269   }
 270
 271   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 272   nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
 273   nsresult rv = dbService->GetMessageMoz(aId, msgCallback);
 274   if (NS_FAILED(rv)) {
 275     aRv.Throw(rv);
 276     return nullptr;
 277   }
 278
 279   return request.forget();
 280 }
 281
 282 already_AddRefed<DOMRequest>
 283 MobileMessageManager::Delete(int32_t* aIdArray,
 284                              uint32_t aSize,
 285                              ErrorResult& aRv)
 286 {
 287   nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
 288     do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
 289   if (!dbService) {
 290     aRv.Throw(NS_ERROR_FAILURE);
 291     return nullptr;
 292   }
 293
 294   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 295   nsCOMPtr<nsIMobileMessageCallback> msgCallback =
 296     new MobileMessageCallback(request);
 297
 298   nsresult rv = dbService->DeleteMessage(aIdArray, aSize, msgCallback);
 299   if (NS_FAILED(rv)) {
 300     aRv.Throw(rv);
 301     return nullptr;
 302   }
 303
 304   return request.forget();
 305 }
 306
 307 already_AddRefed<DOMRequest>
 308 MobileMessageManager::Delete(int32_t aId,
 309                              ErrorResult& aRv)
 310 {
 311   return Delete(&aId, 1, aRv);
 312 }
 313
 314 already_AddRefed<DOMRequest>
 315 MobileMessageManager::Delete(nsIDOMMozSmsMessage* aMessage,
 316                              ErrorResult& aRv)
 317 {
 318   int32_t id;
 319
 320   DebugOnly<nsresult> rv = aMessage->GetId(&id);
 321   MOZ_ASSERT(NS_SUCCEEDED(rv));
 322
 323   return Delete(id, aRv);
 324 }
 325
 326 already_AddRefed<DOMRequest>
 327 MobileMessageManager::Delete(nsIDOMMozMmsMessage* aMessage,
 328                              ErrorResult& aRv)
 329 {
 330   int32_t id;
 331
 332   DebugOnly<nsresult> rv = aMessage->GetId(&id);
 333   MOZ_ASSERT(NS_SUCCEEDED(rv));
 334
 335   return Delete(id, aRv);
 336 }
 337
 338 already_AddRefed<DOMRequest>
 339 MobileMessageManager::Delete(const Sequence<OwningLongOrMozSmsMessageOrMozMmsMessage>& aParams,
 340                              ErrorResult& aRv)
 341 {
 342   const uint32_t size = aParams.Length();
 343   FallibleTArray<int32_t> idArray;
 344   if (!idArray.SetLength(size)) {
 345     aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
 346     return nullptr;
 347   }
 348
 349   DebugOnly<nsresult> rv;
 350   for (uint32_t i = 0; i < size; i++) {
 351     const OwningLongOrMozSmsMessageOrMozMmsMessage& element = aParams[i];
 352     int32_t &id = idArray[i];
 353
 354     if (element.IsLong()) {
 355       id = element.GetAsLong();
 356     } else if (element.IsMozMmsMessage()) {
 357       rv = element.GetAsMozMmsMessage()->GetId(&id);
 358       MOZ_ASSERT(NS_SUCCEEDED(rv));
 359     } else /*if (element.IsMozSmsMessage())*/ {
 360       rv = element.GetAsMozSmsMessage()->GetId(&id);
 361       MOZ_ASSERT(NS_SUCCEEDED(rv));
 362     }
 363   }
 364
 365   return Delete(idArray.Elements(), size, aRv);
 366 }
 367
 368 already_AddRefed<DOMCursor>
 369 MobileMessageManager::GetMessages(const MobileMessageFilter& aFilter,
 370                                   bool aReverse,
 371                                   ErrorResult& aRv)
 372 {
 373   nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
 374     do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
 375   if (!dbService) {
 376     aRv.Throw(NS_ERROR_FAILURE);
 377     return nullptr;
 378   }
 379
 380   bool hasStartDate = !aFilter.mStartDate.IsNull();
 381   uint64_t startDate = 0;
 382   if (hasStartDate) {
 383     startDate = aFilter.mStartDate.Value();
 384   }
 385
 386   bool hasEndDate = !aFilter.mEndDate.IsNull();
 387   uint64_t endDate = 0;
 388   if (hasEndDate) {
 389     endDate = aFilter.mEndDate.Value();
 390   }
 391
 392   nsAutoArrayPtr<const char16_t*> ptrNumbers;
 393   uint32_t numbersCount = 0;
 394   if (!aFilter.mNumbers.IsNull() &&
 395       aFilter.mNumbers.Value().Length()) {
 396     const FallibleTArray<nsString>& numbers = aFilter.mNumbers.Value();
 397     uint32_t index;
 398
 399     numbersCount = numbers.Length();
 400     ptrNumbers = new const char16_t* [numbersCount];
 401     for (index = 0; index < numbersCount; index++) {
 402       ptrNumbers[index] = numbers[index].get();
 403     }
 404   }
 405
 406   nsString delivery;
 407   delivery.SetIsVoid(true);
 408   if (!aFilter.mDelivery.IsNull()) {
 409     const uint32_t index = static_cast<uint32_t>(aFilter.mDelivery.Value());
 410     const EnumEntry& entry =
 411       MobileMessageFilterDeliveryValues::strings[index];
 412     delivery.AssignASCII(entry.value, entry.length);
 413   }
 414
 415   bool hasRead = !aFilter.mRead.IsNull();
 416   bool read = false;
 417   if (hasRead) {
 418     read = aFilter.mRead.Value();
 419   }
 420
 421   uint64_t threadId = 0;
 422   if (!aFilter.mThreadId.IsNull()) {
 423     threadId = aFilter.mThreadId.Value();
 424   }
 425
 426   nsRefPtr<MobileMessageCursorCallback> cursorCallback =
 427     new MobileMessageCursorCallback();
 428   nsCOMPtr<nsICursorContinueCallback> continueCallback;
 429   nsresult rv = dbService->CreateMessageCursor(hasStartDate, startDate,
 430                                                hasEndDate, endDate,
 431                                                ptrNumbers, numbersCount,
 432                                                delivery,
 433                                                hasRead, read,
 434                                                threadId,
 435                                                aReverse, cursorCallback,
 436                                                getter_AddRefs(continueCallback));
 437   if (NS_FAILED(rv)) {
 438     aRv.Throw(rv);
 439     return nullptr;
 440   }
 441
 442   cursorCallback->mDOMCursor =
 443     new MobileMessageCursor(GetOwner(), continueCallback);
 444
 445   nsRefPtr<DOMCursor> cursor(cursorCallback->mDOMCursor);
 446   return cursor.forget();
 447 }
 448
 449 already_AddRefed<DOMRequest>
 450 MobileMessageManager::MarkMessageRead(int32_t aId,
 451                                       bool aValue,
 452                                       bool aSendReadReport,
 453                                       ErrorResult& aRv)
 454 {
 455   nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
 456     do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
 457   if (!dbService) {
 458     aRv.Throw(NS_ERROR_FAILURE);
 459     return nullptr;
 460   }
 461
 462   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 463   nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
 464   nsresult rv = dbService->MarkMessageRead(aId, aValue, aSendReadReport,
 465                                            msgCallback);
 466   if (NS_FAILED(rv)) {
 467     aRv.Throw(rv);
 468     return nullptr;
 469   }
 470
 471   return request.forget();
 472 }
 473
 474 already_AddRefed<DOMCursor>
 475 MobileMessageManager::GetThreads(ErrorResult& aRv)
 476 {
 477   nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
 478     do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
 479   if (!dbService) {
 480     aRv.Throw(NS_ERROR_FAILURE);
 481     return nullptr;
 482   }
 483
 484   nsRefPtr<MobileMessageCursorCallback> cursorCallback =
 485     new MobileMessageCursorCallback();
 486
 487   nsCOMPtr<nsICursorContinueCallback> continueCallback;
 488   nsresult rv = dbService->CreateThreadCursor(cursorCallback,
 489                                               getter_AddRefs(continueCallback));
 490   if (NS_FAILED(rv)) {
 491     aRv.Throw(rv);
 492     return nullptr;
 493   }
 494
 495   cursorCallback->mDOMCursor =
 496     new MobileMessageCursor(GetOwner(), continueCallback);
 497
 498   nsRefPtr<DOMCursor> cursor(cursorCallback->mDOMCursor);
 499   return cursor.forget();
 500 }
 501
 502 already_AddRefed<DOMRequest>
 503 MobileMessageManager::RetrieveMMS(int32_t aId,
 504                                   ErrorResult& aRv)
 505 {
 506   nsCOMPtr<nsIMmsService> mmsService = do_GetService(MMS_SERVICE_CONTRACTID);
 507   if (!mmsService) {
 508     aRv.Throw(NS_ERROR_FAILURE);
 509     return nullptr;
 510   }
 511
 512   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 513   nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
 514
 515   nsresult rv = mmsService->Retrieve(aId, msgCallback);
 516   if (NS_FAILED(rv)) {
 517     aRv.Throw(rv);
 518     return nullptr;
 519   }
 520
 521   return request.forget();
 522 }
 523
 524 already_AddRefed<DOMRequest>
 525 MobileMessageManager::RetrieveMMS(nsIDOMMozMmsMessage* aMessage,
 526                                   ErrorResult& aRv)
 527 {
 528   int32_t id;
 529
 530   DebugOnly<nsresult> rv = aMessage->GetId(&id);
 531   MOZ_ASSERT(NS_SUCCEEDED(rv));
 532
 533   return RetrieveMMS(id, aRv);
 534 }
 535
 536 nsresult
 537 MobileMessageManager::DispatchTrustedSmsEventToSelf(const char* aTopic,
 538                                                     const nsAString& aEventName,
 539                                                     nsISupports* aMsg)
 540 {
 541   nsCOMPtr<nsIDOMMozSmsMessage> sms = do_QueryInterface(aMsg);
 542   if (sms) {
 543     MozSmsEventInit init;
 544     init.mBubbles = false;
 545     init.mCancelable = false;
 546     init.mMessage = sms;
 547
 548     nsRefPtr<MozSmsEvent> event =
 549       MozSmsEvent::Constructor(this, aEventName, init);
 550     return DispatchTrustedEvent(event);
 551   }
 552
 553   nsCOMPtr<nsIDOMMozMmsMessage> mms = do_QueryInterface(aMsg);
 554   if (mms) {
 555     MozMmsEventInit init;
 556     init.mBubbles = false;
 557     init.mCancelable = false;
 558     init.mMessage = mms;
 559
 560     nsRefPtr<MozMmsEvent> event =
 561       MozMmsEvent::Constructor(this, aEventName, init);
 562     return DispatchTrustedEvent(event);
 563   }
 564
 565   nsAutoCString errorMsg;
 566   errorMsg.AssignLiteral("Got a '");
 567   errorMsg.Append(aTopic);
 568   errorMsg.AppendLiteral("' topic without a valid message!");
 569   NS_ERROR(errorMsg.get());
 570   return NS_OK;
 571 }
 572
 573 nsresult
 574 MobileMessageManager::DispatchTrustedDeletedEventToSelf(nsISupports* aDeletedInfo)
 575 {
 576   nsCOMPtr<nsIDeletedMessageInfo> deletedInfo = do_QueryInterface(aDeletedInfo);
 577   if (deletedInfo) {
 578     MozMessageDeletedEventInit init;
 579     init.mBubbles = false;
 580     init.mCancelable = false;
 581     DeletedMessageInfo* info =
 582       static_cast<DeletedMessageInfo*>(deletedInfo.get());
 583
 584     uint32_t msgIdLength = info->GetData().deletedMessageIds().Length();
 585     if (msgIdLength) {
 586       Sequence<int32_t>& deletedMsgIds = init.mDeletedMessageIds.SetValue();
 587       deletedMsgIds.AppendElements(info->GetData().deletedMessageIds());
 588     }
 589
 590     uint32_t threadIdLength = info->GetData().deletedThreadIds().Length();
 591     if (threadIdLength) {
 592       Sequence<uint64_t>& deletedThreadIds = init.mDeletedThreadIds.SetValue();
 593       deletedThreadIds.AppendElements(info->GetData().deletedThreadIds());
 594     }
 595
 596     nsRefPtr<MozMessageDeletedEvent> event =
 597       MozMessageDeletedEvent::Constructor(this, DELETED_EVENT_NAME, init);
 598     return DispatchTrustedEvent(event);
 599   }
 600
 601   NS_ERROR("Got a 'deleted' topic without a valid message!");
 602
 603   return NS_OK;
 604 }
 605
 606 NS_IMETHODIMP
 607 MobileMessageManager::Observe(nsISupports* aSubject, const char* aTopic,
 608                               const char16_t* aData)
 609 {
 610   if (!strcmp(aTopic, kSmsReceivedObserverTopic)) {
 611     return DispatchTrustedSmsEventToSelf(aTopic, RECEIVED_EVENT_NAME, aSubject);
 612   }
 613
 614   if (!strcmp(aTopic, kSmsRetrievingObserverTopic)) {
 615     return DispatchTrustedSmsEventToSelf(aTopic, RETRIEVING_EVENT_NAME, aSubject);
 616   }
 617
 618   if (!strcmp(aTopic, kSmsSendingObserverTopic)) {
 619     return DispatchTrustedSmsEventToSelf(aTopic, SENDING_EVENT_NAME, aSubject);
 620   }
 621
 622   if (!strcmp(aTopic, kSmsSentObserverTopic)) {
 623     return DispatchTrustedSmsEventToSelf(aTopic, SENT_EVENT_NAME, aSubject);
 624   }
 625
 626   if (!strcmp(aTopic, kSmsFailedObserverTopic)) {
 627     return DispatchTrustedSmsEventToSelf(aTopic, FAILED_EVENT_NAME, aSubject);
 628   }
 629
 630   if (!strcmp(aTopic, kSmsDeliverySuccessObserverTopic)) {
 631     return DispatchTrustedSmsEventToSelf(aTopic, DELIVERY_SUCCESS_EVENT_NAME, aSubject);
 632   }
 633
 634   if (!strcmp(aTopic, kSmsDeliveryErrorObserverTopic)) {
 635     return DispatchTrustedSmsEventToSelf(aTopic, DELIVERY_ERROR_EVENT_NAME, aSubject);
 636   }
 637
 638   if (!strcmp(aTopic, kSmsReadSuccessObserverTopic)) {
 639     return DispatchTrustedSmsEventToSelf(aTopic, READ_SUCCESS_EVENT_NAME, aSubject);
 640   }
 641
 642   if (!strcmp(aTopic, kSmsReadErrorObserverTopic)) {
 643     return DispatchTrustedSmsEventToSelf(aTopic, READ_ERROR_EVENT_NAME, aSubject);
 644   }
 645
 646   if (!strcmp(aTopic, kSmsDeletedObserverTopic)) {
 647     return DispatchTrustedDeletedEventToSelf(aSubject);
 648   }
 649
 650   return NS_OK;
 651 }
 652
 653 already_AddRefed<DOMRequest>
 654 MobileMessageManager::GetSmscAddress(const Optional<uint32_t>& aServiceId,
 655                                      ErrorResult& aRv)
 656 {
 657   nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
 658   if (!smsService) {
 659     aRv.Throw(NS_ERROR_FAILURE);
 660     return nullptr;
 661   }
 662
 663   // Use the default one unless |aSendParams.serviceId| is available.
 664   uint32_t serviceId;
 665   nsresult rv;
 666   if (aServiceId.WasPassed()) {
 667     serviceId = aServiceId.Value();
 668   } else {
 669     rv = smsService->GetSmsDefaultServiceId(&serviceId);
 670     if (NS_FAILED(rv)) {
 671       aRv.Throw(rv);
 672       return nullptr;
 673     }
 674   }
 675
 676   nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
 677   nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
 678   rv = smsService->GetSmscAddress(serviceId, msgCallback);
 679   if (NS_FAILED(rv)) {
 680     aRv.Throw(rv);
 681     return nullptr;
 682   }
 683
 684   return request.forget();
 685 }
 686
 687 } // namespace dom
 688 } // namespace mozilla