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