dom/mobilemessage/src/MobileMessageManager.cpp@6474c204b198
dom/mobilemessage/src/MobileMessageManager.cpp
Wed, 31 Dec 2014 06:09:35 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Wed, 31 Dec 2014 06:09:35 +0100
- changeset 0
- 6474c204b198
- permissions
- -rw-r--r--
Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.
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/. */
6 #include "SmsFilter.h"
7 #include "MobileMessageManager.h"
8 #include "nsIDOMClassInfo.h"
9 #include "nsISmsService.h"
10 #include "nsIMmsService.h"
11 #include "nsIObserverService.h"
12 #include "mozilla/Preferences.h"
13 #include "mozilla/Services.h"
14 #include "mozilla/dom/mobilemessage/Constants.h" // For MessageType
15 #include "mozilla/dom/MobileMessageManagerBinding.h"
16 #include "mozilla/dom/MozMmsMessageBinding.h"
17 #include "nsIDOMMozSmsEvent.h"
18 #include "nsIDOMMozMmsEvent.h"
19 #include "nsIDOMMozSmsMessage.h"
20 #include "nsIDOMMozMmsMessage.h"
21 #include "nsJSUtils.h"
22 #include "nsContentUtils.h"
23 #include "nsCxPusher.h"
24 #include "nsIMobileMessageDatabaseService.h"
25 #include "nsIXPConnect.h"
26 #include "nsIPermissionManager.h"
27 #include "GeneratedEvents.h"
28 #include "DOMRequest.h"
29 #include "nsIMobileMessageCallback.h"
30 #include "MobileMessageCallback.h"
31 #include "MobileMessageCursorCallback.h"
32 #include "DOMCursor.h"
34 #define RECEIVED_EVENT_NAME NS_LITERAL_STRING("received")
35 #define RETRIEVING_EVENT_NAME NS_LITERAL_STRING("retrieving")
36 #define SENDING_EVENT_NAME NS_LITERAL_STRING("sending")
37 #define SENT_EVENT_NAME NS_LITERAL_STRING("sent")
38 #define FAILED_EVENT_NAME NS_LITERAL_STRING("failed")
39 #define DELIVERY_SUCCESS_EVENT_NAME NS_LITERAL_STRING("deliverysuccess")
40 #define DELIVERY_ERROR_EVENT_NAME NS_LITERAL_STRING("deliveryerror")
41 #define READ_SUCCESS_EVENT_NAME NS_LITERAL_STRING("readsuccess")
42 #define READ_ERROR_EVENT_NAME NS_LITERAL_STRING("readerror")
44 using namespace mozilla::dom::mobilemessage;
46 DOMCI_DATA(MozMobileMessageManager, mozilla::dom::MobileMessageManager)
48 namespace mozilla {
49 namespace dom {
51 NS_INTERFACE_MAP_BEGIN(MobileMessageManager)
52 NS_INTERFACE_MAP_ENTRY(nsIDOMMozMobileMessageManager)
53 NS_INTERFACE_MAP_ENTRY(nsIObserver)
54 NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(MozMobileMessageManager)
55 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
57 NS_IMPL_ADDREF_INHERITED(MobileMessageManager, DOMEventTargetHelper)
58 NS_IMPL_RELEASE_INHERITED(MobileMessageManager, DOMEventTargetHelper)
60 NS_IMPL_EVENT_HANDLER(MobileMessageManager, received)
61 NS_IMPL_EVENT_HANDLER(MobileMessageManager, retrieving)
62 NS_IMPL_EVENT_HANDLER(MobileMessageManager, sending)
63 NS_IMPL_EVENT_HANDLER(MobileMessageManager, sent)
64 NS_IMPL_EVENT_HANDLER(MobileMessageManager, failed)
65 NS_IMPL_EVENT_HANDLER(MobileMessageManager, deliverysuccess)
66 NS_IMPL_EVENT_HANDLER(MobileMessageManager, deliveryerror)
67 NS_IMPL_EVENT_HANDLER(MobileMessageManager, readsuccess)
68 NS_IMPL_EVENT_HANDLER(MobileMessageManager, readerror)
70 void
71 MobileMessageManager::Init(nsPIDOMWindow *aWindow)
72 {
73 BindToOwner(aWindow);
75 nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
76 // GetObserverService() can return null is some situations like shutdown.
77 if (!obs) {
78 return;
79 }
81 obs->AddObserver(this, kSmsReceivedObserverTopic, false);
82 obs->AddObserver(this, kSmsRetrievingObserverTopic, false);
83 obs->AddObserver(this, kSmsSendingObserverTopic, false);
84 obs->AddObserver(this, kSmsSentObserverTopic, false);
85 obs->AddObserver(this, kSmsFailedObserverTopic, false);
86 obs->AddObserver(this, kSmsDeliverySuccessObserverTopic, false);
87 obs->AddObserver(this, kSmsDeliveryErrorObserverTopic, false);
88 obs->AddObserver(this, kSmsReadSuccessObserverTopic, false);
89 obs->AddObserver(this, kSmsReadErrorObserverTopic, false);
90 }
92 void
93 MobileMessageManager::Shutdown()
94 {
95 nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
96 // GetObserverService() can return null is some situations like shutdown.
97 if (!obs) {
98 return;
99 }
101 obs->RemoveObserver(this, kSmsReceivedObserverTopic);
102 obs->RemoveObserver(this, kSmsRetrievingObserverTopic);
103 obs->RemoveObserver(this, kSmsSendingObserverTopic);
104 obs->RemoveObserver(this, kSmsSentObserverTopic);
105 obs->RemoveObserver(this, kSmsFailedObserverTopic);
106 obs->RemoveObserver(this, kSmsDeliverySuccessObserverTopic);
107 obs->RemoveObserver(this, kSmsDeliveryErrorObserverTopic);
108 obs->RemoveObserver(this, kSmsReadSuccessObserverTopic);
109 obs->RemoveObserver(this, kSmsReadErrorObserverTopic);
110 }
112 NS_IMETHODIMP
113 MobileMessageManager::GetSegmentInfoForText(const nsAString& aText,
114 nsIDOMDOMRequest** aRequest)
115 {
116 nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
117 NS_ENSURE_TRUE(smsService, NS_ERROR_FAILURE);
119 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
120 nsCOMPtr<nsIMobileMessageCallback> msgCallback =
121 new MobileMessageCallback(request);
122 nsresult rv = smsService->GetSegmentInfoForText(aText, msgCallback);
123 NS_ENSURE_SUCCESS(rv, rv);
125 request.forget(aRequest);
126 return NS_OK;
127 }
129 nsresult
130 MobileMessageManager::Send(JSContext* aCx, JS::Handle<JSObject*> aGlobal,
131 uint32_t aServiceId,
132 JS::Handle<JSString*> aNumber,
133 const nsAString& aMessage,
134 JS::Value* aRequest)
135 {
136 nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
137 NS_ENSURE_TRUE(smsService, NS_ERROR_FAILURE);
139 nsDependentJSString number;
140 number.init(aCx, aNumber);
142 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
143 nsCOMPtr<nsIMobileMessageCallback> msgCallback =
144 new MobileMessageCallback(request);
146 // By default, we don't send silent messages via MobileMessageManager.
147 nsresult rv = smsService->Send(aServiceId, number, aMessage,
148 false, msgCallback);
149 NS_ENSURE_SUCCESS(rv, rv);
151 js::AssertSameCompartment(aCx, aGlobal);
152 JS::Rooted<JS::Value> rval(aCx);
153 rv = nsContentUtils::WrapNative(aCx,
154 static_cast<nsIDOMDOMRequest*>(request.get()),
155 &rval);
156 if (NS_FAILED(rv)) {
157 NS_ERROR("Failed to create the js value!");
158 return rv;
159 }
161 *aRequest = rval;
162 return NS_OK;
163 }
165 NS_IMETHODIMP
166 MobileMessageManager::Send(JS::Handle<JS::Value> aNumber,
167 const nsAString& aMessage,
168 JS::Handle<JS::Value> aSendParams,
169 JSContext* aCx,
170 uint8_t aArgc,
171 JS::MutableHandle<JS::Value> aReturn)
172 {
173 if (!aNumber.isString() && !JS_IsArrayObject(aCx, aNumber)) {
174 return NS_ERROR_INVALID_ARG;
175 }
177 nsresult rv;
178 nsIScriptContext* sc = GetContextForEventHandlers(&rv);
179 NS_ENSURE_SUCCESS(rv, rv);
180 NS_ENSURE_STATE(sc);
182 JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
184 mozilla::Maybe<JSAutoCompartment> ac;
185 if (!global) {
186 global = sc->GetWindowProxy();
187 ac.construct(aCx, global);
188 }
190 nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
191 NS_ENSURE_TRUE(smsService, NS_ERROR_FAILURE);
193 // Use the default one unless |aSendParams.serviceId| is available.
194 uint32_t serviceId;
195 rv = smsService->GetSmsDefaultServiceId(&serviceId);
196 NS_ENSURE_SUCCESS(rv, rv);
198 if (aArgc == 1) {
199 JS::Rooted<JS::Value> param(aCx, aSendParams);
200 RootedDictionary<SmsSendParameters> sendParams(aCx);
201 if (!sendParams.Init(aCx, param)) {
202 return NS_ERROR_TYPE_ERR;
203 }
204 if (sendParams.mServiceId.WasPassed()) {
205 serviceId = sendParams.mServiceId.Value();
206 }
207 }
209 if (aNumber.isString()) {
210 JS::Rooted<JSString*> str(aCx, aNumber.toString());
211 return Send(aCx, global, serviceId, str, aMessage, aReturn.address());
212 }
214 // Must be an array then.
215 JS::Rooted<JSObject*> numbers(aCx, &aNumber.toObject());
217 uint32_t size;
218 if (!JS_GetArrayLength(aCx, numbers, &size)) {
219 return NS_ERROR_FAILURE;
220 }
222 JS::AutoValueVector requests(aCx);
223 if (!requests.resize(size)) {
224 return NS_ERROR_FAILURE;
225 }
227 JS::Rooted<JS::Value> number(aCx);
228 JS::Rooted<JSString*> str(aCx);
229 for (uint32_t i = 0; i < size; ++i) {
230 if (!JS_GetElement(aCx, numbers, i, &number)) {
231 return NS_ERROR_INVALID_ARG;
232 }
234 str = JS::ToString(aCx, number);
235 if (!str) {
236 return NS_ERROR_FAILURE;
237 }
239 nsresult rv = Send(aCx, global, serviceId, str, aMessage, &requests[i]);
240 NS_ENSURE_SUCCESS(rv, rv);
241 }
243 JS::Rooted<JSObject*> obj(aCx);
244 obj = JS_NewArrayObject(aCx, requests);
245 if (!obj) {
246 return NS_ERROR_FAILURE;
247 }
249 aReturn.setObject(*obj);
250 return NS_OK;
251 }
253 NS_IMETHODIMP
254 MobileMessageManager::SendMMS(JS::Handle<JS::Value> aParams,
255 JS::Handle<JS::Value> aSendParams,
256 JSContext* aCx,
257 uint8_t aArgc,
258 nsIDOMDOMRequest** aRequest)
259 {
260 nsCOMPtr<nsIMmsService> mmsService = do_GetService(MMS_SERVICE_CONTRACTID);
261 NS_ENSURE_TRUE(mmsService, NS_ERROR_FAILURE);
263 // Use the default one unless |aSendParams.serviceId| is available.
264 uint32_t serviceId;
265 nsresult rv = mmsService->GetMmsDefaultServiceId(&serviceId);
266 NS_ENSURE_SUCCESS(rv, rv);
268 if (aArgc == 1) {
269 JS::Rooted<JS::Value> param(aCx, aSendParams);
270 RootedDictionary<MmsSendParameters> sendParams(aCx);
271 if (!sendParams.Init(aCx, param)) {
272 return NS_ERROR_TYPE_ERR;
273 }
274 if (sendParams.mServiceId.WasPassed()) {
275 serviceId = sendParams.mServiceId.Value();
276 }
277 }
279 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
280 nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
281 rv = mmsService->Send(serviceId, aParams, msgCallback);
282 NS_ENSURE_SUCCESS(rv, rv);
284 request.forget(aRequest);
285 return NS_OK;
286 }
288 NS_IMETHODIMP
289 MobileMessageManager::GetMessageMoz(int32_t aId, nsIDOMDOMRequest** aRequest)
290 {
291 nsCOMPtr<nsIMobileMessageDatabaseService> mobileMessageDBService =
292 do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
293 NS_ENSURE_TRUE(mobileMessageDBService, NS_ERROR_FAILURE);
295 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
296 nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
297 nsresult rv = mobileMessageDBService->GetMessageMoz(aId, msgCallback);
298 NS_ENSURE_SUCCESS(rv, rv);
300 request.forget(aRequest);
301 return NS_OK;
302 }
304 nsresult
305 MobileMessageManager::GetMessageId(JSContext* aCx,
306 const JS::Value& aMessage, int32_t* aId)
307 {
308 nsCOMPtr<nsIDOMMozSmsMessage> smsMessage =
309 do_QueryInterface(nsContentUtils::XPConnect()->GetNativeOfWrapper(aCx, &aMessage.toObject()));
310 if (smsMessage) {
311 return smsMessage->GetId(aId);
312 }
314 nsCOMPtr<nsIDOMMozMmsMessage> mmsMessage =
315 do_QueryInterface(nsContentUtils::XPConnect()->GetNativeOfWrapper(aCx, &aMessage.toObject()));
316 if (mmsMessage) {
317 return mmsMessage->GetId(aId);
318 }
320 return NS_ERROR_INVALID_ARG;
321 }
323 NS_IMETHODIMP
324 MobileMessageManager::Delete(JS::Handle<JS::Value> aParam, JSContext* aCx,
325 nsIDOMDOMRequest** aRequest)
326 {
327 // We expect Int32, SmsMessage, MmsMessage, Int32[], SmsMessage[], MmsMessage[]
328 if (!aParam.isObject() && !aParam.isInt32()) {
329 return NS_ERROR_INVALID_ARG;
330 }
332 nsresult rv = NS_OK;
333 int32_t id, *idArray;
334 uint32_t size;
336 if (aParam.isInt32()) {
337 // Single Integer Message ID
338 id = aParam.toInt32();
340 size = 1;
341 idArray = &id;
342 } else if (!JS_IsArrayObject(aCx, aParam)) {
343 // Single SmsMessage/MmsMessage object
344 rv = GetMessageId(aCx, aParam, &id);
345 NS_ENSURE_SUCCESS(rv, rv);
347 size = 1;
348 idArray = &id;
349 } else {
350 // Int32[], SmsMessage[], or MmsMessage[]
351 JS::Rooted<JSObject*> ids(aCx, &aParam.toObject());
353 MOZ_ALWAYS_TRUE(JS_GetArrayLength(aCx, ids, &size));
354 nsAutoArrayPtr<int32_t> idAutoArray(new int32_t[size]);
356 JS::Rooted<JS::Value> idJsValue(aCx);
357 for (uint32_t i = 0; i < size; i++) {
358 if (!JS_GetElement(aCx, ids, i, &idJsValue)) {
359 return NS_ERROR_INVALID_ARG;
360 }
362 if (idJsValue.isInt32()) {
363 idAutoArray[i] = idJsValue.toInt32();
364 } else if (idJsValue.isObject()) {
365 rv = GetMessageId(aCx, idJsValue, &id);
366 NS_ENSURE_SUCCESS(rv, rv);
368 idAutoArray[i] = id;
369 }
370 }
372 idArray = idAutoArray.forget();
373 }
375 nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
376 do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
377 NS_ENSURE_TRUE(dbService, NS_ERROR_FAILURE);
379 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
380 nsCOMPtr<nsIMobileMessageCallback> msgCallback =
381 new MobileMessageCallback(request);
383 rv = dbService->DeleteMessage(idArray, size, msgCallback);
384 NS_ENSURE_SUCCESS(rv, rv);
386 request.forget(aRequest);
387 return NS_OK;
388 }
390 NS_IMETHODIMP
391 MobileMessageManager::GetMessages(nsIDOMMozSmsFilter* aFilter,
392 bool aReverse,
393 nsIDOMDOMCursor** aCursor)
394 {
395 nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
396 do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
397 NS_ENSURE_TRUE(dbService, NS_ERROR_FAILURE);
399 nsCOMPtr<nsIDOMMozSmsFilter> filter = aFilter;
400 if (!filter) {
401 filter = new SmsFilter();
402 }
404 nsRefPtr<MobileMessageCursorCallback> cursorCallback =
405 new MobileMessageCursorCallback();
407 nsCOMPtr<nsICursorContinueCallback> continueCallback;
408 nsresult rv = dbService->CreateMessageCursor(filter, aReverse, cursorCallback,
409 getter_AddRefs(continueCallback));
410 NS_ENSURE_SUCCESS(rv, rv);
412 cursorCallback->mDOMCursor = new DOMCursor(GetOwner(), continueCallback);
413 NS_ADDREF(*aCursor = cursorCallback->mDOMCursor);
415 return NS_OK;
416 }
418 NS_IMETHODIMP
419 MobileMessageManager::MarkMessageRead(int32_t aId, bool aValue,
420 bool aSendReadReport,
421 nsIDOMDOMRequest** aRequest)
422 {
423 nsCOMPtr<nsIMobileMessageDatabaseService> mobileMessageDBService =
424 do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
425 NS_ENSURE_TRUE(mobileMessageDBService, NS_ERROR_FAILURE);
427 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
428 nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
429 nsresult rv = mobileMessageDBService->MarkMessageRead(aId, aValue,
430 aSendReadReport,
431 msgCallback);
432 NS_ENSURE_SUCCESS(rv, rv);
434 request.forget(aRequest);
435 return NS_OK;
436 }
438 NS_IMETHODIMP
439 MobileMessageManager::GetThreads(nsIDOMDOMCursor** aCursor)
440 {
441 nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
442 do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
443 NS_ENSURE_TRUE(dbService, NS_ERROR_FAILURE);
445 nsRefPtr<MobileMessageCursorCallback> cursorCallback =
446 new MobileMessageCursorCallback();
448 nsCOMPtr<nsICursorContinueCallback> continueCallback;
449 nsresult rv = dbService->CreateThreadCursor(cursorCallback,
450 getter_AddRefs(continueCallback));
451 NS_ENSURE_SUCCESS(rv, rv);
453 cursorCallback->mDOMCursor = new DOMCursor(GetOwner(), continueCallback);
454 NS_ADDREF(*aCursor = cursorCallback->mDOMCursor);
456 return NS_OK;
457 }
459 NS_IMETHODIMP
460 MobileMessageManager::RetrieveMMS(int32_t id,
461 nsIDOMDOMRequest** aRequest)
462 {
463 nsCOMPtr<nsIMmsService> mmsService = do_GetService(MMS_SERVICE_CONTRACTID);
464 NS_ENSURE_TRUE(mmsService, NS_ERROR_FAILURE);
466 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
467 nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
469 nsresult rv = mmsService->Retrieve(id, msgCallback);
470 NS_ENSURE_SUCCESS(rv, rv);
472 request.forget(aRequest);
473 return NS_OK;
474 }
476 nsresult
477 MobileMessageManager::DispatchTrustedSmsEventToSelf(const char* aTopic,
478 const nsAString& aEventName,
479 nsISupports* aMsg)
480 {
481 nsCOMPtr<nsIDOMEvent> event;
483 nsCOMPtr<nsIDOMMozSmsMessage> sms = do_QueryInterface(aMsg);
484 if (sms) {
485 NS_NewDOMMozSmsEvent(getter_AddRefs(event), this, nullptr, nullptr);
486 NS_ASSERTION(event, "This should never fail!");
488 nsCOMPtr<nsIDOMMozSmsEvent> se = do_QueryInterface(event);
489 nsresult rv = se->InitMozSmsEvent(aEventName, false, false, sms);
490 NS_ENSURE_SUCCESS(rv, rv);
491 return DispatchTrustedEvent(event);
492 }
494 nsCOMPtr<nsIDOMMozMmsMessage> mms = do_QueryInterface(aMsg);
495 if (mms) {
496 NS_NewDOMMozMmsEvent(getter_AddRefs(event), this, nullptr, nullptr);
497 NS_ASSERTION(event, "This should never fail!");
499 nsCOMPtr<nsIDOMMozMmsEvent> se = do_QueryInterface(event);
500 nsresult rv = se->InitMozMmsEvent(aEventName, false, false, mms);
501 NS_ENSURE_SUCCESS(rv, rv);
502 return DispatchTrustedEvent(event);
503 }
505 nsAutoCString errorMsg;
506 errorMsg.AssignLiteral("Got a '");
507 errorMsg.Append(aTopic);
508 errorMsg.AppendLiteral("' topic without a valid message!");
509 NS_ERROR(errorMsg.get());
510 return NS_OK;
511 }
513 NS_IMETHODIMP
514 MobileMessageManager::Observe(nsISupports* aSubject, const char* aTopic,
515 const char16_t* aData)
516 {
517 if (!strcmp(aTopic, kSmsReceivedObserverTopic)) {
518 return DispatchTrustedSmsEventToSelf(aTopic, RECEIVED_EVENT_NAME, aSubject);
519 }
521 if (!strcmp(aTopic, kSmsRetrievingObserverTopic)) {
522 return DispatchTrustedSmsEventToSelf(aTopic, RETRIEVING_EVENT_NAME, aSubject);
523 }
525 if (!strcmp(aTopic, kSmsSendingObserverTopic)) {
526 return DispatchTrustedSmsEventToSelf(aTopic, SENDING_EVENT_NAME, aSubject);
527 }
529 if (!strcmp(aTopic, kSmsSentObserverTopic)) {
530 return DispatchTrustedSmsEventToSelf(aTopic, SENT_EVENT_NAME, aSubject);
531 }
533 if (!strcmp(aTopic, kSmsFailedObserverTopic)) {
534 return DispatchTrustedSmsEventToSelf(aTopic, FAILED_EVENT_NAME, aSubject);
535 }
537 if (!strcmp(aTopic, kSmsDeliverySuccessObserverTopic)) {
538 return DispatchTrustedSmsEventToSelf(aTopic, DELIVERY_SUCCESS_EVENT_NAME, aSubject);
539 }
541 if (!strcmp(aTopic, kSmsDeliveryErrorObserverTopic)) {
542 return DispatchTrustedSmsEventToSelf(aTopic, DELIVERY_ERROR_EVENT_NAME, aSubject);
543 }
545 if (!strcmp(aTopic, kSmsReadSuccessObserverTopic)) {
546 return DispatchTrustedSmsEventToSelf(aTopic, READ_SUCCESS_EVENT_NAME, aSubject);
547 }
549 if (!strcmp(aTopic, kSmsReadErrorObserverTopic)) {
550 return DispatchTrustedSmsEventToSelf(aTopic, READ_ERROR_EVENT_NAME, aSubject);
551 }
553 return NS_OK;
554 }
556 NS_IMETHODIMP
557 MobileMessageManager::GetSmscAddress(uint32_t aServiceId, uint8_t aArgc,
558 nsIDOMDOMRequest** aRequest)
559 {
560 nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
561 NS_ENSURE_TRUE(smsService, NS_ERROR_FAILURE);
563 nsresult rv;
564 if (aArgc != 1) {
565 rv = smsService->GetSmsDefaultServiceId(&aServiceId);
566 NS_ENSURE_SUCCESS(rv, rv);
567 }
569 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
570 nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
571 rv = smsService->GetSmscAddress(aServiceId, msgCallback);
572 NS_ENSURE_SUCCESS(rv, rv);
574 request.forget(aRequest);
575 return NS_OK;
576 }
578 } // namespace dom
579 } // namespace mozilla
