src/FMsg_SmsManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 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  * @file                FMsg_SmsManagerImpl.cpp
  19  * @brief               This is the implementation file for the %_SmsManagerImpl class.
  20  *
  21  * This file contains the implementation of the %_SmsManagerImpl class.
  22  */
  23
  24 // OAF headers
  25 #include <unique_ptr.h>
  26 #include <msg.h>
  27 #include <msg_transport.h>
  28 #include <msg_storage.h>
  29 #include <dbus/dbus.h>
  30 #include <email-api.h>
  31 #include <FMsgSmsManager.h>
  32 #include <FBaseSysLog.h>
  33 #include <FBase_StringConverter.h>
  34 #include "FMsg_SmsManagerImpl.h"
  35 #include "FMsg_SmsMessageImpl.h"
  36 #include "FMsg_SmsEvent.h"
  37 #include "FMsg_MsgUtil.h"
  38 #include "FMsg_RecipientListImpl.h"
  39 #include "FMsg_SmsMmsCallbackHandler.h"
  40 #include "FMsg_CbsChannelImpl.h"
  41
  42 using namespace std;
  43 using namespace Tizen::Base;
  44 using namespace Tizen::Messaging;
  45 using namespace Tizen::Base::Collection;
  46
  47 namespace Tizen { namespace Messaging
  48 {
  49
  50 _SmsManagerImpl::_SmsManagerImpl(void)
  51         : __isConstructed(false)
  52         , __isCbsSaveEnabled(true)
  53         , __pSmsEvent(null)
  54         , __pSmsReceiveEvent(null)
  55         , __pCbsReceiveEvent(null)
  56         , __pEtwsReceiveEvent(null)
  57         , __pSmsTriggerEventList(null)
  58         , __msgHandle(0)
  59         , __cbsSettingsHandle(0)
  60         , __pCbsListener(null)
  61         , __pEtwsListener(null)
  62 {
  63 }
  64
  65 _SmsManagerImpl::~_SmsManagerImpl(void)
  66 {
  67
  68         if (__pSmsReceiveEvent)
  69         {
  70                 delete __pSmsReceiveEvent;
  71                 __pSmsReceiveEvent = null;
  72         }
  73
  74         if (__pCbsReceiveEvent)
  75         {
  76                 delete __pCbsReceiveEvent;
  77                 __pCbsReceiveEvent = null;
  78         }
  79
  80         if (__pEtwsReceiveEvent)
  81         {
  82                 delete __pEtwsReceiveEvent;
  83                 __pEtwsReceiveEvent = null;
  84         }
  85
  86         if (__pSmsTriggerEventList)
  87         {
  88                 if (__pSmsTriggerEventList->GetCount() > 0)
  89                 {
  90                         __pSmsTriggerEventList->RemoveAll(true);
  91                 }
  92                 delete __pSmsTriggerEventList;
  93                 __pSmsTriggerEventList = null;
  94         }
  95
  96         if (_SmsMmsCallbackHandler::GetInstance())
  97         {
  98                 _SmsMmsCallbackHandler::GetInstance()->CloseMessageHandle();
  99                 _SmsMmsCallbackHandler::GetInstance()->CloseCbsSettingsHandle();
 100         }
 101
 102         __isConstructed = false;
 103 }
 104
 105 result
 106 _SmsManagerImpl::Construct(const ISmsListener& listener)
 107 {
 108         // method return code
 109         result r = E_SUCCESS;
 110         int err = MSG_SUCCESS;
 111
 112         SysAssertf(__isConstructed == false, "_SmsManagerImpl instance is already constructed.");
 113
 114         // set event
 115         unique_ptr<_SmsEvent> pSmsEvent(new (std::nothrow) _SmsEvent());
 116         SysTryReturn(NID_MSG, pSmsEvent != null, E_OUT_OF_MEMORY, r = E_OUT_OF_MEMORY, "memory allocation failed.");
 117
 118         // event construction
 119         r = pSmsEvent->Construct(_SMS_EVENT_TYPE_SMS_SEND_RESULT);
 120         SysTryReturn(NID_MSG, r == E_SUCCESS, r, r, "Failed to construct an instance");
 121
 122         // add listener
 123         r = pSmsEvent->AddListener(listener, true);
 124         SysTryReturn(NID_MSG, r == E_SUCCESS, r, r, "Failed to add a listener");
 125
 126         SysTryReturnResult(NID_MSG, _SmsMmsCallbackHandler::GetInstance() != NULL, E_SYSTEM, "Failed to constructSmsMmsCallbackHandler.");
 127
 128         // open message handle
 129         err = _SmsMmsCallbackHandler::GetInstance()->OpenMessageHandle(__msgHandle);
 130         SysLog(NID_MSG, "value of __msgHandle is [%d]", __msgHandle);
 131
 132         r = ConvertException(err);
 133         SysTryReturn(NID_MSG, r == E_SUCCESS, r, r, "Failed to open messageHandle.");
 134
 135         // check value of msg handle
 136         SysTryReturnResult(NID_MSG, __msgHandle > 0, E_SYSTEM, "msgHandle is invalid.");
 137
 138         // register sent status callback
 139         err = _SmsMmsCallbackHandler::GetInstance()->RegisterMessageCallback();
 140
 141         r = ConvertException(err);
 142         SysTryReturn(NID_MSG, r == E_SUCCESS, r, r, "Failed to register sms,mms callback.");
 143
 144         // open cbs message handle
 145         err = _SmsMmsCallbackHandler::GetInstance()->OpenCbsSettingsHandle(__cbsSettingsHandle);
 146
 147         if (err == MSG_ERR_NO_SIM)
 148         {
 149                 r = E_SUCCESS;
 150                 SysLog(NID_MSG, "Sim card is not present in device"); // even no sim, return sucess so that app will launch sucess
 151         }
 152         else
 153         {
 154                 r = ConvertException(err);
 155                 SysTryReturn(NID_MSG, r == E_SUCCESS, r, r, "Failed to open cbs Settings Handle");
 156
 157                 // check value of cbs settings handle
 158                 SysTryReturnResult(NID_MSG, __cbsSettingsHandle > 0, E_SYSTEM, "cbsSettingsHandle is invalid.");
 159         }
 160
 161         // load cbs settings
 162         r = _SmsMmsCallbackHandler::GetInstance()->LoadCbsSettings();
 163         SysTryReturn(NID_MSG, r == E_SUCCESS, r, r, "Failed to load cbs message settings.");
 164
 165         __pSmsEvent = move(pSmsEvent);
 166         __isConstructed = true;
 167
 168         return r;
 169 }
 170
 171 result
 172 _SmsManagerImpl::AddSmsEventListener(int port, ISmsEventListener& eventListener)
 173 {
 174         // checking conditions
 175         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 176         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 177
 178         result r = E_SUCCESS;
 179         _SmsEvent* pSmsTriggerEvent = null;
 180         int err = MSG_SUCCESS;
 181
 182         // check duplications
 183         if (__pSmsTriggerEventList)
 184         {
 185                 int listSize = __pSmsTriggerEventList->GetCount();
 186                 for (int i = 0; i < listSize; i++)
 187                 {
 188                         _SmsEvent* pItem = static_cast <_SmsEvent*>(__pSmsTriggerEventList->GetAt(i));
 189                         if (pItem->GetPort() == port)
 190                         {
 191                                 r = E_OBJ_ALREADY_EXIST;
 192                                 SysLogException(NID_MSG, r, "[%s] The specific port [%d] is already registered.", GetErrorMessage(r), port);
 193                                 goto CATCH;
 194                         }
 195                 }
 196         }
 197
 198         // make an sms trigger event
 199         pSmsTriggerEvent = new (std::nothrow) _SmsEvent();
 200         SysTryReturn(NID_MSG, pSmsTriggerEvent != null, E_OUT_OF_MEMORY, r = E_OUT_OF_MEMORY, "memory allocation failed");
 201
 202         // construct an sms trigger event
 203         r = pSmsTriggerEvent->Construct(port);
 204         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] Failed to construct an instance.", GetErrorMessage(r));
 205
 206         // add corresponding listener to the event
 207         r = pSmsTriggerEvent->AddListener(eventListener, true);
 208         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] Failed to add a listener.", GetErrorMessage(r));
 209
 210         // make a list for events
 211         if (!__pSmsTriggerEventList)
 212         {
 213                 __pSmsTriggerEventList = new (std::nothrow) ArrayList();
 214                 SysTryReturnResult(NID_MSG, __pSmsTriggerEventList != null, E_OUT_OF_MEMORY, "memory allocation failed.");
 215
 216                 r = __pSmsTriggerEventList->Construct();
 217                 SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] Failed to construct an instance.", GetErrorMessage(r));
 218         }
 219         // add an event to the list
 220         r = __pSmsTriggerEventList->Add(*pSmsTriggerEvent);
 221         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] Failed to add a listener.", GetErrorMessage(r));
 222
 223         // Register SMS Trigger
 224         err = msg_reg_sms_message_callback(__msgHandle, &_SmsMmsCallbackHandler::IncomingSmsMessageCallback, port, (void*) pSmsTriggerEvent);
 225
 226         if (err != MSG_SUCCESS)
 227         {
 228                 r = __pSmsTriggerEventList->Remove(*pSmsTriggerEvent);
 229                 r = E_SYSTEM;
 230                 SysLogException(NID_MSG, r, "[%s] Failed to register for incoming sms callback.", GetErrorMessage(r));
 231
 232                 goto CATCH;
 233         }
 234
 235         return r;
 236
 237 CATCH:
 238         if (pSmsTriggerEvent)
 239         {
 240                 delete pSmsTriggerEvent;
 241         }
 242
 243         return r;
 244 }
 245
 246 result
 247 _SmsManagerImpl::RemoveSmsEventListener(int port, ISmsEventListener& eventListener)
 248 {
 249         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 250         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 251
 252         result r = E_SUCCESS;
 253         int index = -1;
 254         int listSize = -1;
 255         bool isFound = false;
 256
 257         // find the SmsTriggerEvent using port
 258         if (__pSmsTriggerEventList)
 259         {
 260                 listSize = __pSmsTriggerEventList->GetCount();
 261                 for (int i = 0; i < listSize; i++)
 262                 {
 263                         _SmsEvent* pItem = static_cast <_SmsEvent*>(__pSmsTriggerEventList->GetAt(i));
 264                         if (pItem->GetPort() == port)
 265                         {
 266                                 index = i;
 267                                 isFound = true;
 268                                 break;
 269                         }
 270                 }
 271         }
 272
 273         // if not found..
 274         SysTryReturn(NID_MSG, isFound, E_OBJ_NOT_FOUND, r = E_OBJ_NOT_FOUND, "Failed to find the SMS event listener");
 275
 276         // remove corresponding event from the list
 277         r = __pSmsTriggerEventList->RemoveAt(index, true);
 278         SysTryReturn(NID_MSG, r == E_SUCCESS, r, r, "Failed to remove the event listener");
 279
 280         return r;
 281 }
 282
 283 result
 284 _SmsManagerImpl::AddSmsMessageEventListener(const ISmsMessageEventListener& eventListener)
 285 {
 286         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 287         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 288
 289         result r = E_SUCCESS;
 290         int err = MSG_SUCCESS;
 291
 292         // set event
 293         if (!__pSmsReceiveEvent)
 294         {
 295                 __pSmsReceiveEvent = new (std::nothrow) _SmsEvent();
 296                 SysTryReturn(NID_MSG, __pSmsReceiveEvent != null, E_OUT_OF_MEMORY, r = E_OUT_OF_MEMORY, "memory allocation failed");
 297
 298                 r = __pSmsReceiveEvent->Construct(_SMS_EVENT_TYPE_SMS_RECEIVE_RESULT);
 299                 SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "Failed to construct an instance");
 300         }
 301
 302         // add listener
 303         r = __pSmsReceiveEvent->AddListener(eventListener, true);
 304         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "Failed to add a listener");
 305
 306         err = msg_reg_sms_message_callback(__msgHandle, &_SmsMmsCallbackHandler::IncomingSmsMessageCallback, 0, (void*)
 307                                                 __pSmsReceiveEvent);
 308
 309         r = ConvertException(err);
 310         SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to register for incoming sms callback.", GetErrorMessage(r));
 311
 312         if (_SmsMmsCallbackHandler::GetInstance())
 313         {
 314                 _SmsMmsCallbackHandler::GetInstance()->SetInComingSmsCallback(true);
 315         }
 316
 317         return E_SUCCESS;
 318
 319 CATCH:
 320         if (__pSmsReceiveEvent)
 321         {
 322                 delete __pSmsReceiveEvent;
 323                 __pSmsReceiveEvent = null;
 324         }
 325
 326         return r;
 327 }
 328
 329 result
 330 _SmsManagerImpl::RemoveSmsMessageEventListener(const ISmsMessageEventListener& eventListener)
 331 {
 332         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 333         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 334
 335         result r = E_SUCCESS;
 336
 337         SysTryReturnResult(NID_MSG, __pSmsReceiveEvent != NULL, E_OBJ_NOT_FOUND, "Failed to remove a listener");
 338
 339         r = __pSmsReceiveEvent->RemoveListener(eventListener);
 340         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] Failed to remove a listener..", GetErrorMessage(r));
 341
 342         if (_SmsMmsCallbackHandler::GetInstance())
 343         {
 344                 _SmsMmsCallbackHandler::GetInstance()->SetInComingSmsCallback(false);
 345         }
 346
 347         if (__pSmsReceiveEvent)
 348         {
 349                 delete __pSmsReceiveEvent;
 350                 __pSmsReceiveEvent = null;
 351         }
 352
 353         return r;
 354
 355 CATCH:
 356         return r;
 357 }
 358
 359 int
 360 _SmsManagerImpl::GetTotalMessageCount(SmsMessageBoxType type) const
 361 {
 362         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 363         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 364
 365         int msgCount = 0;
 366         msg_struct_t countInfo = NULL;
 367         int err = MSG_SUCCESS;
 368         _MSG_FOLDER_ID_E folderType = MSG_ALLBOX_ID;
 369         result r = E_SUCCESS;
 370
 371         ClearLastResult();
 372
 373         switch (type)
 374         {
 375         case SMS_MESSAGE_BOX_TYPE_INBOX:
 376                 folderType = MSG_INBOX_ID;
 377                 break;
 378         case SMS_MESSAGE_BOX_TYPE_SENTBOX:
 379                 folderType = MSG_SENTBOX_ID;
 380                 break;
 381         case SMS_MESSAGE_BOX_TYPE_OUTBOX:
 382                 folderType = MSG_OUTBOX_ID;
 383                 break;
 384         case SMS_MESSAGE_BOX_TYPE_ALL:
 385         {
 386                 err = msg_count_msg_by_type(__msgHandle, MSG_TYPE_SMS, &msgCount);
 387
 388                 if (err != MSG_SUCCESS)
 389                 {
 390                         r = ConvertException(err);
 391                         SysLogException(NID_MSG, r, "[%s] Failed to get the message count", GetErrorMessage(r));
 392                         SetLastResult(r);
 393                         return -1;
 394                 }
 395
 396                 SysLog(NID_MSG, "Total count of messages is [%d]", msgCount);
 397                 return msgCount;
 398         }
 399                 break;
 400         case SMS_MESSAGE_BOX_TYPE_NONE: // impossible case
 401                 break;
 402         default:
 403                 break;
 404         }
 405
 406         // get the count of corresponding message box
 407         countInfo = msg_create_struct(MSG_STRUCT_COUNT_INFO);
 408         err = msg_count_message(__msgHandle, folderType, countInfo);
 409
 410         if (err != MSG_SUCCESS)
 411         {
 412                 r = ConvertException(err);
 413                 SysLogException(NID_MSG, r, "[%s] Failed to get the message count of the message box (%d)", GetErrorMessage(r), (int) type);
 414                 msg_release_struct(&countInfo);
 415                 SetLastResult(r);
 416                 return -1;
 417         }
 418
 419         msg_get_int_value(countInfo, MSG_COUNT_INFO_SMS_INT, &msgCount);
 420         msg_release_struct(&countInfo);
 421         SysLog(NID_MSG, "Total count of messages is [%d]", msgCount);
 422
 423         return msgCount;
 424 }
 425
 426 Tizen::Base::Collection::IList*
 427 _SmsManagerImpl::SearchInboxN(const Tizen::Base::String* pKeyword, const Tizen::Base::String* pSenderAddress, int startIndex,
 428                                                           int count,
 429                                                           int& totalResultCount) const
 430 {
 431         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 432         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 433
 434         char* pSearchString = NULL;
 435         char* pSenderAddressTemp = NULL;
 436         ArrayList* pList = null;
 437         int err = MSG_SUCCESS;
 438         result r = E_SUCCESS;
 439         msg_struct_list_s msgList;
 440         msg_struct_t searchCon = NULL;
 441
 442         ClearLastResult();
 443
 444         pList = new (std::nothrow) ArrayList();
 445         SysTryCatch(NID_MSG, pList != null, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
 446
 447         // make a list
 448         r = pList->Construct();
 449         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "Failed to construct an ArrayList");
 450
 451         // Set Condition
 452         searchCon = msg_create_struct(MSG_STRUCT_SEARCH_CONDITION);
 453         msg_set_int_value(searchCon, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_INBOX_ID);
 454         msg_set_int_value(searchCon, MSG_SEARCH_CONDITION_MSGTYPE_INT, MSG_TYPE_SMS);
 455
 456         // keyword
 457         if (pKeyword)
 458         {
 459                 pSearchString = _StringConverter::CopyToCharArrayN(*pKeyword);
 460                 SysTryCatch(NID_MSG, pSearchString != null, r = E_OUT_OF_MEMORY, r, "Memory allocation failed.");
 461                 msg_set_str_value(searchCon, MSG_SEARCH_CONDITION_SEARCH_VALUE_STR, pSearchString, strlen(pSearchString));
 462         }
 463
 464         // sender address
 465         if (pSenderAddress)
 466         {
 467                 pSenderAddressTemp = _StringConverter::CopyToCharArrayN(*pSenderAddress);
 468                 SysTryCatch(NID_MSG, pSenderAddressTemp != null, r = E_OUT_OF_MEMORY, r, "Memory allocation failed.");
 469                 msg_set_str_value(searchCon, MSG_SEARCH_CONDITION_ADDRESS_VALUE_STR, pSenderAddressTemp, strlen(pSenderAddressTemp));
 470         }
 471
 472         // Search
 473         err = msg_search_message(__msgHandle, searchCon, startIndex, count, &msgList);
 474
 475         r = ConvertException(err);
 476         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] msg_search_message call failed.", GetErrorMessage(r));
 477
 478         totalResultCount = msgList.nCount;
 479
 480         SysLog(NID_MSG, "Total Search count of messages is [%d]", totalResultCount);
 481
 482         for (int index = 0; index < totalResultCount; index++)
 483         {
 484                 // get SmsMessage instance
 485                 SmsMessage* pSmsMessage = _MsgUtil::ConvertSmsMessageN(SMS_MESSAGE_BOX_TYPE_INBOX, msgList.msg_struct_info[index]);
 486                 // add to the list
 487                 pList->Add(*pSmsMessage);
 488         }
 489
 490         if (pSearchString)
 491         {
 492                 delete[] pSearchString;
 493                 pSearchString = NULL;
 494         }
 495
 496         if (pSenderAddressTemp)
 497         {
 498                 delete[] pSenderAddressTemp;
 499                 pSenderAddressTemp = NULL;
 500         }
 501
 502         msg_release_struct(&searchCon);
 503         msg_release_list_struct(&msgList);
 504
 505         return pList;
 506
 507 CATCH:
 508         if (pSearchString)
 509         {
 510                 delete[] pSearchString;
 511                 pSearchString = NULL;
 512         }
 513
 514         if (pSenderAddressTemp)
 515         {
 516                 delete[] pSenderAddressTemp;
 517                 pSenderAddressTemp = NULL;
 518         }
 519
 520         if (pList)
 521         {
 522                 if (pList->GetCount() > 0)
 523                 {
 524                         pList->RemoveAll(true);
 525                 }
 526                 delete pList;
 527                 pList = null;
 528         }
 529
 530         msg_release_struct(&searchCon);
 531         msg_release_list_struct(&msgList);
 532
 533         return null;
 534 }
 535
 536 Tizen::Base::Collection::IList*
 537 _SmsManagerImpl::SearchMessageBoxN(SmsMessageBoxType type, const Tizen::Base::String* pKeyword, int startIndex, int count,
 538                                                                    int& totalResultCount) const
 539 {
 540         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 541         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 542
 543         result r = E_SUCCESS;
 544         int err = MSG_SUCCESS;
 545         char* pSearchString = NULL;
 546         int folderId = MSG_ALLBOX_ID;
 547         ArrayList* pList = NULL;
 548         msg_struct_list_s msgList;
 549         msg_struct_t searchCon = NULL;
 550
 551         ClearLastResult();
 552
 553         pList = new (std::nothrow) ArrayList();
 554         SysTryCatch(NID_MSG, pList != null, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
 555
 556         // make a list
 557         r = pList->Construct();
 558         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "Failed to construct an ArrayList");
 559
 560         // type
 561         folderId = _MsgUtil::GetMsgFolderId(type);
 562
 563         // Set Condition
 564         searchCon = msg_create_struct(MSG_STRUCT_SEARCH_CONDITION);
 565         msg_set_int_value(searchCon, MSG_SEARCH_CONDITION_FOLDERID_INT, folderId);
 566         msg_set_int_value(searchCon, MSG_SEARCH_CONDITION_MSGTYPE_INT, MSG_TYPE_SMS);
 567
 568         // keyword
 569         if (pKeyword)
 570         {
 571                 pSearchString = _StringConverter::CopyToCharArrayN(*pKeyword);
 572                 SysTryCatch(NID_MSG, pSearchString != null, r = E_OUT_OF_MEMORY, r, "Memory allocation failed.");
 573                 msg_set_str_value(searchCon, MSG_SEARCH_CONDITION_SEARCH_VALUE_STR, pSearchString, strlen(pSearchString));
 574         }
 575
 576         // Search
 577         err = msg_search_message(__msgHandle, searchCon, startIndex, count, &msgList);
 578
 579         r = ConvertException(err);
 580         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] msg_search_message call failed.", GetErrorMessage(r));
 581
 582         totalResultCount = msgList.nCount;
 583
 584         SysLog(NID_MSG, "Total Search count of messages is [%d]", totalResultCount);
 585
 586         for (int index = 0; index < totalResultCount; index++)
 587         {
 588                 SmsMessage* pSmsMessage = null;
 589
 590                 if (type == SMS_MESSAGE_BOX_TYPE_ALL)
 591                 {
 592                         err = msg_get_int_value(msgList.msg_struct_info[index], MSG_MESSAGE_FOLDER_ID_INT, &folderId);
 593
 594                         switch (folderId)
 595                         {
 596                         case MSG_INBOX_ID:
 597                                 pSmsMessage = _MsgUtil::ConvertSmsMessageN(SMS_MESSAGE_BOX_TYPE_INBOX, msgList.msg_struct_info[index]);
 598                                 break;
 599
 600                         case MSG_OUTBOX_ID:
 601                                 pSmsMessage = _MsgUtil::ConvertSmsMessageN(SMS_MESSAGE_BOX_TYPE_OUTBOX, msgList.msg_struct_info[index]);
 602                                 break;
 603
 604                         case MSG_SENTBOX_ID:
 605                                 pSmsMessage = _MsgUtil::ConvertSmsMessageN(SMS_MESSAGE_BOX_TYPE_SENTBOX, msgList.msg_struct_info[index]);
 606                                 break;
 607
 608                         case MSG_DRAFT_ID:
 609                                 //pSmsMessage = _MsgUtil::ConvertSmsMessageN(SMS_MESSAGE_BOX_TYPE_SENTBOX, msgList.msg_struct_info[index]);
 610                                 break;
 611
 612                         case MSG_ALLBOX_ID:
 613                                 //pSmsMessage = _MsgUtil::ConvertSmsMessageN(SMS_MESSAGE_BOX_TYPE_SENTBOX, msgList.msg_struct_info[index]);
 614                                 break;
 615                         }
 616
 617                         // add the item to the list
 618                         pList->Add(*pSmsMessage);
 619                 }
 620                 else
 621                 {
 622                         pSmsMessage = _MsgUtil::ConvertSmsMessageN(type, msgList.msg_struct_info[index]);
 623                         pList->Add(*pSmsMessage);
 624                 }
 625         }
 626
 627         if (pSearchString)
 628         {
 629                 delete[] pSearchString;
 630                 pSearchString = NULL;
 631         }
 632
 633         msg_release_struct(&searchCon);
 634         msg_release_list_struct(&msgList);
 635
 636         return pList;
 637
 638 CATCH:
 639         if (pList)
 640         {
 641                 if (pList->GetCount() > 0)
 642                 {
 643                         pList->RemoveAll(true);
 644                 }
 645                 delete pList;
 646                 pList = null;
 647         }
 648
 649         if (pSearchString)
 650         {
 651                 delete[] pSearchString;
 652                 pSearchString = NULL;
 653         }
 654
 655         msg_release_struct(&searchCon);
 656         msg_release_list_struct(&msgList);
 657
 658         return null;
 659 }
 660
 661 Tizen::Base::String
 662 _SmsManagerImpl::GetFullText(int messageId) const
 663 {
 664         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 665         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 666
 667         result r = E_SUCCESS;
 668         String fullText;
 669         msg_struct_t smsMsg = null;
 670         msg_struct_t sendOpt = null;
 671         int err = MSG_SUCCESS;
 672         char msgText[MAX_MSG_TEXT_LEN];
 673
 674         ClearLastResult();
 675
 676         // get SMS message
 677         smsMsg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 678         sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 679         err = msg_get_message(__msgHandle, messageId, smsMsg, sendOpt);
 680
 681         r = ConvertException(err);
 682         SetLastResult(r);
 683
 684         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] msg_get_message by messageid failed.", GetErrorMessage(r));
 685
 686         // get text
 687         err = msg_get_str_value(smsMsg, MSG_MESSAGE_SMS_DATA_STR, msgText, MAX_MSG_TEXT_LEN);
 688         SysTryCatch(NID_MSG, err == MSG_SUCCESS, r = E_SYSTEM, r, "sms get message body failed");
 689
 690         fullText = msgText;
 691
 692         SysLog(NID_MSG, "Returned Full Text : [%ls]", fullText.GetPointer());
 693
 694         msg_release_struct(&sendOpt);
 695         msg_release_struct(&smsMsg);
 696
 697         return fullText;
 698
 699 CATCH:
 700         msg_release_struct(&sendOpt);
 701         msg_release_struct(&smsMsg);
 702
 703         return L"";
 704 }
 705
 706 result
 707 _SmsManagerImpl::Send(const SmsMessage& message, const RecipientList& recipientList, bool saveToSentbox)
 708 {
 709         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 710         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 711
 712         result r = E_SUCCESS;
 713         int err = MSG_SUCCESS;
 714         int msgReqId = -1;
 715         bool saveMsgToSentbox = saveToSentbox;
 716
 717         SysLog(NID_MSG, "sending an sms message");
 718
 719         msg_struct_t msgReq = msg_create_struct(MSG_STRUCT_REQUEST_INFO);
 720         msg_struct_t msgInfo = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);;
 721         msg_struct_t msgSendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 722
 723         msg_set_bool_value(msgSendOpt, MSG_SEND_OPT_SETTING_BOOL, true);
 724         msg_set_bool_value(msgSendOpt, MSG_SEND_OPT_DELIVER_REQ_BOOL, false);
 725         msg_set_bool_value(msgSendOpt, MSG_SEND_OPT_KEEPCOPY_BOOL, saveMsgToSentbox);
 726
 727         err = _MsgUtil::GetSmsMessage(msgInfo, message, recipientList);
 728
 729         r = ConvertException(err);
 730         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] Failed to generate the SMS message.", GetErrorMessage(r));
 731
 732         msg_set_struct_handle(msgReq, MSG_REQUEST_MESSAGE_HND, msgInfo);
 733         msg_set_struct_handle(msgReq, MSG_REQUEST_SENDOPT_HND, msgSendOpt);
 734
 735         if (err == MSG_SUCCESS)
 736         {
 737                 err = msg_sms_send_message(__msgHandle, msgReq);
 738         }
 739
 740         r = ConvertException(err);
 741
 742         if (r == E_SUCCESS)
 743         {
 744                 if (_SmsMmsCallbackHandler::GetInstance())
 745                 {
 746                         msg_get_int_value(msgReq, MSG_REQUEST_REQUESTID_INT, &msgReqId);
 747                         r = _SmsMmsCallbackHandler::GetInstance()->AddToMessageMap(msgReqId, _MSG_SMS, __pSmsEvent.get());
 748                 }
 749                 else
 750                 {
 751                         r = E_SYSTEM;
 752                 }
 753         }
 754
 755         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] Failed to send the SMS message.", GetErrorMessage(r));
 756
 757         //release message
 758         msg_release_struct(&msgReq);
 759         SysLog(NID_MSG, "sending an sms message success");
 760         return r;
 761
 762 CATCH:
 763         //release message
 764         msg_release_struct(&msgReq);
 765         return r;
 766 }
 767
 768 result
 769 _SmsManagerImpl::SetCbsMessageEventListener(ICbsMessageEventListener* pListener)
 770 {
 771         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 772         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 773
 774         result r = E_SUCCESS;
 775         int err = MSG_SUCCESS;
 776
 777         if (!pListener)
 778         {
 779                 if (__pCbsReceiveEvent)
 780                 {
 781                         r = __pCbsReceiveEvent->RemoveListener(*__pCbsListener);
 782                         SysTryReturnResult(NID_MSG, r == E_SUCCESS, E_SYSTEM, "Failed to reset the cbs message event listener.");
 783
 784                         __pCbsListener = null;
 785                 }
 786                 return r;
 787         }
 788
 789         // set listener
 790         __pCbsListener = pListener;
 791
 792         // set event
 793         if (!__pCbsReceiveEvent)
 794         {
 795                 __pCbsReceiveEvent = new (std::nothrow) _SmsEvent();
 796                 SysTryCatch(NID_MSG, __pCbsReceiveEvent != null, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
 797
 798                 r = __pCbsReceiveEvent->Construct(_SMS_EVENT_TYPE_CBS_RECEIVE_RESULT);
 799                 SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Failed to construct an cbs listener instance");
 800         }
 801
 802         // add listener
 803         r = __pCbsReceiveEvent->AddListener(*__pCbsListener, true);
 804         SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Failed to add cbs listner");
 805
 806         err = msg_reg_cb_message_callback(__msgHandle, &_SmsMmsCallbackHandler::IncomingCbsMessageCallback, __isCbsSaveEnabled, null);
 807         r = ConvertException(err);
 808         SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Failed to set cbs incoming callback");
 809
 810         if (r == E_SUCCESS)
 811         {
 812                 if (_SmsMmsCallbackHandler::GetInstance())
 813                 {
 814                         _SmsMmsCallbackHandler::GetInstance()->SetCbsAndEtwsUserEvent(_MSG_CBS, __pCbsReceiveEvent);
 815                 }
 816                 else
 817                 {
 818                         r = E_SYSTEM;
 819                 }
 820         }
 821
 822         return r;
 823
 824 CATCH:
 825         if (__pCbsReceiveEvent)
 826         {
 827                 delete __pCbsReceiveEvent;
 828                 __pCbsReceiveEvent = null;
 829         }
 830         __pCbsListener = null;
 831
 832         return r;
 833 }
 834
 835 result
 836 _SmsManagerImpl::SetEtwsPrimaryNotificationEventListener(IEtwsPrimaryNotificationEventListener* pListener)
 837 {
 838         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 839         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 840
 841         result r = E_SUCCESS;
 842         int err = MSG_SUCCESS;
 843
 844         if (!pListener)
 845         {
 846                 if (__pEtwsReceiveEvent)
 847                 {
 848                         r = __pEtwsReceiveEvent->RemoveListener(*__pEtwsListener);
 849                         SysTryReturnResult(NID_MSG, r == E_SUCCESS, E_SYSTEM, "Failed to reset the etws primary notification event listener.");
 850
 851                         __pEtwsListener = null;
 852                 }
 853                 return r;
 854         }
 855
 856         // set listener
 857         __pEtwsListener = pListener;
 858
 859         // set event
 860         if (!__pEtwsReceiveEvent)
 861         {
 862                 __pEtwsReceiveEvent = new (std::nothrow) _SmsEvent();
 863                 SysTryCatch(NID_MSG, __pEtwsReceiveEvent != null, r = E_OUT_OF_MEMORY, r, "memory allocation failed");
 864
 865                 r = __pEtwsReceiveEvent->Construct(_SMS_EVENT_TYPE_ETWS_RECEIVE_RESULT);
 866                 SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM,
 867                                 "Failed to construct an etws primary notification event listener instance");
 868         }
 869
 870         // add listener
 871         r = __pEtwsReceiveEvent->AddListener(*__pEtwsListener, true);
 872         SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Failed to add an etws primary notification event listener.");
 873
 874         err = msg_reg_cb_message_callback(__msgHandle, &_SmsMmsCallbackHandler::IncomingCbsMessageCallback, __isCbsSaveEnabled, null);
 875         r = ConvertException(err);
 876         SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM,"Failed to add an etws primary notification event listener.");
 877
 878         if (r == E_SUCCESS)
 879         {
 880                 if (_SmsMmsCallbackHandler::GetInstance())
 881                 {
 882                        _SmsMmsCallbackHandler::GetInstance()->SetCbsAndEtwsUserEvent(_MSG_ETWS, __pEtwsReceiveEvent);
 883                 }
 884                 else
 885                 {
 886                         r = E_SYSTEM;
 887                 }
 888         }
 889
 890         return r;
 891
 892 CATCH:
 893         if (__pEtwsReceiveEvent)
 894         {
 895                 delete __pEtwsReceiveEvent;
 896                 __pEtwsReceiveEvent = null;
 897         }
 898         __pEtwsListener = null;
 899
 900         return r;
 901 }
 902
 903 result
 904 _SmsManagerImpl::SetSavingToCbsBoxEnabled(bool enable)
 905 {
 906         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 907         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 908         SysTryReturnResult(NID_MSG, __cbsSettingsHandle != NULL, E_SYSTEM, "Cb handle is null");
 909
 910         int err = MSG_SUCCESS;
 911
 912         err = msg_reg_cb_message_callback(__msgHandle, &_SmsMmsCallbackHandler::IncomingCbsMessageCallback, enable, null);
 913         SysTryReturnResult(NID_MSG, err == MSG_SUCCESS, E_SYSTEM, "Failed to set SavingToCbsBoxEnabled option.");
 914
 915         __isCbsSaveEnabled = enable;
 916
 917         return E_SUCCESS;
 918 }
 919
 920 bool
 921 _SmsManagerImpl::IsCbsEnabled(void) const
 922 {
 923         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 924         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 925         SysTryReturn(NID_MSG, __cbsSettingsHandle != NULL, false, E_SYSTEM, "Cb handle is null");
 926
 927         bool isCbsEnabled = false;
 928         int err = MSG_SUCCESS;
 929
 930         err = msg_get_bool_value(__cbsSettingsHandle, MSG_CB_RECEIVE_BOOL, &isCbsEnabled);
 931         SysTryReturn(NID_MSG, err == MSG_SUCCESS, false, E_SYSTEM, "Failed to set SavingToCbsBoxEnabled option.");
 932
 933         return isCbsEnabled;
 934 }
 935
 936 result
 937 _SmsManagerImpl::SetCbsEnabled(bool enable)
 938 {
 939         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 940         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 941         SysTryReturnResult(NID_MSG, __cbsSettingsHandle != NULL, E_SYSTEM, "Cb handle is null");
 942
 943         int err = MSG_SUCCESS;
 944         result r = E_SUCCESS;
 945
 946         err = msg_set_bool_value(__cbsSettingsHandle, MSG_CB_RECEIVE_BOOL, enable);
 947         SysTryReturnResult(NID_MSG, err == MSG_SUCCESS, E_SYSTEM, "Failed to set cbs enabled.");
 948
 949         r = _SmsMmsCallbackHandler::GetInstance()->SaveCbsSettings();
 950         SysTryReturnResult(NID_MSG, r == E_SUCCESS, E_SYSTEM, "Failed to save cbs settings.");
 951
 952         return E_SUCCESS;
 953 }
 954
 955 result
 956 _SmsManagerImpl::AddCbsChannel(int from, int to, Tizen::Base::String& name, bool activate)
 957 {
 958         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 959         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 960         SysTryReturnResult(NID_MSG, __cbsSettingsHandle != NULL, E_SYSTEM, "Cb handle is null");
 961
 962         result r = E_SUCCESS;
 963         int count = 0;
 964
 965         r = _SmsMmsCallbackHandler::GetInstance()->GetCbsChannelsCount(count);
 966         SysTryReturn(NID_MSG, r == E_SUCCESS, r, r, "Failed to get CB Channel count.");
 967
 968         if (CB_CHANNEL_MAX <= count)
 969         {
 970                 return E_ALREADY_SET;
 971         }
 972
 973         // add channel
 974         r = _SmsMmsCallbackHandler::GetInstance()->AddCbsChannel(from, to, name, activate);
 975         SysTryReturn(NID_MSG, r == E_SUCCESS, r, r, "Failed to add a CB Channel.");
 976
 977         return r;
 978 }
 979
 980 result
 981 _SmsManagerImpl::RemoveCbsChannel(int from, int to)
 982 {
 983         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
 984         SysAssertf(__msgHandle > 0, "message handle is invalid.");
 985         SysTryReturnResult(NID_MSG, __cbsSettingsHandle != NULL, E_SYSTEM, "Cb handle is null");
 986
 987         result r = E_SUCCESS;
 988
 989         // remove channel
 990         r = _SmsMmsCallbackHandler::GetInstance()->RemoveCbsChannel(from, to);
 991         SysTryReturn(NID_MSG, r == E_SUCCESS, r, r, "Failed to remove a CB Channel.");
 992
 993         return r;
 994 }
 995
 996 CbsChannel*
 997 _SmsManagerImpl::GetCbsChannelN(int from, int to) const
 998 {
 999         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
1000         SysAssertf(__msgHandle > 0, "message handle is invalid.");
1001         SysTryReturn(NID_MSG, __cbsSettingsHandle != null, null, E_SYSTEM, "Cb handle is null.");
1002
1003         result r = E_SUCCESS;
1004         int fromId = 0;
1005         int toId = 0;
1006         int index = 0;
1007         bool isActive = false;
1008         String channelName;
1009         std::unique_ptr<CbsChannel> pCbsChannel;
1010
1011         ClearLastResult();
1012
1013         // search channel
1014         r = _SmsMmsCallbackHandler::GetInstance()->SearchCbsChannel(from, to, index);
1015         SysTryReturn(NID_MSG, r == E_SUCCESS, null, r, "Failed to find the cb channel.");
1016
1017         // get channel
1018         r = _SmsMmsCallbackHandler::GetInstance()->GetCbsChannel(index, fromId, toId, channelName, isActive);
1019         SysTryReturn(NID_MSG, r == E_SUCCESS, null, r, "Failed to get the cb channel.");
1020
1021         // creates channel
1022         pCbsChannel.reset(_CbsChannelImpl::GetCbsChannelN(fromId, toId, channelName));
1023
1024         if (isActive)
1025         {
1026                 pCbsChannel->Activate();
1027         }
1028
1029         return pCbsChannel.release();
1030 }
1031
1032 Tizen::Base::Collection::IList*
1033 _SmsManagerImpl::GetCbsChannelListN(void)
1034 {
1035         SysAssertf(__isConstructed == true, "_SmsManagerImpl instance is not constructed yet.");
1036         SysAssertf(__msgHandle > 0, "message handle is invalid.");
1037         SysTryReturn(NID_MSG, __cbsSettingsHandle != null, null, E_SYSTEM, "Cb handle is null.");
1038
1039         result r = E_SUCCESS;
1040         unique_ptr<ArrayList, AllElementsDeleter> pList;
1041         int cbChannelCount = 0;
1042         int fromId = 0;
1043         int toId = 0;
1044         bool isActive = false;
1045         String channelName;
1046         std::unique_ptr<CbsChannel> pCbsChannel;
1047
1048         ClearLastResult();
1049
1050         pList.reset(new (std::nothrow) ArrayList(SingleObjectDeleter));
1051         SysTryReturn(NID_MSG, pList != null, null, E_OUT_OF_MEMORY, "Memory allocation failed.");
1052
1053         // make a list
1054         r = pList->Construct();
1055         SysTryReturn(NID_MSG, r == E_SUCCESS, null, r, "Failed to construct array list.");
1056
1057         r = _SmsMmsCallbackHandler::GetInstance()->GetCbsChannelsCount(cbChannelCount);
1058         SysTryReturn(NID_MSG, r == E_SUCCESS, null, r, "Failed to get CB Channel count.");
1059
1060         for (int index = 0; index < cbChannelCount; index++)
1061         {
1062                 // get channel
1063                 r = _SmsMmsCallbackHandler::GetInstance()->GetCbsChannel(index, fromId, toId, channelName, isActive);
1064                 SysTryReturn(NID_MSG, r == E_SUCCESS, null, r , "Failed to get the cb channel.");
1065
1066                 pCbsChannel.reset(_CbsChannelImpl::GetCbsChannelN(fromId, toId, channelName));
1067                 if (pCbsChannel && isActive)
1068                 {
1069                         _CbsChannelImpl::GetInstance(*pCbsChannel)->SetCbsChannelState(isActive);
1070                         // add to the list
1071                         pList->Add(*pCbsChannel);
1072                 }
1073         }
1074
1075         return pList.release();
1076 }
1077
1078 _SmsManagerImpl*
1079 _SmsManagerImpl::GetInstance(SmsManager& smsManager)
1080 {
1081         return smsManager.__pImpl;
1082 }
1083
1084 const _SmsManagerImpl*
1085 _SmsManagerImpl::GetInstance(const SmsManager& smsManager)
1086 {
1087         return smsManager.__pImpl;
1088 }
1089
1090 result
1091 _SmsManagerImpl::ConvertException(int err) const
1092 {
1093         result r = E_SUCCESS;
1094
1095         switch (err)
1096         {
1097         case MSG_SUCCESS:
1098                 r = E_SUCCESS;
1099                 break;
1100
1101         case MSG_ERR_INVALID_PARAMETER:
1102         case MSG_ERR_INVALID_MESSAGE:
1103         case MSG_ERR_NULL_POINTER:
1104         case MSG_ERR_NULL_MESSAGE:
1105                 r = E_INVALID_ARG;
1106                 break;
1107
1108         case MSG_ERR_MEMORY_ERROR:
1109                 r = E_OUT_OF_MEMORY;
1110                 break;
1111
1112         case MSG_ERR_SERVER_NOT_READY:
1113         case MSG_ERR_TRANSPORT_ERROR:
1114         case MSG_ERR_COMMUNICATION_ERROR:
1115                 r = E_NETWORK_UNAVAILABLE;
1116                 break;
1117
1118         case MSG_ERR_NO_SIM:
1119                 r = E_DEVICE_UNAVAILABLE;
1120                 break;
1121
1122         case MSG_ERR_PLUGIN_TAPI_FAILED:
1123                 r = E_FAILURE;
1124                 break;
1125
1126         default:
1127                 r = E_SYSTEM;
1128                 break;
1129         }
1130
1131         return r;
1132 }
1133
1134 } } // Tizen::Messaging