2013-03-08 23:21:47 -08:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
|
|
|
#include "SmsFilter.h"
|
|
|
|
#include "MobileMessageManager.h"
|
|
|
|
#include "nsIDOMClassInfo.h"
|
|
|
|
#include "nsISmsService.h"
|
2013-03-08 23:22:32 -08:00
|
|
|
#include "nsIMmsService.h"
|
2013-03-08 23:21:47 -08:00
|
|
|
#include "nsIObserverService.h"
|
|
|
|
#include "mozilla/Preferences.h"
|
|
|
|
#include "mozilla/Services.h"
|
2013-09-11 20:17:24 -07:00
|
|
|
#include "mozilla/dom/mobilemessage/Constants.h" // For MessageType
|
2013-11-02 03:17:16 -07:00
|
|
|
#include "mozilla/dom/MobileMessageManagerBinding.h"
|
2014-06-10 18:23:34 -07:00
|
|
|
#include "mozilla/dom/MozMmsEvent.h"
|
2013-11-02 03:17:16 -07:00
|
|
|
#include "mozilla/dom/MozMmsMessageBinding.h"
|
2014-06-10 18:23:34 -07:00
|
|
|
#include "mozilla/dom/MozSmsEvent.h"
|
2013-03-08 23:21:47 -08:00
|
|
|
#include "nsIDOMMozSmsMessage.h"
|
2013-03-08 23:22:42 -08:00
|
|
|
#include "nsIDOMMozMmsMessage.h"
|
2013-03-08 23:21:47 -08:00
|
|
|
#include "nsJSUtils.h"
|
|
|
|
#include "nsContentUtils.h"
|
2013-05-22 09:05:26 -07:00
|
|
|
#include "nsCxPusher.h"
|
2013-03-08 23:21:47 -08:00
|
|
|
#include "nsIMobileMessageDatabaseService.h"
|
|
|
|
#include "nsIXPConnect.h"
|
|
|
|
#include "nsIPermissionManager.h"
|
|
|
|
#include "GeneratedEvents.h"
|
2013-03-08 23:22:32 -08:00
|
|
|
#include "DOMRequest.h"
|
|
|
|
#include "nsIMobileMessageCallback.h"
|
|
|
|
#include "MobileMessageCallback.h"
|
2013-04-09 09:35:59 -07:00
|
|
|
#include "MobileMessageCursorCallback.h"
|
|
|
|
#include "DOMCursor.h"
|
2013-03-08 23:21:47 -08:00
|
|
|
|
|
|
|
#define RECEIVED_EVENT_NAME NS_LITERAL_STRING("received")
|
2013-05-10 13:39:22 -07:00
|
|
|
#define RETRIEVING_EVENT_NAME NS_LITERAL_STRING("retrieving")
|
2013-03-08 23:21:47 -08:00
|
|
|
#define SENDING_EVENT_NAME NS_LITERAL_STRING("sending")
|
|
|
|
#define SENT_EVENT_NAME NS_LITERAL_STRING("sent")
|
|
|
|
#define FAILED_EVENT_NAME NS_LITERAL_STRING("failed")
|
|
|
|
#define DELIVERY_SUCCESS_EVENT_NAME NS_LITERAL_STRING("deliverysuccess")
|
|
|
|
#define DELIVERY_ERROR_EVENT_NAME NS_LITERAL_STRING("deliveryerror")
|
2013-11-25 02:54:59 -08:00
|
|
|
#define READ_SUCCESS_EVENT_NAME NS_LITERAL_STRING("readsuccess")
|
|
|
|
#define READ_ERROR_EVENT_NAME NS_LITERAL_STRING("readerror")
|
2013-03-08 23:21:47 -08:00
|
|
|
|
|
|
|
using namespace mozilla::dom::mobilemessage;
|
|
|
|
|
|
|
|
DOMCI_DATA(MozMobileMessageManager, mozilla::dom::MobileMessageManager)
|
|
|
|
|
|
|
|
namespace mozilla {
|
|
|
|
namespace dom {
|
|
|
|
|
|
|
|
NS_INTERFACE_MAP_BEGIN(MobileMessageManager)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMMozMobileMessageManager)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIObserver)
|
|
|
|
NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(MozMobileMessageManager)
|
2014-03-31 23:13:50 -07:00
|
|
|
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2014-03-31 23:13:50 -07:00
|
|
|
NS_IMPL_ADDREF_INHERITED(MobileMessageManager, DOMEventTargetHelper)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(MobileMessageManager, DOMEventTargetHelper)
|
2013-03-08 23:21:47 -08:00
|
|
|
|
|
|
|
NS_IMPL_EVENT_HANDLER(MobileMessageManager, received)
|
2013-05-10 13:39:22 -07:00
|
|
|
NS_IMPL_EVENT_HANDLER(MobileMessageManager, retrieving)
|
2013-03-08 23:21:47 -08:00
|
|
|
NS_IMPL_EVENT_HANDLER(MobileMessageManager, sending)
|
|
|
|
NS_IMPL_EVENT_HANDLER(MobileMessageManager, sent)
|
|
|
|
NS_IMPL_EVENT_HANDLER(MobileMessageManager, failed)
|
|
|
|
NS_IMPL_EVENT_HANDLER(MobileMessageManager, deliverysuccess)
|
|
|
|
NS_IMPL_EVENT_HANDLER(MobileMessageManager, deliveryerror)
|
2013-11-25 02:54:59 -08:00
|
|
|
NS_IMPL_EVENT_HANDLER(MobileMessageManager, readsuccess)
|
|
|
|
NS_IMPL_EVENT_HANDLER(MobileMessageManager, readerror)
|
2013-03-08 23:21:47 -08:00
|
|
|
|
|
|
|
void
|
|
|
|
MobileMessageManager::Init(nsPIDOMWindow *aWindow)
|
|
|
|
{
|
|
|
|
BindToOwner(aWindow);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
|
|
|
|
// GetObserverService() can return null is some situations like shutdown.
|
|
|
|
if (!obs) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
obs->AddObserver(this, kSmsReceivedObserverTopic, false);
|
2013-05-10 13:39:22 -07:00
|
|
|
obs->AddObserver(this, kSmsRetrievingObserverTopic, false);
|
2013-03-08 23:21:47 -08:00
|
|
|
obs->AddObserver(this, kSmsSendingObserverTopic, false);
|
|
|
|
obs->AddObserver(this, kSmsSentObserverTopic, false);
|
|
|
|
obs->AddObserver(this, kSmsFailedObserverTopic, false);
|
|
|
|
obs->AddObserver(this, kSmsDeliverySuccessObserverTopic, false);
|
|
|
|
obs->AddObserver(this, kSmsDeliveryErrorObserverTopic, false);
|
2013-11-25 02:54:59 -08:00
|
|
|
obs->AddObserver(this, kSmsReadSuccessObserverTopic, false);
|
|
|
|
obs->AddObserver(this, kSmsReadErrorObserverTopic, false);
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MobileMessageManager::Shutdown()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
|
|
|
|
// GetObserverService() can return null is some situations like shutdown.
|
|
|
|
if (!obs) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
obs->RemoveObserver(this, kSmsReceivedObserverTopic);
|
2013-05-10 13:39:22 -07:00
|
|
|
obs->RemoveObserver(this, kSmsRetrievingObserverTopic);
|
2013-03-08 23:21:47 -08:00
|
|
|
obs->RemoveObserver(this, kSmsSendingObserverTopic);
|
|
|
|
obs->RemoveObserver(this, kSmsSentObserverTopic);
|
|
|
|
obs->RemoveObserver(this, kSmsFailedObserverTopic);
|
|
|
|
obs->RemoveObserver(this, kSmsDeliverySuccessObserverTopic);
|
|
|
|
obs->RemoveObserver(this, kSmsDeliveryErrorObserverTopic);
|
2013-11-25 02:54:59 -08:00
|
|
|
obs->RemoveObserver(this, kSmsReadSuccessObserverTopic);
|
|
|
|
obs->RemoveObserver(this, kSmsReadErrorObserverTopic);
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
MobileMessageManager::GetSegmentInfoForText(const nsAString& aText,
|
2013-08-09 06:25:53 -07:00
|
|
|
nsIDOMDOMRequest** aRequest)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
|
|
|
|
NS_ENSURE_TRUE(smsService, NS_ERROR_FAILURE);
|
|
|
|
|
2013-08-09 06:25:53 -07:00
|
|
|
nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
|
|
|
|
nsCOMPtr<nsIMobileMessageCallback> msgCallback =
|
|
|
|
new MobileMessageCallback(request);
|
|
|
|
nsresult rv = smsService->GetSegmentInfoForText(aText, msgCallback);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
request.forget(aRequest);
|
|
|
|
return NS_OK;
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
2013-05-11 22:17:42 -07:00
|
|
|
MobileMessageManager::Send(JSContext* aCx, JS::Handle<JSObject*> aGlobal,
|
2013-11-02 03:17:16 -07:00
|
|
|
uint32_t aServiceId,
|
2013-05-11 22:17:42 -07:00
|
|
|
JS::Handle<JSString*> aNumber,
|
2013-11-02 03:17:16 -07:00
|
|
|
const nsAString& aMessage,
|
2014-04-28 07:53:00 -07:00
|
|
|
JS::MutableHandle<JS::Value> aRequest)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
|
2013-04-09 09:41:27 -07:00
|
|
|
NS_ENSURE_TRUE(smsService, NS_ERROR_FAILURE);
|
2013-03-08 23:21:47 -08:00
|
|
|
|
|
|
|
nsDependentJSString number;
|
|
|
|
number.init(aCx, aNumber);
|
|
|
|
|
2013-04-09 09:41:27 -07:00
|
|
|
nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
|
|
|
|
nsCOMPtr<nsIMobileMessageCallback> msgCallback =
|
|
|
|
new MobileMessageCallback(request);
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2013-07-29 15:50:21 -07:00
|
|
|
// By default, we don't send silent messages via MobileMessageManager.
|
2013-11-02 03:17:16 -07:00
|
|
|
nsresult rv = smsService->Send(aServiceId, number, aMessage,
|
|
|
|
false, msgCallback);
|
2013-04-09 09:41:27 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2014-04-09 21:58:41 -07:00
|
|
|
js::AssertSameCompartment(aCx, aGlobal);
|
|
|
|
rv = nsContentUtils::WrapNative(aCx,
|
2013-04-09 09:41:27 -07:00
|
|
|
static_cast<nsIDOMDOMRequest*>(request.get()),
|
2014-04-28 07:53:00 -07:00
|
|
|
aRequest);
|
2013-03-08 23:21:47 -08:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
NS_ERROR("Failed to create the js value!");
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2014-01-09 09:39:36 -08:00
|
|
|
MobileMessageManager::Send(JS::Handle<JS::Value> aNumber,
|
2013-11-02 03:16:59 -07:00
|
|
|
const nsAString& aMessage,
|
2014-01-09 09:39:36 -08:00
|
|
|
JS::Handle<JS::Value> aSendParams,
|
2013-11-02 03:16:59 -07:00
|
|
|
JSContext* aCx,
|
|
|
|
uint8_t aArgc,
|
2014-01-09 09:39:36 -08:00
|
|
|
JS::MutableHandle<JS::Value> aReturn)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
2014-01-29 02:00:40 -08:00
|
|
|
if (!aNumber.isString() && !JS_IsArrayObject(aCx, aNumber)) {
|
2013-03-08 23:21:47 -08:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2013-11-02 03:16:59 -07:00
|
|
|
nsresult rv;
|
|
|
|
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ENSURE_STATE(sc);
|
|
|
|
|
2013-12-05 13:28:13 -08:00
|
|
|
JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2013-12-05 13:28:13 -08:00
|
|
|
mozilla::Maybe<JSAutoCompartment> ac;
|
|
|
|
if (!global) {
|
|
|
|
global = sc->GetWindowProxy();
|
|
|
|
ac.construct(aCx, global);
|
|
|
|
}
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2013-11-02 03:17:16 -07:00
|
|
|
nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
|
|
|
|
NS_ENSURE_TRUE(smsService, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// Use the default one unless |aSendParams.serviceId| is available.
|
|
|
|
uint32_t serviceId;
|
|
|
|
rv = smsService->GetSmsDefaultServiceId(&serviceId);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2014-03-14 00:28:32 -07:00
|
|
|
if (aArgc == 1) {
|
2013-11-02 03:17:16 -07:00
|
|
|
JS::Rooted<JS::Value> param(aCx, aSendParams);
|
|
|
|
RootedDictionary<SmsSendParameters> sendParams(aCx);
|
|
|
|
if (!sendParams.Init(aCx, param)) {
|
|
|
|
return NS_ERROR_TYPE_ERR;
|
|
|
|
}
|
|
|
|
if (sendParams.mServiceId.WasPassed()) {
|
|
|
|
serviceId = sendParams.mServiceId.Value();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-08 23:21:47 -08:00
|
|
|
if (aNumber.isString()) {
|
2013-11-02 03:16:59 -07:00
|
|
|
JS::Rooted<JSString*> str(aCx, aNumber.toString());
|
2014-04-28 07:53:00 -07:00
|
|
|
return Send(aCx, global, serviceId, str, aMessage, aReturn);
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Must be an array then.
|
2013-11-02 03:16:59 -07:00
|
|
|
JS::Rooted<JSObject*> numbers(aCx, &aNumber.toObject());
|
2013-03-08 23:21:47 -08:00
|
|
|
|
|
|
|
uint32_t size;
|
2013-11-05 16:09:33 -08:00
|
|
|
if (!JS_GetArrayLength(aCx, numbers, &size)) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2013-11-05 16:09:33 -08:00
|
|
|
JS::AutoValueVector requests(aCx);
|
|
|
|
if (!requests.resize(size)) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2013-11-02 03:16:59 -07:00
|
|
|
JS::Rooted<JS::Value> number(aCx);
|
2013-11-05 16:09:33 -08:00
|
|
|
JS::Rooted<JSString*> str(aCx);
|
2013-11-02 03:17:16 -07:00
|
|
|
for (uint32_t i = 0; i < size; ++i) {
|
2013-11-02 03:16:59 -07:00
|
|
|
if (!JS_GetElement(aCx, numbers, i, &number)) {
|
2013-03-08 23:21:47 -08:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2013-11-05 16:09:33 -08:00
|
|
|
str = JS::ToString(aCx, number);
|
|
|
|
if (!str) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2014-04-28 07:53:00 -07:00
|
|
|
nsresult rv = Send(aCx, global, serviceId, str, aMessage, requests[i]);
|
2013-03-08 23:21:47 -08:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
|
|
|
|
2013-11-05 16:09:33 -08:00
|
|
|
JS::Rooted<JSObject*> obj(aCx);
|
2014-02-12 02:50:46 -08:00
|
|
|
obj = JS_NewArrayObject(aCx, requests);
|
2013-11-05 16:09:33 -08:00
|
|
|
if (!obj) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2014-01-09 09:39:36 -08:00
|
|
|
aReturn.setObject(*obj);
|
2013-03-08 23:21:47 -08:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-03-08 23:22:32 -08:00
|
|
|
NS_IMETHODIMP
|
2014-01-09 09:39:36 -08:00
|
|
|
MobileMessageManager::SendMMS(JS::Handle<JS::Value> aParams,
|
|
|
|
JS::Handle<JS::Value> aSendParams,
|
2013-11-02 03:16:59 -07:00
|
|
|
JSContext* aCx,
|
|
|
|
uint8_t aArgc,
|
|
|
|
nsIDOMDOMRequest** aRequest)
|
2013-03-08 23:22:32 -08:00
|
|
|
{
|
2013-04-10 05:18:32 -07:00
|
|
|
nsCOMPtr<nsIMmsService> mmsService = do_GetService(MMS_SERVICE_CONTRACTID);
|
2013-03-08 23:22:32 -08:00
|
|
|
NS_ENSURE_TRUE(mmsService, NS_ERROR_FAILURE);
|
|
|
|
|
2013-11-02 03:17:16 -07:00
|
|
|
// Use the default one unless |aSendParams.serviceId| is available.
|
|
|
|
uint32_t serviceId;
|
|
|
|
nsresult rv = mmsService->GetMmsDefaultServiceId(&serviceId);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2014-03-14 00:28:32 -07:00
|
|
|
if (aArgc == 1) {
|
2013-11-02 03:17:16 -07:00
|
|
|
JS::Rooted<JS::Value> param(aCx, aSendParams);
|
|
|
|
RootedDictionary<MmsSendParameters> sendParams(aCx);
|
|
|
|
if (!sendParams.Init(aCx, param)) {
|
|
|
|
return NS_ERROR_TYPE_ERR;
|
|
|
|
}
|
|
|
|
if (sendParams.mServiceId.WasPassed()) {
|
|
|
|
serviceId = sendParams.mServiceId.Value();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-08 23:22:32 -08:00
|
|
|
nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
|
|
|
|
nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
|
2013-11-02 03:17:16 -07:00
|
|
|
rv = mmsService->Send(serviceId, aParams, msgCallback);
|
2013-03-08 23:22:32 -08:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
request.forget(aRequest);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-03-08 23:21:47 -08:00
|
|
|
NS_IMETHODIMP
|
2013-03-07 19:46:16 -08:00
|
|
|
MobileMessageManager::GetMessageMoz(int32_t aId, nsIDOMDOMRequest** aRequest)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIMobileMessageDatabaseService> mobileMessageDBService =
|
|
|
|
do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
|
|
|
|
NS_ENSURE_TRUE(mobileMessageDBService, NS_ERROR_FAILURE);
|
2013-03-07 19:46:16 -08:00
|
|
|
|
|
|
|
nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
|
|
|
|
nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
|
|
|
|
nsresult rv = mobileMessageDBService->GetMessageMoz(aId, msgCallback);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
request.forget(aRequest);
|
2013-03-08 23:21:47 -08:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
2013-12-05 13:28:41 -08:00
|
|
|
MobileMessageManager::GetMessageId(JSContext* aCx,
|
|
|
|
const JS::Value& aMessage, int32_t* aId)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
2013-05-10 01:45:05 -07:00
|
|
|
nsCOMPtr<nsIDOMMozSmsMessage> smsMessage =
|
|
|
|
do_QueryInterface(nsContentUtils::XPConnect()->GetNativeOfWrapper(aCx, &aMessage.toObject()));
|
|
|
|
if (smsMessage) {
|
2013-12-05 13:28:41 -08:00
|
|
|
return smsMessage->GetId(aId);
|
2013-05-10 01:45:05 -07:00
|
|
|
}
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2013-05-10 01:45:05 -07:00
|
|
|
nsCOMPtr<nsIDOMMozMmsMessage> mmsMessage =
|
|
|
|
do_QueryInterface(nsContentUtils::XPConnect()->GetNativeOfWrapper(aCx, &aMessage.toObject()));
|
|
|
|
if (mmsMessage) {
|
2013-12-05 13:28:41 -08:00
|
|
|
return mmsMessage->GetId(aId);
|
2013-05-10 01:45:05 -07:00
|
|
|
}
|
2013-03-07 20:06:06 -08:00
|
|
|
|
2013-05-10 01:45:05 -07:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2014-01-09 09:39:36 -08:00
|
|
|
MobileMessageManager::Delete(JS::Handle<JS::Value> aParam, JSContext* aCx,
|
2013-12-05 13:28:41 -08:00
|
|
|
nsIDOMDOMRequest** aRequest)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
2013-05-10 01:45:05 -07:00
|
|
|
// We expect Int32, SmsMessage, MmsMessage, Int32[], SmsMessage[], MmsMessage[]
|
|
|
|
if (!aParam.isObject() && !aParam.isInt32()) {
|
2013-03-08 23:21:47 -08:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2013-12-05 13:28:41 -08:00
|
|
|
nsresult rv = NS_OK;
|
2013-05-10 01:45:05 -07:00
|
|
|
int32_t id, *idArray;
|
|
|
|
uint32_t size;
|
|
|
|
|
|
|
|
if (aParam.isInt32()) {
|
|
|
|
// Single Integer Message ID
|
|
|
|
id = aParam.toInt32();
|
|
|
|
|
|
|
|
size = 1;
|
|
|
|
idArray = &id;
|
2014-01-29 02:00:40 -08:00
|
|
|
} else if (!JS_IsArrayObject(aCx, aParam)) {
|
2013-05-10 01:45:05 -07:00
|
|
|
// Single SmsMessage/MmsMessage object
|
2013-12-05 13:28:41 -08:00
|
|
|
rv = GetMessageId(aCx, aParam, &id);
|
2013-05-10 01:45:05 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
size = 1;
|
|
|
|
idArray = &id;
|
2013-03-07 20:06:06 -08:00
|
|
|
} else {
|
2013-05-10 01:45:05 -07:00
|
|
|
// Int32[], SmsMessage[], or MmsMessage[]
|
2013-12-05 13:28:41 -08:00
|
|
|
JS::Rooted<JSObject*> ids(aCx, &aParam.toObject());
|
2013-05-10 01:45:05 -07:00
|
|
|
|
2014-02-17 22:42:57 -08:00
|
|
|
MOZ_ALWAYS_TRUE(JS_GetArrayLength(aCx, ids, &size));
|
2013-05-10 01:45:05 -07:00
|
|
|
nsAutoArrayPtr<int32_t> idAutoArray(new int32_t[size]);
|
|
|
|
|
2013-12-05 13:28:41 -08:00
|
|
|
JS::Rooted<JS::Value> idJsValue(aCx);
|
2013-05-10 01:45:05 -07:00
|
|
|
for (uint32_t i = 0; i < size; i++) {
|
2013-12-05 13:28:41 -08:00
|
|
|
if (!JS_GetElement(aCx, ids, i, &idJsValue)) {
|
2013-05-10 01:45:05 -07:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (idJsValue.isInt32()) {
|
|
|
|
idAutoArray[i] = idJsValue.toInt32();
|
|
|
|
} else if (idJsValue.isObject()) {
|
2013-12-05 13:28:41 -08:00
|
|
|
rv = GetMessageId(aCx, idJsValue, &id);
|
2013-05-10 01:45:05 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
idAutoArray[i] = id;
|
|
|
|
}
|
2013-03-07 20:06:06 -08:00
|
|
|
}
|
2013-05-10 01:45:05 -07:00
|
|
|
|
|
|
|
idArray = idAutoArray.forget();
|
2013-03-07 20:06:06 -08:00
|
|
|
}
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2013-05-10 01:45:05 -07:00
|
|
|
nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
|
|
|
|
do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
|
|
|
|
NS_ENSURE_TRUE(dbService, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
|
|
|
|
nsCOMPtr<nsIMobileMessageCallback> msgCallback =
|
|
|
|
new MobileMessageCallback(request);
|
|
|
|
|
|
|
|
rv = dbService->DeleteMessage(idArray, size, msgCallback);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
request.forget(aRequest);
|
|
|
|
return NS_OK;
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2013-04-09 09:35:59 -07:00
|
|
|
MobileMessageManager::GetMessages(nsIDOMMozSmsFilter* aFilter,
|
|
|
|
bool aReverse,
|
|
|
|
nsIDOMDOMCursor** aCursor)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
2013-04-09 09:35:59 -07:00
|
|
|
nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
|
|
|
|
do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
|
|
|
|
NS_ENSURE_TRUE(dbService, NS_ERROR_FAILURE);
|
|
|
|
|
2013-03-08 23:21:47 -08:00
|
|
|
nsCOMPtr<nsIDOMMozSmsFilter> filter = aFilter;
|
|
|
|
if (!filter) {
|
|
|
|
filter = new SmsFilter();
|
|
|
|
}
|
|
|
|
|
2013-04-09 09:35:59 -07:00
|
|
|
nsRefPtr<MobileMessageCursorCallback> cursorCallback =
|
|
|
|
new MobileMessageCursorCallback();
|
|
|
|
|
|
|
|
nsCOMPtr<nsICursorContinueCallback> continueCallback;
|
|
|
|
nsresult rv = dbService->CreateMessageCursor(filter, aReverse, cursorCallback,
|
|
|
|
getter_AddRefs(continueCallback));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
cursorCallback->mDOMCursor = new DOMCursor(GetOwner(), continueCallback);
|
|
|
|
NS_ADDREF(*aCursor = cursorCallback->mDOMCursor);
|
|
|
|
|
2013-03-08 23:21:47 -08:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
MobileMessageManager::MarkMessageRead(int32_t aId, bool aValue,
|
2013-11-03 19:36:00 -08:00
|
|
|
bool aSendReadReport,
|
2013-03-10 21:14:15 -07:00
|
|
|
nsIDOMDOMRequest** aRequest)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIMobileMessageDatabaseService> mobileMessageDBService =
|
|
|
|
do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
|
|
|
|
NS_ENSURE_TRUE(mobileMessageDBService, NS_ERROR_FAILURE);
|
2013-03-10 21:14:15 -07:00
|
|
|
|
|
|
|
nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
|
|
|
|
nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
|
2013-11-03 19:36:00 -08:00
|
|
|
nsresult rv = mobileMessageDBService->MarkMessageRead(aId, aValue,
|
|
|
|
aSendReadReport,
|
|
|
|
msgCallback);
|
2013-03-10 21:14:15 -07:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
request.forget(aRequest);
|
2013-03-08 23:21:47 -08:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2013-04-09 09:37:54 -07:00
|
|
|
MobileMessageManager::GetThreads(nsIDOMDOMCursor** aCursor)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
2013-04-09 09:37:54 -07:00
|
|
|
nsCOMPtr<nsIMobileMessageDatabaseService> dbService =
|
2013-03-08 23:21:47 -08:00
|
|
|
do_GetService(MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID);
|
2013-04-09 09:37:54 -07:00
|
|
|
NS_ENSURE_TRUE(dbService, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsRefPtr<MobileMessageCursorCallback> cursorCallback =
|
|
|
|
new MobileMessageCursorCallback();
|
|
|
|
|
|
|
|
nsCOMPtr<nsICursorContinueCallback> continueCallback;
|
|
|
|
nsresult rv = dbService->CreateThreadCursor(cursorCallback,
|
|
|
|
getter_AddRefs(continueCallback));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
cursorCallback->mDOMCursor = new DOMCursor(GetOwner(), continueCallback);
|
|
|
|
NS_ADDREF(*aCursor = cursorCallback->mDOMCursor);
|
|
|
|
|
2013-03-08 23:21:47 -08:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-03-21 02:57:41 -07:00
|
|
|
NS_IMETHODIMP
|
|
|
|
MobileMessageManager::RetrieveMMS(int32_t id,
|
|
|
|
nsIDOMDOMRequest** aRequest)
|
|
|
|
{
|
2013-04-10 05:18:43 -07:00
|
|
|
nsCOMPtr<nsIMmsService> mmsService = do_GetService(MMS_SERVICE_CONTRACTID);
|
2013-03-21 02:57:41 -07:00
|
|
|
NS_ENSURE_TRUE(mmsService, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
|
|
|
|
nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
|
|
|
|
|
|
|
|
nsresult rv = mmsService->Retrieve(id, msgCallback);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
request.forget(aRequest);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-03-08 23:21:47 -08:00
|
|
|
nsresult
|
2013-04-10 05:18:35 -07:00
|
|
|
MobileMessageManager::DispatchTrustedSmsEventToSelf(const char* aTopic,
|
|
|
|
const nsAString& aEventName,
|
|
|
|
nsISupports* aMsg)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
2013-04-10 05:18:35 -07:00
|
|
|
nsCOMPtr<nsIDOMMozSmsMessage> sms = do_QueryInterface(aMsg);
|
|
|
|
if (sms) {
|
2014-06-10 18:23:34 -07:00
|
|
|
MozSmsEventInit init;
|
|
|
|
init.mBubbles = false;
|
|
|
|
init.mCancelable = false;
|
|
|
|
init.mMessage = sms;
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2014-06-10 18:23:34 -07:00
|
|
|
nsRefPtr<MozSmsEvent> event =
|
|
|
|
MozSmsEvent::Constructor(this, aEventName, init);
|
2013-04-10 05:18:35 -07:00
|
|
|
return DispatchTrustedEvent(event);
|
|
|
|
}
|
2013-03-08 23:21:47 -08:00
|
|
|
|
2013-04-10 05:18:35 -07:00
|
|
|
nsCOMPtr<nsIDOMMozMmsMessage> mms = do_QueryInterface(aMsg);
|
|
|
|
if (mms) {
|
2014-06-10 18:23:34 -07:00
|
|
|
MozMmsEventInit init;
|
|
|
|
init.mBubbles = false;
|
|
|
|
init.mCancelable = false;
|
|
|
|
init.mMessage = mms;
|
2013-03-08 23:22:42 -08:00
|
|
|
|
2014-06-10 18:23:34 -07:00
|
|
|
nsRefPtr<MozMmsEvent> event =
|
|
|
|
MozMmsEvent::Constructor(this, aEventName, init);
|
2013-04-10 05:18:35 -07:00
|
|
|
return DispatchTrustedEvent(event);
|
|
|
|
}
|
2013-03-08 23:22:42 -08:00
|
|
|
|
2013-04-10 05:18:35 -07:00
|
|
|
nsAutoCString errorMsg;
|
|
|
|
errorMsg.AssignLiteral("Got a '");
|
|
|
|
errorMsg.Append(aTopic);
|
|
|
|
errorMsg.AppendLiteral("' topic without a valid message!");
|
|
|
|
NS_ERROR(errorMsg.get());
|
|
|
|
return NS_OK;
|
2013-03-08 23:22:42 -08:00
|
|
|
}
|
|
|
|
|
2013-03-08 23:21:47 -08:00
|
|
|
NS_IMETHODIMP
|
|
|
|
MobileMessageManager::Observe(nsISupports* aSubject, const char* aTopic,
|
2014-01-04 07:02:17 -08:00
|
|
|
const char16_t* aData)
|
2013-03-08 23:21:47 -08:00
|
|
|
{
|
|
|
|
if (!strcmp(aTopic, kSmsReceivedObserverTopic)) {
|
2013-04-10 05:18:35 -07:00
|
|
|
return DispatchTrustedSmsEventToSelf(aTopic, RECEIVED_EVENT_NAME, aSubject);
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
2013-05-10 13:39:22 -07:00
|
|
|
if (!strcmp(aTopic, kSmsRetrievingObserverTopic)) {
|
|
|
|
return DispatchTrustedSmsEventToSelf(aTopic, RETRIEVING_EVENT_NAME, aSubject);
|
|
|
|
}
|
|
|
|
|
2013-03-08 23:21:47 -08:00
|
|
|
if (!strcmp(aTopic, kSmsSendingObserverTopic)) {
|
2013-04-10 05:18:35 -07:00
|
|
|
return DispatchTrustedSmsEventToSelf(aTopic, SENDING_EVENT_NAME, aSubject);
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(aTopic, kSmsSentObserverTopic)) {
|
2013-04-10 05:18:35 -07:00
|
|
|
return DispatchTrustedSmsEventToSelf(aTopic, SENT_EVENT_NAME, aSubject);
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(aTopic, kSmsFailedObserverTopic)) {
|
2013-04-10 05:18:35 -07:00
|
|
|
return DispatchTrustedSmsEventToSelf(aTopic, FAILED_EVENT_NAME, aSubject);
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(aTopic, kSmsDeliverySuccessObserverTopic)) {
|
2013-04-10 05:18:35 -07:00
|
|
|
return DispatchTrustedSmsEventToSelf(aTopic, DELIVERY_SUCCESS_EVENT_NAME, aSubject);
|
2013-03-08 23:21:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(aTopic, kSmsDeliveryErrorObserverTopic)) {
|
2013-04-10 05:18:35 -07:00
|
|
|
return DispatchTrustedSmsEventToSelf(aTopic, DELIVERY_ERROR_EVENT_NAME, aSubject);
|
2013-03-18 03:47:41 -07:00
|
|
|
}
|
|
|
|
|
2013-11-25 02:54:59 -08:00
|
|
|
if (!strcmp(aTopic, kSmsReadSuccessObserverTopic)) {
|
|
|
|
return DispatchTrustedSmsEventToSelf(aTopic, READ_SUCCESS_EVENT_NAME, aSubject);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(aTopic, kSmsReadErrorObserverTopic)) {
|
|
|
|
return DispatchTrustedSmsEventToSelf(aTopic, READ_ERROR_EVENT_NAME, aSubject);
|
|
|
|
}
|
|
|
|
|
2013-03-08 23:21:47 -08:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-09-15 19:12:43 -07:00
|
|
|
NS_IMETHODIMP
|
|
|
|
MobileMessageManager::GetSmscAddress(uint32_t aServiceId, uint8_t aArgc,
|
|
|
|
nsIDOMDOMRequest** aRequest)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID);
|
|
|
|
NS_ENSURE_TRUE(smsService, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
if (aArgc != 1) {
|
|
|
|
rv = smsService->GetSmsDefaultServiceId(&aServiceId);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsRefPtr<DOMRequest> request = new DOMRequest(GetOwner());
|
|
|
|
nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request);
|
|
|
|
rv = smsService->GetSmscAddress(aServiceId, msgCallback);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
request.forget(aRequest);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-03-08 23:21:47 -08:00
|
|
|
} // namespace dom
|
|
|
|
} // namespace mozilla
|