dom/mobilemessage/SmsMessage.cpp

   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 "SmsMessage.h"
   7 #include "nsIDOMClassInfo.h"
   8 #include "jsapi.h" // For OBJECT_TO_JSVAL and JS_NewDateObjectMsec
   9 #include "jsfriendapi.h" // For js_DateGetMsecSinceEpoch
  10 #include "mozilla/dom/mobilemessage/Constants.h" // For MessageType
  11
  12 using namespace mozilla::dom::mobilemessage;
  13
  14 namespace mozilla {
  15 namespace dom {
  16
  17 NS_INTERFACE_MAP_BEGIN(SmsMessage)
  18   NS_INTERFACE_MAP_ENTRY(nsIDOMMozSmsMessage)
  19   NS_INTERFACE_MAP_ENTRY(nsISupports)
  20   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(MozSmsMessage)
  21 NS_INTERFACE_MAP_END
  22
  23 NS_IMPL_ADDREF(SmsMessage)
  24 NS_IMPL_RELEASE(SmsMessage)
  25
  26 SmsMessage::SmsMessage(int32_t aId,
  27                        uint64_t aThreadId,
  28                        const nsString& aIccId,
  29                        DeliveryState aDelivery,
  30                        DeliveryStatus aDeliveryStatus,
  31                        const nsString& aSender,
  32                        const nsString& aReceiver,
  33                        const nsString& aBody,
  34                        MessageClass aMessageClass,
  35                        uint64_t aTimestamp,
  36                        uint64_t aSentTimestamp,
  37                        uint64_t aDeliveryTimestamp,
  38                        bool aRead)
  39   : mData(aId, aThreadId, aIccId, aDelivery, aDeliveryStatus,
  40           aSender, aReceiver, aBody, aMessageClass, aTimestamp, aSentTimestamp,
  41           aDeliveryTimestamp, aRead)
  42 {
  43 }
  44
  45 SmsMessage::SmsMessage(const SmsMessageData& aData)
  46   : mData(aData)
  47 {
  48 }
  49
  50 /* static */ nsresult
  51 SmsMessage::Create(int32_t aId,
  52                    uint64_t aThreadId,
  53                    const nsAString& aIccId,
  54                    const nsAString& aDelivery,
  55                    const nsAString& aDeliveryStatus,
  56                    const nsAString& aSender,
  57                    const nsAString& aReceiver,
  58                    const nsAString& aBody,
  59                    const nsAString& aMessageClass,
  60                    uint64_t aTimestamp,
  61                    uint64_t aSentTimestamp,
  62                    uint64_t aDeliveryTimestamp,
  63                    bool aRead,
  64                    JSContext* aCx,
  65                    nsIDOMMozSmsMessage** aMessage)
  66 {
  67   *aMessage = nullptr;
  68
  69   // SmsMessageData exposes these as references, so we can simply assign
  70   // to them.
  71   SmsMessageData data;
  72   data.id() = aId;
  73   data.threadId() = aThreadId;
  74   data.iccId() = nsString(aIccId);
  75   data.sender() = nsString(aSender);
  76   data.receiver() = nsString(aReceiver);
  77   data.body() = nsString(aBody);
  78   data.read() = aRead;
  79
  80   if (aDelivery.Equals(DELIVERY_RECEIVED)) {
  81     data.delivery() = eDeliveryState_Received;
  82   } else if (aDelivery.Equals(DELIVERY_SENDING)) {
  83     data.delivery() = eDeliveryState_Sending;
  84   } else if (aDelivery.Equals(DELIVERY_SENT)) {
  85     data.delivery() = eDeliveryState_Sent;
  86   } else if (aDelivery.Equals(DELIVERY_ERROR)) {
  87     data.delivery() = eDeliveryState_Error;
  88   } else {
  89     return NS_ERROR_INVALID_ARG;
  90   }
  91
  92   if (aDeliveryStatus.Equals(DELIVERY_STATUS_NOT_APPLICABLE)) {
  93     data.deliveryStatus() = eDeliveryStatus_NotApplicable;
  94   } else if (aDeliveryStatus.Equals(DELIVERY_STATUS_SUCCESS)) {
  95     data.deliveryStatus() = eDeliveryStatus_Success;
  96   } else if (aDeliveryStatus.Equals(DELIVERY_STATUS_PENDING)) {
  97     data.deliveryStatus() = eDeliveryStatus_Pending;
  98   } else if (aDeliveryStatus.Equals(DELIVERY_STATUS_ERROR)) {
  99     data.deliveryStatus() = eDeliveryStatus_Error;
 100   } else {
 101     return NS_ERROR_INVALID_ARG;
 102   }
 103
 104   if (aMessageClass.Equals(MESSAGE_CLASS_NORMAL)) {
 105     data.messageClass() = eMessageClass_Normal;
 106   } else if (aMessageClass.Equals(MESSAGE_CLASS_CLASS_0)) {
 107     data.messageClass() = eMessageClass_Class0;
 108   } else if (aMessageClass.Equals(MESSAGE_CLASS_CLASS_1)) {
 109     data.messageClass() = eMessageClass_Class1;
 110   } else if (aMessageClass.Equals(MESSAGE_CLASS_CLASS_2)) {
 111     data.messageClass() = eMessageClass_Class2;
 112   } else if (aMessageClass.Equals(MESSAGE_CLASS_CLASS_3)) {
 113     data.messageClass() = eMessageClass_Class3;
 114   } else {
 115     return NS_ERROR_INVALID_ARG;
 116   }
 117
 118   // Set |timestamp|.
 119   data.timestamp() = aTimestamp;
 120
 121   // Set |sentTimestamp|.
 122   data.sentTimestamp() = aSentTimestamp;
 123
 124   // Set |deliveryTimestamp|.
 125   data.deliveryTimestamp() = aDeliveryTimestamp;
 126
 127   nsCOMPtr<nsIDOMMozSmsMessage> message = new SmsMessage(data);
 128   message.swap(*aMessage);
 129   return NS_OK;
 130 }
 131
 132 const SmsMessageData&
 133 SmsMessage::GetData() const
 134 {
 135   return mData;
 136 }
 137
 138 NS_IMETHODIMP
 139 SmsMessage::GetType(nsAString& aType)
 140 {
 141   aType = NS_LITERAL_STRING("sms");
 142   return NS_OK;
 143 }
 144
 145 NS_IMETHODIMP
 146 SmsMessage::GetId(int32_t* aId)
 147 {
 148   *aId = mData.id();
 149   return NS_OK;
 150 }
 151
 152 NS_IMETHODIMP
 153 SmsMessage::GetThreadId(uint64_t* aThreadId)
 154 {
 155   *aThreadId = mData.threadId();
 156   return NS_OK;
 157 }
 158
 159 NS_IMETHODIMP
 160 SmsMessage::GetIccId(nsAString& aIccId)
 161 {
 162   aIccId = mData.iccId();
 163   return NS_OK;
 164 }
 165
 166 NS_IMETHODIMP
 167 SmsMessage::GetDelivery(nsAString& aDelivery)
 168 {
 169   switch (mData.delivery()) {
 170     case eDeliveryState_Received:
 171       aDelivery = DELIVERY_RECEIVED;
 172       break;
 173     case eDeliveryState_Sending:
 174       aDelivery = DELIVERY_SENDING;
 175       break;
 176     case eDeliveryState_Sent:
 177       aDelivery = DELIVERY_SENT;
 178       break;
 179     case eDeliveryState_Error:
 180       aDelivery = DELIVERY_ERROR;
 181       break;
 182     case eDeliveryState_Unknown:
 183     case eDeliveryState_EndGuard:
 184     default:
 185       MOZ_CRASH("We shouldn't get any other delivery state!");
 186   }
 187
 188   return NS_OK;
 189 }
 190
 191 NS_IMETHODIMP
 192 SmsMessage::GetDeliveryStatus(nsAString& aDeliveryStatus)
 193 {
 194   switch (mData.deliveryStatus()) {
 195     case eDeliveryStatus_NotApplicable:
 196       aDeliveryStatus = DELIVERY_STATUS_NOT_APPLICABLE;
 197       break;
 198     case eDeliveryStatus_Success:
 199       aDeliveryStatus = DELIVERY_STATUS_SUCCESS;
 200       break;
 201     case eDeliveryStatus_Pending:
 202       aDeliveryStatus = DELIVERY_STATUS_PENDING;
 203       break;
 204     case eDeliveryStatus_Error:
 205       aDeliveryStatus = DELIVERY_STATUS_ERROR;
 206       break;
 207     case eDeliveryStatus_EndGuard:
 208     default:
 209       MOZ_CRASH("We shouldn't get any other delivery status!");
 210   }
 211
 212   return NS_OK;
 213 }
 214
 215 NS_IMETHODIMP
 216 SmsMessage::GetSender(nsAString& aSender)
 217 {
 218   aSender = mData.sender();
 219   return NS_OK;
 220 }
 221
 222 NS_IMETHODIMP
 223 SmsMessage::GetReceiver(nsAString& aReceiver)
 224 {
 225   aReceiver = mData.receiver();
 226   return NS_OK;
 227 }
 228
 229 NS_IMETHODIMP
 230 SmsMessage::GetBody(nsAString& aBody)
 231 {
 232   aBody = mData.body();
 233   return NS_OK;
 234 }
 235
 236 NS_IMETHODIMP
 237 SmsMessage::GetMessageClass(nsAString& aMessageClass)
 238 {
 239   switch (mData.messageClass()) {
 240     case eMessageClass_Normal:
 241       aMessageClass = MESSAGE_CLASS_NORMAL;
 242       break;
 243     case eMessageClass_Class0:
 244       aMessageClass = MESSAGE_CLASS_CLASS_0;
 245       break;
 246     case eMessageClass_Class1:
 247       aMessageClass = MESSAGE_CLASS_CLASS_1;
 248       break;
 249     case eMessageClass_Class2:
 250       aMessageClass = MESSAGE_CLASS_CLASS_2;
 251       break;
 252     case eMessageClass_Class3:
 253       aMessageClass = MESSAGE_CLASS_CLASS_3;
 254       break;
 255     default:
 256       MOZ_CRASH("We shouldn't get any other message class!");
 257   }
 258
 259   return NS_OK;
 260 }
 261
 262 NS_IMETHODIMP
 263 SmsMessage::GetTimestamp(DOMTimeStamp* aTimestamp)
 264 {
 265   *aTimestamp = mData.timestamp();
 266   return NS_OK;
 267 }
 268
 269 NS_IMETHODIMP
 270 SmsMessage::GetSentTimestamp(DOMTimeStamp* aSentTimestamp)
 271 {
 272   *aSentTimestamp = mData.sentTimestamp();
 273   return NS_OK;
 274 }
 275
 276 NS_IMETHODIMP
 277 SmsMessage::GetDeliveryTimestamp(DOMTimeStamp* aDate)
 278 {
 279   *aDate = mData.deliveryTimestamp();
 280   return NS_OK;
 281 }
 282
 283 NS_IMETHODIMP
 284 SmsMessage::GetRead(bool* aRead)
 285 {
 286   *aRead = mData.read();
 287   return NS_OK;
 288 }
 289
 290 } // namespace dom
 291 } // namespace mozilla