The Tor Browser / file comparison

comparison: dom/mobilemessage/src/MobileMessageManager.cpp

dom/mobilemessage/src/MobileMessageManager.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:293bfb16b039
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 "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"
33
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")
43
44 using namespace mozilla::dom::mobilemessage;
45
46 DOMCI_DATA(MozMobileMessageManager, mozilla::dom::MobileMessageManager)
47
48 namespace mozilla {
49 namespace dom {
50
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)
56
57 NS_IMPL_ADDREF_INHERITED(MobileMessageManager, DOMEventTargetHelper)
58 NS_IMPL_RELEASE_INHERITED(MobileMessageManager, DOMEventTargetHelper)
59
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)
69
70 void
71 MobileMessageManager::Init(nsPIDOMWindow *aWindow)
72 {
73 BindToOwner(aWindow);
74
75 nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
76 // GetObserverService() can return null is some situations like shutdown.
77 if (!obs) {
78 return;
79 }
80
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 }
91
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 }
100
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 }
111
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);
118
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);
124
125 request.forget(aRequest);
126 return NS_OK;
127 }
128
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);
138
139 nsDependentJSString number;
140 number.init(aCx, aNumber);
141
142 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
143 nsCOMPtr<nsIMobileMessageCallback> msgCallback =
144 new MobileMessageCallback(request);
145
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);
150
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 }
160
161 *aRequest = rval;
162 return NS_OK;
163 }
164
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 }
176
177 nsresult rv;
178 nsIScriptContext* sc = GetContextForEventHandlers(&rv);
179 NS_ENSURE_SUCCESS(rv, rv);
180 NS_ENSURE_STATE(sc);
181
182 JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
183
184 mozilla::Maybe<JSAutoCompartment> ac;
185 if (!global) {
186 global = sc->GetWindowProxy();
187 ac.construct(aCx, global);
188 }
189
190 nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
191 NS_ENSURE_TRUE(smsService, NS_ERROR_FAILURE);
192
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);
197
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 }
208
209 if (aNumber.isString()) {
210 JS::Rooted<JSString*> str(aCx, aNumber.toString());
211 return Send(aCx, global, serviceId, str, aMessage, aReturn.address());
212 }
213
214 // Must be an array then.
215 JS::Rooted<JSObject*> numbers(aCx, &aNumber.toObject());
216
217 uint32_t size;
218 if (!JS_GetArrayLength(aCx, numbers, &size)) {
219 return NS_ERROR_FAILURE;
220 }
221
222 JS::AutoValueVector requests(aCx);
223 if (!requests.resize(size)) {
224 return NS_ERROR_FAILURE;
225 }
226
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 }
233
234 str = JS::ToString(aCx, number);
235 if (!str) {
236 return NS_ERROR_FAILURE;
237 }
238
239 nsresult rv = Send(aCx, global, serviceId, str, aMessage, &requests[i]);
240 NS_ENSURE_SUCCESS(rv, rv);
241 }
242
243 JS::Rooted<JSObject*> obj(aCx);
244 obj = JS_NewArrayObject(aCx, requests);
245 if (!obj) {
246 return NS_ERROR_FAILURE;
247 }
248
249 aReturn.setObject(*obj);
250 return NS_OK;
251 }
252
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);
262
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);
267
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 }
278
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);
283
284 request.forget(aRequest);
285 return NS_OK;
286 }
287
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);
294
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);
299
300 request.forget(aRequest);
301 return NS_OK;
302 }
303
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 }
313
314 nsCOMPtr<nsIDOMMozMmsMessage> mmsMessage =
315 do_QueryInterface(nsContentUtils::XPConnect()->GetNativeOfWrapper(aCx, &aMessage.toObject()));
316 if (mmsMessage) {
317 return mmsMessage->GetId(aId);
318 }
319
320 return NS_ERROR_INVALID_ARG;
321 }
322
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 }
331
332 nsresult rv = NS_OK;
333 int32_t id, *idArray;
334 uint32_t size;
335
336 if (aParam.isInt32()) {
337 // Single Integer Message ID
338 id = aParam.toInt32();
339
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);
346
347 size = 1;
348 idArray = &id;
349 } else {
350 // Int32[], SmsMessage[], or MmsMessage[]
351 JS::Rooted<JSObject*> ids(aCx, &aParam.toObject());
352
353 MOZ_ALWAYS_TRUE(JS_GetArrayLength(aCx, ids, &size));
354 nsAutoArrayPtr<int32_t> idAutoArray(new int32_t[size]);
355
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 }
361
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);
367
368 idAutoArray[i] = id;
369 }
370 }
371
372 idArray = idAutoArray.forget();
373 }
374
375 nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
376 do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
377 NS_ENSURE_TRUE(dbService, NS_ERROR_FAILURE);
378
379 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
380 nsCOMPtr<nsIMobileMessageCallback> msgCallback =
381 new MobileMessageCallback(request);
382
383 rv = dbService->DeleteMessage(idArray, size, msgCallback);
384 NS_ENSURE_SUCCESS(rv, rv);
385
386 request.forget(aRequest);
387 return NS_OK;
388 }
389
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);
398
399 nsCOMPtr<nsIDOMMozSmsFilter> filter = aFilter;
400 if (!filter) {
401 filter = new SmsFilter();
402 }
403
404 nsRefPtr<MobileMessageCursorCallback> cursorCallback =
405 new MobileMessageCursorCallback();
406
407 nsCOMPtr<nsICursorContinueCallback> continueCallback;
408 nsresult rv = dbService->CreateMessageCursor(filter, aReverse, cursorCallback,
409 getter_AddRefs(continueCallback));
410 NS_ENSURE_SUCCESS(rv, rv);
411
412 cursorCallback->mDOMCursor = new DOMCursor(GetOwner(), continueCallback);
413 NS_ADDREF(*aCursor = cursorCallback->mDOMCursor);
414
415 return NS_OK;
416 }
417
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);
426
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);
433
434 request.forget(aRequest);
435 return NS_OK;
436 }
437
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);
444
445 nsRefPtr<MobileMessageCursorCallback> cursorCallback =
446 new MobileMessageCursorCallback();
447
448 nsCOMPtr<nsICursorContinueCallback> continueCallback;
449 nsresult rv = dbService->CreateThreadCursor(cursorCallback,
450 getter_AddRefs(continueCallback));
451 NS_ENSURE_SUCCESS(rv, rv);
452
453 cursorCallback->mDOMCursor = new DOMCursor(GetOwner(), continueCallback);
454 NS_ADDREF(*aCursor = cursorCallback->mDOMCursor);
455
456 return NS_OK;
457 }
458
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);
465
466 nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
467 nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
468
469 nsresult rv = mmsService->Retrieve(id, msgCallback);
470 NS_ENSURE_SUCCESS(rv, rv);
471
472 request.forget(aRequest);
473 return NS_OK;
474 }
475
476 nsresult
477 MobileMessageManager::DispatchTrustedSmsEventToSelf(const char* aTopic,
478 const nsAString& aEventName,
479 nsISupports* aMsg)
480 {
481 nsCOMPtr<nsIDOMEvent> event;
482
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!");
487
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 }
493
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!");
498
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 }
504
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 }
512
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 }
520
521 if (!strcmp(aTopic, kSmsRetrievingObserverTopic)) {
522 return DispatchTrustedSmsEventToSelf(aTopic, RETRIEVING_EVENT_NAME, aSubject);
523 }
524
525 if (!strcmp(aTopic, kSmsSendingObserverTopic)) {
526 return DispatchTrustedSmsEventToSelf(aTopic, SENDING_EVENT_NAME, aSubject);
527 }
528
529 if (!strcmp(aTopic, kSmsSentObserverTopic)) {
530 return DispatchTrustedSmsEventToSelf(aTopic, SENT_EVENT_NAME, aSubject);
531 }
532
533 if (!strcmp(aTopic, kSmsFailedObserverTopic)) {
534 return DispatchTrustedSmsEventToSelf(aTopic, FAILED_EVENT_NAME, aSubject);
535 }
536
537 if (!strcmp(aTopic, kSmsDeliverySuccessObserverTopic)) {
538 return DispatchTrustedSmsEventToSelf(aTopic, DELIVERY_SUCCESS_EVENT_NAME, aSubject);
539 }
540
541 if (!strcmp(aTopic, kSmsDeliveryErrorObserverTopic)) {
542 return DispatchTrustedSmsEventToSelf(aTopic, DELIVERY_ERROR_EVENT_NAME, aSubject);
543 }
544
545 if (!strcmp(aTopic, kSmsReadSuccessObserverTopic)) {
546 return DispatchTrustedSmsEventToSelf(aTopic, READ_SUCCESS_EVENT_NAME, aSubject);
547 }
548
549 if (!strcmp(aTopic, kSmsReadErrorObserverTopic)) {
550 return DispatchTrustedSmsEventToSelf(aTopic, READ_ERROR_EVENT_NAME, aSubject);
551 }
552
553 return NS_OK;
554 }
555
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);
562
563 nsresult rv;
564 if (aArgc != 1) {
565 rv = smsService->GetSmsDefaultServiceId(&aServiceId);
566 NS_ENSURE_SUCCESS(rv, rv);
567 }
568
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);
573
574 request.forget(aRequest);
575 return NS_OK;
576 }
577
578 } // namespace dom
579 } // namespace mozilla

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial