зеркало из https://github.com/mozilla/gecko-dev.git
381 строка
11 KiB
C++
381 строка
11 KiB
C++
/* 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 "SmsChild.h"
|
|
#include "SmsMessage.h"
|
|
#include "MmsMessage.h"
|
|
#include "DeletedMessageInfo.h"
|
|
#include "nsIObserverService.h"
|
|
#include "mozilla/Services.h"
|
|
#include "mozilla/dom/ContentChild.h"
|
|
#include "mozilla/dom/mobilemessage/Constants.h" // For MessageType
|
|
#include "MobileMessageThread.h"
|
|
#include "MainThreadUtils.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
using namespace mozilla::dom::mobilemessage;
|
|
|
|
namespace {
|
|
|
|
already_AddRefed<nsISupports>
|
|
CreateMessageFromMessageData(const MobileMessageData& aData)
|
|
{
|
|
nsCOMPtr<nsISupports> message;
|
|
|
|
switch(aData.type()) {
|
|
case MobileMessageData::TMmsMessageData:
|
|
message = new MmsMessage(aData.get_MmsMessageData());
|
|
break;
|
|
case MobileMessageData::TSmsMessageData:
|
|
message = new SmsMessage(aData.get_SmsMessageData());
|
|
break;
|
|
default:
|
|
MOZ_CRASH("Unexpected type of MobileMessageData");
|
|
}
|
|
|
|
return message.forget();
|
|
}
|
|
|
|
void
|
|
NotifyObserversWithMobileMessage(const char* aEventName,
|
|
const MobileMessageData& aData)
|
|
{
|
|
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
|
|
if (!obs) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsISupports> msg = CreateMessageFromMessageData(aData);
|
|
obs->NotifyObservers(msg, aEventName, nullptr);
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
namespace mobilemessage {
|
|
|
|
void
|
|
SmsChild::ActorDestroy(ActorDestroyReason aWhy)
|
|
{
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifyReceivedMessage(const MobileMessageData& aData)
|
|
{
|
|
NotifyObserversWithMobileMessage(kSmsReceivedObserverTopic, aData);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifyRetrievingMessage(const MobileMessageData& aData)
|
|
{
|
|
NotifyObserversWithMobileMessage(kSmsRetrievingObserverTopic, aData);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifySendingMessage(const MobileMessageData& aData)
|
|
{
|
|
NotifyObserversWithMobileMessage(kSmsSendingObserverTopic, aData);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifySentMessage(const MobileMessageData& aData)
|
|
{
|
|
NotifyObserversWithMobileMessage(kSmsSentObserverTopic, aData);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifyFailedMessage(const MobileMessageData& aData)
|
|
{
|
|
NotifyObserversWithMobileMessage(kSmsFailedObserverTopic, aData);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifyDeliverySuccessMessage(const MobileMessageData& aData)
|
|
{
|
|
NotifyObserversWithMobileMessage(kSmsDeliverySuccessObserverTopic, aData);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifyDeliveryErrorMessage(const MobileMessageData& aData)
|
|
{
|
|
NotifyObserversWithMobileMessage(kSmsDeliveryErrorObserverTopic, aData);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifyReceivedSilentMessage(const MobileMessageData& aData)
|
|
{
|
|
NotifyObserversWithMobileMessage(kSilentSmsReceivedObserverTopic, aData);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifyReadSuccessMessage(const MobileMessageData& aData)
|
|
{
|
|
NotifyObserversWithMobileMessage(kSmsReadSuccessObserverTopic, aData);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifyReadErrorMessage(const MobileMessageData& aData)
|
|
{
|
|
NotifyObserversWithMobileMessage(kSmsReadErrorObserverTopic, aData);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SmsChild::RecvNotifyDeletedMessageInfo(const DeletedMessageInfoData& aDeletedInfo)
|
|
{
|
|
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
|
|
if (!obs) {
|
|
NS_ERROR("Failed to get nsIObserverService!");
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsISupports> info = new DeletedMessageInfo(aDeletedInfo);
|
|
obs->NotifyObservers(info, kSmsDeletedObserverTopic, nullptr);
|
|
|
|
return true;
|
|
}
|
|
|
|
PSmsRequestChild*
|
|
SmsChild::AllocPSmsRequestChild(const IPCSmsRequest& aRequest)
|
|
{
|
|
MOZ_CRASH("Caller is supposed to manually construct a request!");
|
|
}
|
|
|
|
bool
|
|
SmsChild::DeallocPSmsRequestChild(PSmsRequestChild* aActor)
|
|
{
|
|
delete aActor;
|
|
return true;
|
|
}
|
|
|
|
PMobileMessageCursorChild*
|
|
SmsChild::AllocPMobileMessageCursorChild(const IPCMobileMessageCursor& aCursor)
|
|
{
|
|
MOZ_CRASH("Caller is supposed to manually construct a cursor!");
|
|
}
|
|
|
|
bool
|
|
SmsChild::DeallocPMobileMessageCursorChild(PMobileMessageCursorChild* aActor)
|
|
{
|
|
// MobileMessageCursorChild is refcounted, must not be freed manually.
|
|
// Originally AddRefed in SendCursorRequest() in SmsIPCService.cpp.
|
|
static_cast<MobileMessageCursorChild*>(aActor)->Release();
|
|
return true;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* SmsRequestChild
|
|
******************************************************************************/
|
|
|
|
SmsRequestChild::SmsRequestChild(nsIMobileMessageCallback* aReplyRequest)
|
|
: mReplyRequest(aReplyRequest)
|
|
{
|
|
MOZ_COUNT_CTOR(SmsRequestChild);
|
|
MOZ_ASSERT(aReplyRequest);
|
|
}
|
|
|
|
void
|
|
SmsRequestChild::ActorDestroy(ActorDestroyReason aWhy)
|
|
{
|
|
// Nothing needed here.
|
|
}
|
|
|
|
bool
|
|
SmsRequestChild::Recv__delete__(const MessageReply& aReply)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(mReplyRequest);
|
|
nsCOMPtr<SmsMessage> message;
|
|
switch(aReply.type()) {
|
|
case MessageReply::TReplyMessageSend: {
|
|
const MobileMessageData& data =
|
|
aReply.get_ReplyMessageSend().messageData();
|
|
nsCOMPtr<nsISupports> msg = CreateMessageFromMessageData(data);
|
|
mReplyRequest->NotifyMessageSent(msg);
|
|
}
|
|
break;
|
|
case MessageReply::TReplyMessageSendFail: {
|
|
const ReplyMessageSendFail &replyFail = aReply.get_ReplyMessageSendFail();
|
|
nsCOMPtr<nsISupports> msg;
|
|
|
|
if (replyFail.messageData().type() ==
|
|
OptionalMobileMessageData::TMobileMessageData) {
|
|
msg = CreateMessageFromMessageData(
|
|
replyFail.messageData().get_MobileMessageData());
|
|
}
|
|
|
|
mReplyRequest->NotifySendMessageFailed(replyFail.error(), msg);
|
|
}
|
|
break;
|
|
case MessageReply::TReplyGetMessage: {
|
|
const MobileMessageData& data =
|
|
aReply.get_ReplyGetMessage().messageData();
|
|
nsCOMPtr<nsISupports> msg = CreateMessageFromMessageData(data);
|
|
mReplyRequest->NotifyMessageGot(msg);
|
|
}
|
|
break;
|
|
case MessageReply::TReplyGetMessageFail:
|
|
mReplyRequest->NotifyGetMessageFailed(aReply.get_ReplyGetMessageFail().error());
|
|
break;
|
|
case MessageReply::TReplyMessageDelete: {
|
|
const InfallibleTArray<bool>& deletedResult = aReply.get_ReplyMessageDelete().deleted();
|
|
mReplyRequest->NotifyMessageDeleted(const_cast<bool *>(deletedResult.Elements()),
|
|
deletedResult.Length());
|
|
}
|
|
break;
|
|
case MessageReply::TReplyMessageDeleteFail:
|
|
mReplyRequest->NotifyDeleteMessageFailed(aReply.get_ReplyMessageDeleteFail().error());
|
|
break;
|
|
case MessageReply::TReplyMarkeMessageRead:
|
|
mReplyRequest->NotifyMessageMarkedRead(aReply.get_ReplyMarkeMessageRead().read());
|
|
break;
|
|
case MessageReply::TReplyMarkeMessageReadFail:
|
|
mReplyRequest->NotifyMarkMessageReadFailed(aReply.get_ReplyMarkeMessageReadFail().error());
|
|
break;
|
|
case MessageReply::TReplyGetSegmentInfoForText: {
|
|
const ReplyGetSegmentInfoForText& reply =
|
|
aReply.get_ReplyGetSegmentInfoForText();
|
|
mReplyRequest->NotifySegmentInfoForTextGot(reply.segments(),
|
|
reply.charsPerSegment(),
|
|
reply.charsAvailableInLastSegment());
|
|
}
|
|
break;
|
|
case MessageReply::TReplyGetSegmentInfoForTextFail:
|
|
mReplyRequest->NotifyGetSegmentInfoForTextFailed(
|
|
aReply.get_ReplyGetSegmentInfoForTextFail().error());
|
|
break;
|
|
case MessageReply::TReplyGetSmscAddress:
|
|
mReplyRequest->NotifyGetSmscAddress(aReply.get_ReplyGetSmscAddress().smscAddress());
|
|
break;
|
|
case MessageReply::TReplyGetSmscAddressFail:
|
|
mReplyRequest->NotifyGetSmscAddressFailed(aReply.get_ReplyGetSmscAddressFail().error());
|
|
break;
|
|
default:
|
|
MOZ_CRASH("Received invalid response parameters!");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* MobileMessageCursorChild
|
|
******************************************************************************/
|
|
|
|
NS_IMPL_ISUPPORTS(MobileMessageCursorChild, nsICursorContinueCallback)
|
|
|
|
MobileMessageCursorChild::MobileMessageCursorChild(nsIMobileMessageCursorCallback* aCallback)
|
|
: mCursorCallback(aCallback)
|
|
{
|
|
MOZ_COUNT_CTOR(MobileMessageCursorChild);
|
|
MOZ_ASSERT(aCallback);
|
|
}
|
|
|
|
void
|
|
MobileMessageCursorChild::ActorDestroy(ActorDestroyReason aWhy)
|
|
{
|
|
// Nothing needed here.
|
|
}
|
|
|
|
bool
|
|
MobileMessageCursorChild::RecvNotifyResult(const MobileMessageCursorData& aData)
|
|
{
|
|
MOZ_ASSERT(mCursorCallback);
|
|
|
|
switch(aData.type()) {
|
|
case MobileMessageCursorData::TMobileMessageArrayData:
|
|
DoNotifyResult(aData.get_MobileMessageArrayData().messages());
|
|
break;
|
|
case MobileMessageCursorData::TThreadArrayData:
|
|
DoNotifyResult(aData.get_ThreadArrayData().threads());
|
|
break;
|
|
default:
|
|
MOZ_CRASH("Received invalid response parameters!");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
MobileMessageCursorChild::Recv__delete__(const int32_t& aError)
|
|
{
|
|
MOZ_ASSERT(mCursorCallback);
|
|
|
|
if (aError != nsIMobileMessageCallback::SUCCESS_NO_ERROR) {
|
|
mCursorCallback->NotifyCursorError(aError);
|
|
} else {
|
|
mCursorCallback->NotifyCursorDone();
|
|
}
|
|
mCursorCallback = nullptr;
|
|
|
|
return true;
|
|
}
|
|
|
|
// nsICursorContinueCallback
|
|
|
|
NS_IMETHODIMP
|
|
MobileMessageCursorChild::HandleContinue()
|
|
{
|
|
MOZ_ASSERT(mCursorCallback);
|
|
|
|
SendContinue();
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
MobileMessageCursorChild::DoNotifyResult(const nsTArray<MobileMessageData>& aDataArray)
|
|
{
|
|
const uint32_t length = aDataArray.Length();
|
|
MOZ_ASSERT(length);
|
|
|
|
AutoFallibleTArray<nsISupports*, 1> autoArray;
|
|
NS_ENSURE_TRUE_VOID(autoArray.SetCapacity(length));
|
|
|
|
AutoFallibleTArray<nsCOMPtr<nsISupports>, 1> messages;
|
|
NS_ENSURE_TRUE_VOID(messages.SetCapacity(length));
|
|
|
|
for (uint32_t i = 0; i < length; i++) {
|
|
nsCOMPtr<nsISupports> message = CreateMessageFromMessageData(aDataArray[i]);
|
|
NS_ENSURE_TRUE_VOID(messages.AppendElement(message));
|
|
NS_ENSURE_TRUE_VOID(autoArray.AppendElement(message.get()));
|
|
}
|
|
|
|
mCursorCallback->NotifyCursorResult(autoArray.Elements(), length);
|
|
}
|
|
|
|
void
|
|
MobileMessageCursorChild::DoNotifyResult(const nsTArray<ThreadData>& aDataArray)
|
|
{
|
|
const uint32_t length = aDataArray.Length();
|
|
MOZ_ASSERT(length);
|
|
|
|
AutoFallibleTArray<nsISupports*, 1> autoArray;
|
|
NS_ENSURE_TRUE_VOID(autoArray.SetCapacity(length));
|
|
|
|
AutoFallibleTArray<nsCOMPtr<nsISupports>, 1> threads;
|
|
NS_ENSURE_TRUE_VOID(threads.SetCapacity(length));
|
|
|
|
for (uint32_t i = 0; i < length; i++) {
|
|
nsCOMPtr<nsISupports> thread = new MobileMessageThread(aDataArray[i]);
|
|
NS_ENSURE_TRUE_VOID(threads.AppendElement(thread));
|
|
NS_ENSURE_TRUE_VOID(autoArray.AppendElement(thread.get()));
|
|
}
|
|
|
|
mCursorCallback->NotifyCursorResult(autoArray.Elements(), length);
|
|
}
|
|
|
|
} // namespace mobilemessage
|
|
} // namespace dom
|
|
} // namespace mozilla
|