gecko-dev/dom/mobilemessage/ipc/SmsChild.cpp

381 lines
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