src/Messaging/Sms.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include "Sms.h"
  19 #include <Commons/Exception.h>
  20 #include "ReqReceiverMessage.h"
  21 #include "Messaging.h"
  22 #include "CallbackMgr.h"
  23 #include "MsgServiceHandleMgr.h"
  24 #include <Logger.h>
  25
  26 extern "C" {
  27 #include <msg_storage.h>
  28 }
  29
  30 using namespace std;
  31
  32 namespace {
  33 const char* EMPTY_ID = "0";
  34 }
  35
  36 namespace DeviceAPI {
  37 namespace Messaging {
  38
  39 Sms::Sms(const string& id) :
  40     IMessage(SMS, id),
  41     m_messageData(NULL)
  42 {
  43     LoggerD("enter");
  44     LoggerD("m_id=" << getIdRef());
  45     LoggerD("m_msgType=" << getMessageType());
  46
  47     if (getIdRef().empty()) {
  48         createNewMessage();
  49     } else {
  50         readExistingMessage();
  51     }
  52
  53     Touch();
  54 }
  55
  56 Sms::Sms(const std::string& id, const msg_struct_t msg_data) :
  57         IMessage(SMS, id),
  58         m_messageData(NULL)
  59 {
  60         LoggerD("enter");
  61         LoggerD("m_id=" << getIdRef());
  62         LoggerD("m_msgType=" << getMessageType());
  63
  64         LoggerD("created msg_data : " << msg_data);
  65         m_messageData = createNewCopyOfPLatformMsgWithAddressList(msg_data);
  66         LoggerD("created m_messageData : " << m_messageData);
  67
  68         readConversationId(m_messageData);
  69         readRecipientList(m_messageData);
  70         readBody(m_messageData);
  71         readFolder(m_messageData);
  72         readDateTime(m_messageData);
  73         readReadStatus(m_messageData);
  74         readSize(m_messageData);
  75         readMessageStatus(m_messageData);
  76 //      setMessageStatus(MESSAGE_STATUS_LOADED);
  77         Touch();
  78 }
  79
  80 Sms::~Sms()
  81 {
  82     LoggerD("enter");
  83
  84     if (m_messageData) {
  85         // release platform message structure
  86         LoggerD("release m_messageData : " << m_messageData);
  87         msg_release_struct(&m_messageData);
  88     }
  89 }
  90
  91 void Sms::update(bool draftsOnly)
  92 {
  93     LoggerD("updating m_id=" << getIdRef());
  94
  95     if (!m_messageData) {
  96         //error if platform message not exists
  97         LoggerE("message can not be updated");
  98         Throw(WrtDeviceApis::Commons::PlatformException);
  99     }
 100
 101     //update all sms data
 102     if (!draftsOnly || getCurrentFolder() == DRAFTBOX) {
 103         updateBody();
 104         updateFrom();
 105         updateTo();
 106         updateSourceAddress();
 107     }
 108     updateReadStatus();
 109 }
 110
 111 void Sms::readAllData()
 112 {
 113     readExistingMessage();
 114 }
 115
 116 void Sms::moveToFolder(const FolderType newFolder)
 117 {
 118 /*
 119     update();
 120
 121     Try
 122     {
 123         const msg_folder_id_t platfromFolderId =
 124             Messaging::convertFolderToPlatform(newFolder);
 125
 126         //call platform api to move message to other folder
 127         if (msg_move_msg_to_folder(MsgGetCommonHandle(), convertId(getId()),
 128                                    platfromFolderId) != MSG_SUCCESS) {
 129             Throw(WrtDeviceApis::Commons::PlatformException);
 130         }
 131     }
 132
 133     Catch(WrtDeviceApis::Commons::PlatformException) {
 134         LoggerE("remove message error");
 135         throw;
 136     }
 137 */
 138 }
 139
 140 void Sms::moveToFolder(const std::string& newFolder)
 141 {
 142 //    update();
 143     //TODO
 144 }
 145
 146 void Sms::copyToFolder(const FolderType newFolder)
 147 {
 148 /*
 149     update();
 150
 151     msg_message_t msg = msg_new_message();
 152
 153     Try
 154     {
 155         MSG_SENDINGOPT_S option = { false, false, false };
 156         option.option.smsSendOpt.bReplyPath = true;
 157         // trying to get message from platform
 158         if (MSG_SUCCESS ==
 159             msg_get_message(MsgGetCommonHandle(), convertId(getIdRef()), msg,
 160                             &option)) {
 161             const msg_folder_id_t platfromFolderId =
 162                 Messaging::convertFolderToPlatform(newFolder);
 163             // new id will me set (initialize to 0)
 164             msg_set_message_id(msg, 0);
 165             msg_set_folder_id(msg, platfromFolderId);
 166
 167             // trying to add message
 168             int error = msg_add_message(MsgGetCommonHandle(), msg, &option);
 169             if (error != MSG_SUCCESS) {
 170                 LoggerE("msg_add_message failed, error code=" << error);
 171                 Throw(WrtDeviceApis::Commons::PlatformException);
 172             }
 173
 174             //releasing platform message structure
 175             msg_release_message(&msg);
 176         }
 177     }
 178
 179     Catch(WrtDeviceApis::Commons::PlatformException) {
 180         LoggerE("remove message error");
 181         if (msg) {
 182             //releasing platform message structure
 183             msg_release_message(&msg);
 184         }
 185         throw;
 186     }
 187 */
 188 }
 189
 190 void Sms::copyToFolder(const std::string& newFolder)
 191 {
 192 //    update();
 193     //TODO
 194 }
 195
 196 int Sms::send()
 197 {
 198         LoggerD("sending message, id=" << getIdRef());
 199         Try{
 200                 if(m_messageData == NULL)
 201                 {
 202                         //prepare for sending sms
 203                         update();
 204                 }
 205                 MsgGetCommonHandle();
 206         }
 207         Catch(WrtDeviceApis::Commons::PlatformException)
 208         {
 209                 LoggerD("getHandle failed");
 210                 Throw(WrtDeviceApis::Commons::PlatformException);
 211         }
 212
 213     // split the message
 214         SendRequest req;
 215
 216         msg_struct_list_s *addr_list = NULL;
 217         msg_struct_list_s *new_addr_list = NULL;
 218         char strNumber[MAX_ADDRESS_VAL_LEN] = {0,};
 219         int nToCnt;
 220         int tempInt;
 221         int tempIdInt;
 222
 223         msg_get_list_handle(m_messageData, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addr_list);
 224         msg_get_int_value(m_messageData, MSG_MESSAGE_ID_INT, &tempIdInt);
 225
 226         nToCnt = addr_list->nCount;
 227         LoggerD("nToCnt : " << nToCnt);
 228
 229         for (int i = 0; i < nToCnt; ++i)
 230         {
 231                 msg_struct_t new_msg = createNewCopyOfPLatformMsg(m_messageData);
 232                 msg_set_int_value(new_msg, MSG_MESSAGE_ID_INT, tempIdInt);
 233
 234                 msg_get_list_handle(new_msg, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&new_addr_list);
 235
 236                 msg_get_int_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT, &tempInt);
 237                 LoggerD("RECIPIENT_TYPE : " << tempInt);
 238                 if(MSG_RECIPIENTS_TYPE_TO != tempInt)
 239                 {
 240                         LoggerD("skip");
 241                         continue;
 242                 }
 243
 244                 msg_get_str_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, strNumber, MAX_ADDRESS_VAL_LEN);
 245                 msg_set_str_value(new_addr_list->msg_struct_info[0], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, strNumber, MAX_ADDRESS_VAL_LEN);
 246                 msg_set_int_value(new_addr_list->msg_struct_info[0], MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT, MSG_RECIPIENTS_TYPE_TO);
 247                 new_addr_list->nCount = 1;
 248
 249                 setMessageStatus(MESSAGE_STATUS_SENDING);
 250
 251                 req.queue.push(new_msg);
 252         }
 253
 254
 255         DPL::Mutex::ScopedLock lock(&m_mutex);
 256         m_sendRequests.push(req);
 257
 258     // schedule sending
 259         PostEvent(0);
 260
 261         LoggerD("sending method finished");
 262
 263         return 0;               //sms handle is -1;
 264 }
 265
 266 void Sms::sendingCallback(msg_struct_t sent_status)
 267 {
 268 //    LoggerI(
 269 //        "sendingCallback callback received. Req id = " <<
 270 //        sent_status->reqId << " Status = " << (int)sent_status->status <<
 271 //        ", Recipient=" << getRecipient());
 272     int status = MSG_NETWORK_SEND_FAIL;
 273
 274     msg_get_int_value(sent_status, MSG_SENT_STATUS_NETWORK_STATUS_INT, &status);
 275
 276     DPL::Mutex::ScopedLock lock(&m_mutex);
 277
 278     if (status != MSG_NETWORK_SEND_SUCCESS) {
 279         m_sendRequests.front().failed = true; // TODO mutex
 280         //send callback, error for recipient
 281         setSendingStatusFailed(getRecipient());
 282         setMessageStatus(MESSAGE_STATUS_FAILED);
 283     } else {
 284         setSendingStatusOk(getRecipient());
 285         setMessageStatus(MESSAGE_STATUS_SENT);
 286     }
 287
 288     msg_release_struct(&currentQueue().front());
 289     currentQueue().pop();
 290
 291     //schedule another sub message send
 292     PostEvent(0);
 293 }
 294
 295 void Sms::OnEventReceived(const int&)
 296 {
 297     LoggerD("enter");
 298     // send another one
 299     sendSubMessage();
 300 }
 301
 302 FolderType Sms::toFolder(const std::string &folder)
 303 {
 304     if (folder == "INBOX") {
 305         return INBOX;
 306     } else if (folder == "OUTBOX") {
 307         return OUTBOX;
 308     } else if (folder == "SENTBOX") {
 309         return SENTBOX;
 310     } else if (folder == "DRAFTBOX") {
 311         return DRAFTBOX;
 312     }
 313     ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Invalid folder");
 314 }
 315
 316 void Sms::sendSubMessage()
 317 {
 318     LoggerD("enter");
 319
 320     DPL::Mutex::ScopedLock lock(&m_mutex);
 321
 322     // if current request queue gets empty, try next one
 323     while (!m_sendRequests.empty()) {
 324         // send as long as the sending fails until there are no more messages
 325         for (msg_error_t err = MSG_ERR_UNKNOWN;
 326              err != MSG_SUCCESS && !currentQueue().empty(); )
 327         {
 328             err = CallbackMgrSingleton::Instance().registerAndSend(
 329                     msg_sms_send_message,
 330                     currentQueue().front(),
 331                     this);
 332             LoggerI("Sending Message (submit request) result:" << err);
 333             if (err != MSG_SUCCESS) {
 334                 LoggerE("Sending Message (submit request) failed!!! err=" << err);
 335                 msg_release_struct(&currentQueue().front());
 336                 currentQueue().pop();
 337                 m_sendRequests.front().failed = true;
 338                 //send callback, error for recipient
 339                 setSendingStatusFailed(getRecipient());
 340             }
 341         }
 342
 343         // empty queue -> notify about results
 344         if (currentQueue().empty()) {
 345                 /*
 346             if (m_sendRequests.front().failed) {
 347                 setSendingStatusFailed();
 348             } else {
 349                 setSendingStatusOk();
 350             }
 351             */
 352             // this request is finished, try next one
 353             m_sendRequests.pop();
 354             continue;
 355         }
 356         break;
 357     }
 358 }
 359
 360 void Sms::setSendingStatusOk(const string &recipient)
 361 {
 362     LoggerD("enter, success number is : " << recipient);
 363     //success callback should be executed here
 364     ReqReceiverMessage *requestReceiver = getRequestReceiver();
 365     if (requestReceiver) {
 366          EventMessagingServicePtr event = getMessagingServiceEvent();
 367          event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::None);
 368          event->m_successRecipients.push_back(recipient);
 369
 370          msg_struct_list_s *addr_list = NULL;
 371          msg_get_list_handle(m_messageData, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addr_list);
 372
 373           if ( event->m_successRecipients.size() + event->m_failRecipients.size() == (unsigned int)addr_list->nCount)
 374         {
 375                 requestReceiver->WrtDeviceApis::Commons::EventRequestReceiver< EventMessagingService >::ManualAnswer(event);
 376         }
 377
 378 #if 0
 379         EventSendMessagePtr event = getSendMessageEvent();
 380         event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::None);
 381         event->m_successRecipients.push_back(recipient);
 382           //LoggerD("total address size : " << msg_get_address_count(m_messageData) << " Status size : " << event->m_successRecipients.size() + event->m_failRecipients.size());
 383         if ( event->m_successRecipients.size() + event->m_failRecipients.size() == (unsigned int)msg_get_address_count(m_messageData))
 384         {
 385                 requestReceiver->WrtDeviceApis::Commons::EventRequestReceiver< EventSendMessage >::ManualAnswer(event);
 386         }
 387 #endif
 388
 389     }
 390 }
 391
 392 void Sms::setSendingStatusFailed(const string &recipient)
 393 {
 394     LoggerD("enter, fail number is : " << recipient);
 395     //error callback should be executed here
 396     EventOnSendingFailedEmitterPtr emitter = getEmitter();
 397     if (emitter) {
 398         EventOnSendingFailedPtr event(new EventOnSendingFailed);
 399         event->setError(EventOnSendingFailed::UNKNOWN); // TODO error codes
 400         emitter->emit(event);
 401     } else {
 402         ReqReceiverMessage *requestReceiver = getRequestReceiver();
 403         if (requestReceiver) {
 404             LoggerE("calling JS error callback");
 405             EventMessagingServicePtr event = getMessagingServiceEvent();
 406             event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
 407                 event->m_successRecipients.push_back(recipient);
 408                 msg_struct_list_s *addr_list = NULL;
 409                 msg_get_list_handle(m_messageData, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addr_list);
 410
 411                  if ( event->m_successRecipients.size() + event->m_failRecipients.size() == (unsigned int)addr_list->nCount)
 412                  {
 413                    requestReceiver->WrtDeviceApis::Commons::EventRequestReceiver< EventMessagingService >::ManualAnswer(event);
 414                  }
 415
 416         }
 417     }
 418 }
 419
 420 void Sms::remove()
 421 {
 422     Try
 423     {
 424         // delete message from platform
 425         if (msg_delete_message(MsgGetCommonHandle(),
 426                                convertId(getId())) != MSG_SUCCESS) {
 427             LoggerE("delete message failed");
 428             Throw(WrtDeviceApis::Commons::PlatformException);
 429         } else {
 430             LoggerD("message deleted succesfully");
 431         }
 432     }
 433
 434     Catch(WrtDeviceApis::Commons::PlatformException) {
 435         LoggerE("remove message error");
 436         throw;
 437     }
 438 }
 439
 440 void Sms::createNewMessage()
 441 {
 442     LoggerD("enter");
 443     if (m_messageData) {
 444         // release platform message if it was created previously
 445         msg_release_struct(&m_messageData);
 446         m_messageData = NULL;
 447     }
 448     // create new platform message
 449     LoggerD("create messeage instance");
 450     m_messageData = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 451     LoggerD("created message : " << m_messageData);
 452
 453     Try
 454     {
 455         //default message initialization
 456         // update sms data
 457         updateBody();
 458         updateTo();
 459
 460         setMessageStatus(MESSAGE_STATUS_DRAFT);
 461
 462         tm dateT = getDateTime();
 463         msg_set_int_value(m_messageData, MSG_MESSAGE_DISPLAY_TIME_INT, (int)mktime(&dateT));
 464
 465           setMessageStatus(MESSAGE_STATUS_CREATED);
 466         LoggerD("Message created successfully, msgId=" << getId());
 467     }
 468     Catch(WrtDeviceApis::Commons::PlatformException) {
 469         msg_release_struct(&m_messageData);
 470         m_messageData = NULL;
 471         LoggerE("Problem with message creation, cleaning");
 472     }
 473 }
 474
 475 void Sms::readExistingMessage()
 476 {
 477         if (getIdRef().empty() || (EMPTY_ID == getIdRef())) {
 478                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Empty id.");
 479         }
 480
 481         // release old data
 482         if (m_messageData) {
 483                 // release platform message if it was created previously
 484         msg_release_struct(&m_messageData);
 485         m_messageData = NULL;
 486         }
 487         msg_struct_t sendOpt = NULL;
 488
 489         Try {
 490                 // create new platform structure
 491                 m_messageData = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 492                 sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 493
 494                 msg_message_id_t l_id = convertId(getIdRef());
 495                 LoggerD("reading message id=" << l_id);
 496                 // trying to get message from platform
 497                 if (MSG_SUCCESS == msg_get_message(MsgGetCommonHandle(), l_id, m_messageData, sendOpt))
 498                 {
 499                         LoggerD("message found with msgId=" << getIdRef());
 500
 501                         // read all mms dat to abstraction layer
 502                         readConversationId(m_messageData);
 503                         readRecipientList(m_messageData);
 504                         readBody(m_messageData);
 505                         readFolder(m_messageData);
 506                         readDateTime(m_messageData);
 507                         readReadStatus(m_messageData);
 508                         readSize(m_messageData);
 509                         readMessageStatus(m_messageData);
 510
 511                 } else {
 512                         LoggerE("message not found with msgId=" << getIdRef());
 513                         setId("");
 514                         Throw(WrtDeviceApis::Commons::PlatformException);
 515                 }
 516
 517                 msg_release_struct(&sendOpt);
 518         }
 519         Catch(WrtDeviceApis::Commons::PlatformException) {
 520                 LoggerE("exception");
 521                 // nothing to do
 522                 msg_release_struct(&sendOpt);
 523         }
 524 }
 525
 526 void Sms::updateBody()
 527 {
 528     // check if abstraction body value has been changed
 529     if (isBodyValid()) {
 530         return;
 531     }
 532     LoggerI("updating platfoprm body");
 533
 534     // change body value in platform structure
 535     if (  getBodyRef().length() >  0)
 536     {
 537                 if (msg_set_str_value(m_messageData, MSG_MESSAGE_SMS_DATA_STR,
 538                         const_cast<char*>(getBodyRef().c_str()), getBodyRef().length()) != MSG_SUCCESS)
 539                 {
 540         LoggerE("problem with update Body");
 541         Throw(WrtDeviceApis::Commons::PlatformException);
 542         }
 543     // set flag as true - platform synchronized with abstraction
 544     setBodyValidity(true);
 545 }
 546     // set flag as true - platform synchronized with abstraction
 547 }
 548
 549 void Sms::updateTo()
 550 {
 551         // check if abstraction recipient value has been changed
 552         if (getToRecipients().isValid()) {
 553                 return;
 554         }
 555
 556         LoggerI("SMS updating platform recipients");
 557
 558         msg_struct_list_s *addr_list = NULL;
 559         msg_get_list_handle(m_messageData, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addr_list);
 560         int nToCnt = addr_list->nCount;
 561
 562         LogInfo("nToCnt size  " << nToCnt);
 563
 564         if (nToCnt > 0)
 565         {
 566                 for (int i = 0; i < nToCnt; i++) {
 567                         msg_set_str_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, (char *)"", 0);
 568                         msg_set_str_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_DISPLAYNAME_STR, (char *)"", 0);
 569                         msg_set_int_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_TYPE_INT, MSG_ADDRESS_TYPE_PLMN);
 570                         msg_set_int_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT, MSG_RECIPIENTS_TYPE_UNKNOWN);
 571                         msg_set_int_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_CONTACT_ID_INT, 0);
 572                 }
 573                 nToCnt = 0;
 574                 addr_list->nCount = nToCnt;
 575         }
 576
 577         vector<string> to = getToRecipients().getRecipients();
 578
 579         // update addresses in platform structure
 580         if (to.size())
 581         {
 582                 LoggerI("updating to");
 583                 for (size_t i = 0; i < to.size(); i++)
 584                 {
 585                         string tmpAddr = to[i];
 586                         if(validatePhoneNumber(tmpAddr))
 587                         {
 588                                 if (i >= MAX_TO_ADDRESS_CNT)
 589                                 {
 590                                         LoggerE("max number of recipient exceeded");
 591                                         break;
 592                                 }
 593                                 LoggerD("adding to[" << i << "]=" << to[i]);
 594
 595                                 msg_set_int_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_TYPE_INT, MSG_ADDRESS_TYPE_PLMN);
 596
 597                                 if (msg_set_int_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT,
 598                                 MSG_RECIPIENTS_TYPE_TO) != MSG_SUCCESS)
 599                                 {
 600                                         LoggerE("problem with adding to address");
 601                                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Problem with adding to address");
 602                                 }
 603
 604                                 if(msg_set_str_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
 605                                 const_cast<char*>(to[i].c_str()), to[i].size()) != MSG_SUCCESS)
 606                                 {
 607                                         LoggerE("problem with adding to address");
 608                                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Problem with adding to address");
 609                                 }
 610
 611                                 addr_list->nCount ++;
 612                                 LoggerD("addr_list->nCount =" << addr_list->nCount);
 613                         }
 614                         else
 615                         {
 616                                 LoggerE("wrong phone number format");
 617                                 ThrowMsg(WrtDeviceApis::Commons::PlatformException, "wrong phone number format");
 618                         }
 619                 }
 620         }
 621
 622         setToValidity(true);
 623
 624 }
 625
 626 void Sms::updateFrom()
 627 {
 628     // check if abstraction from field value has been changed
 629     if (getFromValidity()) {
 630         // do not update if not changed
 631         return;
 632     }
 633     LoggerI("updating platform from");
 634
 635     //TODO
 636
 637     // set flag as true - platform synchronized with abstraction
 638     setFromValidity(true);
 639 }
 640
 641 void Sms::updateSourceAddress()
 642 {
 643     // check if abstraction source address value has been changed
 644     if (getSourceAddressValidity()) {
 645         // do not update if not changed
 646         return;
 647     }
 648     LoggerI("updating platform source address");
 649
 650     //TODO
 651
 652     // set flag as true - platform synchronized with abstraction
 653     setSourceAddressValidity(true);
 654 }
 655
 656 void Sms::updateReadStatus()
 657 {
 658     LoggerI("updating platform read status: " << isRead());
 659     if (isReadStatusValid()) {
 660         // do not update if not changed
 661         return;
 662     }
 663     if (MSG_SUCCESS != msg_set_bool_value(m_messageData, MSG_MESSAGE_READ_BOOL, isRead())) {
 664         LoggerE("problem with setting subject");
 665         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Problem with setting subject");
 666     }
 667     setReadStatusValidity(true);
 668 }
 669
 670 void Sms::updateIsRead()
 671 {
 672     LoggerD("updating m_id=" << getIdRef());
 673
 674     if (!m_messageData) {
 675         //error if platform message not exists
 676         LoggerE("message can not be updated");
 677         Throw(WrtDeviceApis::Commons::PlatformException);
 678     }
 679
 680     // check if abstraction from m_isReadChange value has been changed
 681     if (isReadChangeStatusValid()) {
 682         // do not update if not changed
 683         return;
 684     }
 685
 686     Try
 687     {
 688         if (this->getIdRef().empty()) {
 689             LoggerE("existing msgId is zero, remove msg not done");
 690             ThrowMsg(WrtDeviceApis::Commons::PlatformException,
 691                     "existing msgId is zero, remove msg not done");
 692         }
 693
 694         if (MSG_SUCCESS !=
 695             msg_update_read_status(MsgGetCommonHandle(), convertId(getIdRef()), isReadChangeStatus()))
 696         {
 697             LoggerE("Failed to update isRead");
 698             ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Failed to update isRead");
 699         }
 700     }
 701     Catch(WrtDeviceApis::Commons::PlatformException) {
 702         LoggerE("platform error occurs");
 703     }
 704     setisReadChangeStatusValidity(true);
 705
 706 }
 707
 708 void Sms::updateMessage()
 709 {
 710         LoggerD("updating m_id=" << getIdRef());
 711         msg_error_t err = MSG_SUCCESS;
 712
 713         msg_struct_t msg = NULL;
 714         msg_struct_t sendOpt = NULL;
 715
 716         if (!m_messageData) {
 717                 //error if platform message not exists
 718                 LoggerE("message can not be updated");
 719                 Throw(WrtDeviceApis::Commons::PlatformException);
 720         }
 721
 722         Try
 723         {
 724
 725                 msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 726                 sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 727
 728                 err = msg_get_message(MsgGetCommonHandle(), convertId(getIdRef()), msg, sendOpt);
 729
 730                 if (err != MSG_SUCCESS)
 731                 {
 732                         LoggerE("Get Message Failed!");
 733                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Failed to update message");
 734                 }
 735
 736                 if (this->getIdRef().empty()) {
 737                         LoggerE("existing msgId is zero, update msg not done");
 738                         ThrowMsg(WrtDeviceApis::Commons::PlatformException,
 739                                         "existing msgId is zero, update msg not done");
 740                 }
 741
 742                 update(TRUE);
 743
 744                 if (MSG_SUCCESS != msg_update_message(MsgGetCommonHandle(), m_messageData, sendOpt))
 745                 {
 746                         LoggerE("Failed to update message");
 747                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Failed to update message");
 748                 }
 749                 msg_release_struct(&msg);
 750                 msg_release_struct(&sendOpt);
 751         }
 752         Catch(WrtDeviceApis::Commons::PlatformException) {
 753                 msg_release_struct(&msg);
 754                 msg_release_struct(&sendOpt);
 755                 LoggerE("platform error occurs");
 756         }
 757 }
 758
 759 void Sms::createSendMessage()
 760 {
 761         LoggerD("convert m_id= " << convertId(getIdRef()));
 762
 763         //prepare for add sms to draft folder
 764         if (!m_messageData) {
 765                 //error if platform message not exists
 766                 LoggerE("message can not be updated");
 767                 Throw(WrtDeviceApis::Commons::PlatformException);
 768         }
 769
 770         //update all sms data
 771         if (getCurrentFolder() == DRAFTBOX) {
 772                 LoggerD("update all sms data");
 773                 updateBody();
 774                 updateFrom();
 775                 updateTo();
 776                 updateSourceAddress();
 777         }
 778
 779         Try
 780         {
 781                 int msgId = 0;
 782 //              MSG_SENDINGOPT_S option = { false, false, false };
 783 //              option.option.smsSendOpt.bReplyPath = true;
 784                 // trying to get message from platform
 785
 786 //              const msg_folder_id_t platfromFolderId = Messaging::convertFolderToPlatform(DRAFTBOX);
 787
 788 //              msg_set_message_id(m_messageData, msgId);
 789 //              msg_set_folder_id(m_messageData, platfromFolderId);
 790 //              msg_set_network_status(m_messageData, MSG_NETWORK_NOT_SEND);
 791
 792                 setId(convertId(msgId));
 793                 setFolderType(DRAFTBOX);
 794                 setMessageStatus(MESSAGE_STATUS_DRAFT);
 795         }
 796         Catch(WrtDeviceApis::Commons::PlatformException) {
 797                 LoggerE("remove message error");
 798                 if (m_messageData) {
 799                         //releasing platform message structure
 800                         msg_release_struct(&m_messageData);
 801                         m_messageData = NULL;
 802                 }
 803                 throw;
 804         }
 805
 806 }
 807
 808
 809
 810 void Sms::addMessageToDraft()
 811 {
 812     LoggerD("convert m_id= " << convertId(getIdRef()));
 813     msg_struct_t sendOpt = NULL;
 814
 815     //prepare for add sms to draft folder
 816     if (!m_messageData) {
 817         //error if platform message not exists
 818         LoggerE("message can not be updated");
 819         Throw(WrtDeviceApis::Commons::PlatformException);
 820     }
 821
 822     //update all sms data
 823     if (getCurrentFolder() == DRAFTBOX) {
 824         LoggerD("update all sms data");
 825         updateBody();
 826         updateFrom();
 827         updateTo();
 828         updateSourceAddress();
 829     }
 830
 831     Try
 832     {
 833         sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 834         msg_set_bool_value(sendOpt, MSG_SEND_OPT_SETTING_BOOL, false);
 835         int msgId = -1;
 836 //        MSG_SENDINGOPT_S option = { false, false, false };
 837 //        option.option.smsSendOpt.bReplyPath = true;
 838         // trying to get message from platform
 839
 840 //        const msg_folder_id_t platfromFolderId = Messaging::convertFolderToPlatform(DRAFTBOX);
 841
 842 //        msg_set_message_id(m_messageData, 0);
 843 //        msg_set_folder_id(m_messageData, platfromFolderId);
 844 //        msg_set_network_status(m_messageData, MSG_NETWORK_NOT_SEND);
 845
 846         // trying to add message
 847         int ret = msg_add_message(MsgGetCommonHandle(), m_messageData, sendOpt);
 848         if (ret < MSG_SUCCESS) {
 849             LoggerE("msg_add_message failed, error code=" << ret);
 850             Throw(WrtDeviceApis::Commons::PlatformException);
 851         }
 852         else
 853         {
 854                 msgId = ret;
 855         }
 856
 857           LoggerD("Message ID : " << msgId);
 858           if (msgId < 0)
 859           {
 860                  LoggerD("Message ID is invailded ");
 861                  Throw(WrtDeviceApis::Commons::PlatformException);
 862           }
 863
 864           msg_set_int_value(m_messageData, MSG_MESSAGE_ID_INT, msgId);
 865
 866           setId(convertId(msgId));
 867         setFolderType(DRAFTBOX);
 868         setMessageStatus(MESSAGE_STATUS_DRAFT);
 869           LoggerD("Message Status " <<  getMessageStatus());
 870
 871 #if 0
 872           if ( folder_list_view.nCount )
 873                 msg_release_list_struct(&folder_list_view);
 874 #endif
 875         msg_release_struct(&sendOpt);
 876
 877     }
 878     Catch(WrtDeviceApis::Commons::PlatformException) {
 879         LoggerE("remove message error");
 880         if (m_messageData) {
 881             //releasing platform message structure
 882             msg_release_struct(&m_messageData);
 883             m_messageData = NULL;
 884             msg_release_struct(&sendOpt);
 885         }
 886         throw;
 887     }
 888
 889 }
 890
 891 void Sms::readConversationId(msg_struct_t& messageData)
 892 {
 893         int tempInt = 0;
 894         msg_get_int_value(messageData, MSG_MESSAGE_THREAD_ID_INT, &tempInt);
 895         LoggerD("conversationID : " <<tempInt);
 896         setConvId(tempInt);
 897 }
 898
 899 void Sms::readRecipientList(msg_struct_t& messageData)
 900 {
 901         std::string phoneNumber;
 902 //      int recipientCount = msg_get_address_count(messageData);
 903 //      LoggerD("Recipient count " << recipientCount);
 904
 905         msg_struct_list_s *addr_list;
 906         msg_get_list_handle(messageData, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addr_list);
 907
 908         int tempInt = 0;
 909         char strNumber[MAX_ADDRESS_VAL_LEN] = {0,};
 910
 911         int recipientCount = addr_list->nCount;
 912         LoggerD("Recipient count " << recipientCount);
 913
 914
 915         for (int i = 0; i < recipientCount; ++i)
 916 {
 917                 msg_get_int_value(messageData, MSG_MESSAGE_DIRECTION_INT, &tempInt);
 918                 int type = tempInt;
 919
 920                 if (MSG_DIRECTION_TYPE_MT == type)
 921                 {
 922                         msg_struct_t addr_info = addr_list->msg_struct_info[i];
 923                         msg_get_str_value(addr_info, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, strNumber, MAX_ADDRESS_VAL_LEN);
 924                         phoneNumber = strNumber;
 925
 926                         if (validatePhoneNumber(phoneNumber))
 927                         {
 928                                 setSourceAddress(phoneNumber);
 929                                 setFrom(phoneNumber);
 930                         }
 931                         LoggerD("MT number: " << phoneNumber);
 932             }
 933                 else if (MSG_DIRECTION_TYPE_MO == type)
 934                 {
 935                         msg_struct_t addr_info = addr_list->msg_struct_info[i];
 936                         msg_get_str_value(addr_info, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, strNumber, MAX_ADDRESS_VAL_LEN);
 937                         LoggerD("MO number: " << strNumber);
 938                         appendToRecipients(strNumber);
 939                 }
 940                 else
 941                 {
 942                         LoggerE("Wrong type of recipient");
 943                         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Wrong type of recipient");
 944         }
 945     }
 946 }
 947
 948 void Sms::readBody(msg_struct_t& messageData)
 949 {
 950     //set abstraction body value
 951     int tempInt;
 952     msg_get_int_value(messageData, MSG_MESSAGE_DATA_SIZE_INT, &tempInt);
 953     LoggerE("body Size : " <<tempInt);
 954     char msgText[tempInt+1];
 955     memset(msgText, 0, tempInt+1);
 956     msg_get_str_value(messageData, MSG_MESSAGE_SMS_DATA_STR, msgText, tempInt);
 957 //    setBody(msg_sms_get_message_body(messageData));
 958     LoggerE("body : " <<msgText);
 959     setBody(msgText);
 960 }
 961
 962 void Sms::readFolder(msg_struct_t& messageData)
 963 {
 964     int tempInt = 0;
 965     msg_get_int_value(messageData, MSG_MESSAGE_FOLDER_ID_INT, &tempInt);
 966     LoggerE("Folder : " <<tempInt);
 967
 968     switch (tempInt) {
 969     case MSG_INBOX_ID:
 970         setFolderType(INBOX);
 971         break;
 972     case MSG_OUTBOX_ID:
 973         setFolderType(OUTBOX);
 974         break;
 975     case MSG_SENTBOX_ID:
 976         setFolderType(SENTBOX);
 977         break;
 978     case MSG_DRAFT_ID:
 979         setFolderType(DRAFTBOX);
 980         break;
 981     default:
 982         LoggerE("Wrong folder id");
 983         ThrowMsg(WrtDeviceApis::Commons::PlatformException, "Unsupported folder id.");
 984     }
 985 }
 986
 987 void Sms::readMessageStatus(msg_struct_t& messageData)
 988 {
 989         int tempValue = 0;
 990         msg_get_int_value(messageData, MSG_MESSAGE_FOLDER_ID_INT, &tempValue);
 991         LoggerD("readMessageStatus folder : " << tempValue);
 992
 993         switch (tempValue) {
 994                 case MSG_INBOX_ID:
 995                         setMessageStatus(MESSAGE_STATUS_LOADED);
 996                         break;
 997                 case MSG_OUTBOX_ID:
 998                         setMessageStatus(MESSAGE_STATUS_SENDING);
 999                         break;
1000                 case MSG_SENTBOX_ID:
1001                         setMessageStatus(MESSAGE_STATUS_SENT);
1002                         break;
1003                 case MSG_DRAFT_ID:
1004                         setMessageStatus(MESSAGE_STATUS_DRAFT);
1005                         break;
1006                 default:
1007                         setMessageStatus(MESSAGE_STATUS_LOADED);
1008                         break;
1009         }
1010 }
1011
1012
1013 void Sms::readDateTime(msg_struct_t& messageData)
1014 {
1015 //  tm* time = localtime(msg_get_time(messageData));
1016 //    tm dateT = getDateTime();
1017     int tempInt = 0;
1018     msg_get_int_value(messageData, MSG_MESSAGE_DISPLAY_TIME_INT, &tempInt);
1019
1020     LoggerE("readDateTime : " <<tempInt);
1021
1022     tm* time = localtime((time_t*)&tempInt);
1023     if (!time) {
1024         LoggerE("localtime failed");
1025         Throw(WrtDeviceApis::Commons::PlatformException);
1026     }
1027     setDateTime(*time);
1028 }
1029
1030 void Sms::readReadStatus(msg_struct_t& messageData)
1031 {
1032     // get read status
1033     bool tempBool = 0;
1034     msg_get_bool_value(messageData, MSG_MESSAGE_READ_BOOL, &tempBool);
1035     LoggerE("readReadStatus : " <<tempBool);
1036     setReadStatus(tempBool);
1037 }
1038
1039 void Sms::readSize(msg_struct_t& messageData)
1040 {
1041     int tempInt;
1042     msg_get_int_value(messageData, MSG_MESSAGE_DATA_SIZE_INT, &tempInt);
1043 //    setSize(msg_get_message_body_size(messageData));
1044     LoggerE("readSize : " <<tempInt);
1045     setSize(tempInt);
1046 }
1047
1048 msg_struct_t Sms::createNewCopyOfPLatformMsg(const msg_struct_t src) const
1049 {
1050         int tempInt;
1051         bool tempBool;
1052
1053         msg_struct_t msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1054
1055         msg_get_int_value(src, MSG_MESSAGE_STORAGE_ID_INT, &tempInt);
1056         msg_set_int_value(msg, MSG_MESSAGE_STORAGE_ID_INT, tempInt);
1057
1058         msg_get_int_value(src, MSG_MESSAGE_FOLDER_ID_INT, &tempInt);
1059         msg_set_int_value(msg, MSG_MESSAGE_FOLDER_ID_INT, tempInt);
1060
1061         msg_get_int_value(src, MSG_MESSAGE_DATA_SIZE_INT, &tempInt);
1062         char tempStr[tempInt+1];
1063         memset(tempStr, 0, tempInt+1);
1064
1065         msg_get_str_value(src, MSG_MESSAGE_SMS_DATA_STR, tempStr, tempInt);
1066         msg_set_str_value(msg, MSG_MESSAGE_SMS_DATA_STR, tempStr, strlen(tempStr));
1067
1068         msg_get_int_value(src, MSG_MESSAGE_DISPLAY_TIME_INT, &tempInt);
1069         msg_set_int_value(msg, MSG_MESSAGE_DISPLAY_TIME_INT, tempInt);
1070
1071 //    msg_set_network_status(msg, msg_get_network_status(src));
1072         msg_get_int_value(src, MSG_MESSAGE_NETWORK_STATUS_INT, &tempInt);
1073         msg_set_int_value(msg, MSG_MESSAGE_NETWORK_STATUS_INT,  tempInt);
1074
1075 //    msg_set_encode_type(msg, msg_get_encode_type(src));
1076         msg_get_int_value(src, MSG_MESSAGE_ENCODE_TYPE_INT, &tempInt);
1077         msg_set_int_value(msg, MSG_MESSAGE_ENCODE_TYPE_INT,  tempInt);
1078
1079 //    msg_set_read_status(msg, msg_is_read(src));
1080         msg_get_bool_value(src, MSG_MESSAGE_READ_BOOL, &tempBool);
1081         msg_set_bool_value(msg, MSG_MESSAGE_READ_BOOL, tempBool);
1082
1083 //        msg_set_protect_status(msg, msg_is_protected(src));
1084         msg_get_bool_value(src, MSG_MESSAGE_PROTECTED_BOOL, &tempBool);
1085         msg_set_bool_value(msg, MSG_MESSAGE_PROTECTED_BOOL, tempBool);
1086
1087 //        msg_set_priority_info(msg, msg_get_priority_info(src));
1088         msg_get_int_value(src, MSG_MESSAGE_PRIORITY_INT, &tempInt);
1089         msg_set_int_value(msg, MSG_MESSAGE_PRIORITY_INT,  tempInt);
1090
1091 //        msg_set_direction_info(msg, msg_get_direction_info(src));
1092         msg_get_int_value(src, MSG_MESSAGE_DIRECTION_INT, &tempInt);
1093         msg_set_int_value(msg, MSG_MESSAGE_DIRECTION_INT,  tempInt);
1094
1095 //        msg_set_port(msg, msg_get_dest_port(src), msg_get_src_port(src));
1096         msg_get_int_value(src, MSG_MESSAGE_DEST_PORT_INT, &tempInt);
1097         msg_set_int_value(msg, MSG_MESSAGE_DEST_PORT_INT,  tempInt);
1098         msg_get_int_value(src, MSG_MESSAGE_SRC_PORT_INT, &tempInt);
1099         msg_set_int_value(msg, MSG_MESSAGE_SRC_PORT_INT,  tempInt);
1100
1101     return msg;
1102 }
1103
1104 msg_struct_t Sms::createNewCopyOfPLatformMsgWithAddressList(const msg_struct_t src) const
1105 {
1106         int tempInt;
1107         bool tempBool;
1108         msg_struct_list_s *addr_list;
1109         msg_struct_list_s *new_addr_list;
1110
1111         msg_struct_t msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1112
1113         msg_get_int_value(src, MSG_MESSAGE_STORAGE_ID_INT, &tempInt);
1114         msg_set_int_value(msg, MSG_MESSAGE_STORAGE_ID_INT, tempInt);
1115
1116         msg_get_int_value(src, MSG_MESSAGE_FOLDER_ID_INT, &tempInt);
1117         msg_set_int_value(msg, MSG_MESSAGE_FOLDER_ID_INT, tempInt);
1118
1119         msg_get_int_value(src, MSG_MESSAGE_DATA_SIZE_INT, &tempInt);
1120         char tempStr[tempInt+1];
1121         memset(tempStr, 0, tempInt+1);
1122
1123         msg_get_str_value(src, MSG_MESSAGE_SMS_DATA_STR, tempStr, tempInt);
1124         msg_set_str_value(msg, MSG_MESSAGE_SMS_DATA_STR, tempStr, strlen(tempStr));
1125
1126         msg_get_int_value(src, MSG_MESSAGE_DISPLAY_TIME_INT, &tempInt);
1127         msg_set_int_value(msg, MSG_MESSAGE_DISPLAY_TIME_INT, tempInt);
1128
1129 //    msg_set_network_status(msg, msg_get_network_status(src));
1130         msg_get_int_value(src, MSG_MESSAGE_NETWORK_STATUS_INT, &tempInt);
1131         msg_set_int_value(msg, MSG_MESSAGE_NETWORK_STATUS_INT,  tempInt);
1132
1133 //    msg_set_encode_type(msg, msg_get_encode_type(src));
1134         msg_get_int_value(src, MSG_MESSAGE_ENCODE_TYPE_INT, &tempInt);
1135         msg_set_int_value(msg, MSG_MESSAGE_ENCODE_TYPE_INT,  tempInt);
1136
1137 //    msg_set_read_status(msg, msg_is_read(src));
1138         msg_get_bool_value(src, MSG_MESSAGE_READ_BOOL, &tempBool);
1139         msg_set_bool_value(msg, MSG_MESSAGE_READ_BOOL, tempBool);
1140
1141 //        msg_set_protect_status(msg, msg_is_protected(src));
1142         msg_get_bool_value(src, MSG_MESSAGE_PROTECTED_BOOL, &tempBool);
1143         msg_set_bool_value(msg, MSG_MESSAGE_PROTECTED_BOOL, tempBool);
1144
1145 //        msg_set_priority_info(msg, msg_get_priority_info(src));
1146         msg_get_int_value(src, MSG_MESSAGE_PRIORITY_INT, &tempInt);
1147         msg_set_int_value(msg, MSG_MESSAGE_PRIORITY_INT,  tempInt);
1148
1149 //        msg_set_direction_info(msg, msg_get_direction_info(src));
1150         msg_get_int_value(src, MSG_MESSAGE_DIRECTION_INT, &tempInt);
1151         msg_set_int_value(msg, MSG_MESSAGE_DIRECTION_INT,  tempInt);
1152
1153 //        msg_set_port(msg, msg_get_dest_port(src), msg_get_src_port(src));
1154         msg_get_int_value(src, MSG_MESSAGE_DEST_PORT_INT, &tempInt);
1155         msg_set_int_value(msg, MSG_MESSAGE_DEST_PORT_INT,  tempInt);
1156         msg_get_int_value(src, MSG_MESSAGE_SRC_PORT_INT, &tempInt);
1157         msg_set_int_value(msg, MSG_MESSAGE_SRC_PORT_INT,  tempInt);
1158
1159 // copy addr list
1160         msg_get_list_handle(src, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addr_list);
1161         msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&new_addr_list);
1162
1163         new_addr_list->nCount = addr_list->nCount;
1164
1165         for(int i=0; i<addr_list->nCount; i++)
1166         {
1167                 msg_struct_t addr_info = NULL;
1168                 msg_struct_t new_addr_info = NULL;
1169                 char addr_value[MAX_ADDRESS_VAL_LEN] = {0,};
1170
1171                 //get original address
1172                 addr_info = addr_list->msg_struct_info[i];
1173                 msg_get_str_value(addr_info, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, addr_value, MAX_ADDRESS_VAL_LEN);
1174                 msg_get_int_value(addr_info, MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT, &tempInt);
1175
1176                 //copy original address
1177                 new_addr_info = new_addr_list->msg_struct_info[i];
1178                 msg_set_str_value(new_addr_info, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, addr_value, MAX_ADDRESS_VAL_LEN);
1179                 msg_set_int_value(new_addr_info, MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT, tempInt);
1180         }
1181
1182     return msg;
1183 }
1184
1185 }
1186 }