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