src/FMsgSmsManager.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                FMsgSmsManager.cpp
  19  * @brief               This is the implementation file for the %SmsManager class.
  20  *
  21  * This file contains the implementation of the %SmsManager class.
  22  */
  23
  24 #include <msg.h>
  25 #include <msg_transport.h>
  26 #include <msg_storage.h>
  27 #include <dbus/dbus.h>
  28 #include <email-api.h>
  29 #include <FMsgSmsManager.h>
  30 #include <FMsgSmsMessage.h>
  31 #include <FBaseSysLog.h>
  32 #include <FSec_AccessController.h>
  33 #include "FMsg_SmsManagerImpl.h"
  34 #include "FMsg_Types.h"
  35 #include "FMsg_SmsEvent.h"
  36 #include "FMsg_MsgUtil.h"
  37 #include "FMsg_RecipientListImpl.h"
  38
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Messaging;
  41 using namespace Tizen::Base::Collection;
  42 using namespace Tizen::Security;
  43
  44 namespace Tizen { namespace Messaging
  45 {
  46
  47 SmsManager::SmsManager(void)
  48         : __pImpl(null)
  49 {
  50 }
  51
  52 SmsManager::~SmsManager(void)
  53 {
  54         if (__pImpl)
  55         {
  56                 delete __pImpl;
  57                 __pImpl = null;
  58         }
  59 }
  60
  61 result
  62 SmsManager::Construct(ISmsListener& listener)
  63 {
  64         // method return code
  65         result r = E_SUCCESS;
  66
  67         SysAssertf(__pImpl == null, "The SmsManager instance is already constructed.");
  68
  69         // create an _SmsManagerImpl instance
  70         __pImpl = new (std::nothrow) _SmsManagerImpl();
  71         SysTryReturnResult(NID_MSG, __pImpl != null, E_OUT_OF_MEMORY, "memory allocation failed.");
  72
  73         r = __pImpl->Construct(listener);
  74         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] Failed to construct an instance.", GetErrorMessage(r));
  75
  76         return r;
  77
  78 CATCH:
  79         return r;
  80 }
  81
  82 result
  83 SmsManager::AddSmsEventListener(int port, ISmsEventListener& eventListener)
  84 {
  85         result r = E_SUCCESS;
  86
  87         // checking privilege
  88         r = _AccessController::CheckUserPrivilege(_PRV_SMSTRIGGER);
  89         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
  90
  91         // checking conditions
  92         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
  93
  94         // checking argument
  95         SysTryReturn(NID_MSG, (port >= 1 && port <= 9999), E_INVALID_ARG, r = E_INVALID_ARG,
  96                            "[E_INVALID_ARG] The port number should range from 1 to 9999 (1 <= port <= 9999).");
  97
  98         r = __pImpl->AddSmsEventListener(port, eventListener);
  99         if (IsFailed(r))
 100         {
 101                 SysLogException(NID_MSG, r, "[%s] Failed to register the event listener with port [%d].", GetErrorMessage(r), port);
 102                 goto CATCH;
 103         }
 104
 105         return r;
 106
 107 CATCH:
 108         return r;
 109 }
 110
 111 result
 112 SmsManager::RemoveSmsEventListener(int port, ISmsEventListener& eventListener)
 113 {
 114         result r = E_SUCCESS;
 115
 116         // checking privilege
 117         r = _AccessController::CheckUserPrivilege(_PRV_SMSTRIGGER);
 118         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagating.");
 119
 120         // checking conditions
 121         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 122
 123         // checking argument
 124         SysTryReturn(NID_MSG, (port >= 1 && port <= 9999), E_INVALID_ARG, r = E_INVALID_ARG,
 125                            "[E_INVALID_ARG] The port number should range from 1 to 9999 (1 <= port <= 9999).");
 126
 127         r = __pImpl->RemoveSmsEventListener(port, eventListener);
 128         if (IsFailed(r))
 129         {
 130                 SysLogException(NID_MSG, r, "[%s] Failed to unregister the event listener.", GetErrorMessage(r));
 131                 goto CATCH;
 132         }
 133
 134         return r;
 135
 136 CATCH:
 137         return r;
 138 }
 139
 140 result
 141 SmsManager::AddSmsMessageEventListener(ISmsMessageEventListener& eventListener)
 142 {
 143         result r = E_SUCCESS;
 144
 145         // checking privilege
 146         r = _AccessController::CheckUserPrivilege(_PRV_MESSAGING_SMS);
 147         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
 148
 149         // checking conditions
 150         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 151
 152         // add listener
 153         r = __pImpl->AddSmsMessageEventListener(eventListener);
 154         if (IsFailed(r))
 155         {
 156                 SysLogException(NID_MSG, r, "[%s] Failed to add a listener.", GetErrorMessage(r));
 157                 goto CATCH;
 158         }
 159
 160
 161         return E_SUCCESS;
 162
 163 CATCH:
 164         return r;
 165 }
 166
 167 result
 168 SmsManager::RemoveSmsMessageEventListener(ISmsMessageEventListener& eventListener)
 169 {
 170         result r = E_SUCCESS;
 171
 172         // checking privilege
 173         r = _AccessController::CheckUserPrivilege(_PRV_MESSAGING_SMS);
 174         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
 175
 176         // checking conditions
 177         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 178
 179         r = __pImpl->RemoveSmsMessageEventListener(eventListener);
 180         if (IsFailed(r))
 181         {
 182                 SysLogException(NID_MSG, r, "[%s] Failed to remove a listener.", GetErrorMessage(r));
 183                 goto CATCH;
 184         }
 185
 186         return r;
 187
 188 CATCH:
 189         return r;
 190 }
 191
 192 int
 193 SmsManager::GetTotalMessageCount(SmsMessageBoxType type) const
 194 {
 195         result r = E_SUCCESS;
 196         int count = 0;
 197         ClearLastResult();
 198
 199         // checking privilege
 200         r = _AccessController::CheckUserPrivilege(_PRV_MESSAGING_SMS);
 201         if (r != E_SUCCESS)
 202         {
 203                 SetLastResult(E_PRIVILEGE_DENIED);
 204                 SysLogException(NID_MSG, GetLastResult(), "[E_PRIVILEGE_DENIED] Propagated.");
 205                 return -1;
 206         }
 207
 208         // checking condition
 209         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 210
 211         // checking argument
 212         if (type <= SMS_MESSAGE_BOX_TYPE_NONE || type > SMS_MESSAGE_BOX_TYPE_ALL)
 213         {
 214                 SetLastResult(E_INVALID_ARG);
 215                 SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] Invalid SmsMessageBoxType argument.");
 216                 return -1;
 217         }
 218         if (type > SMS_MESSAGE_BOX_TYPE_OUTBOX && type < SMS_MESSAGE_BOX_TYPE_ALL)
 219         {
 220                 SetLastResult(E_INVALID_ARG);
 221                 SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] Invalid SmsMessageBoxType argument.");
 222                 return -1;
 223         }
 224
 225         count = __pImpl->GetTotalMessageCount(type);
 226         r = GetLastResult();
 227         if (IsFailed(r))
 228         {
 229                 SysLogException(NID_MSG, r, "[%s] exception occurred. Failed to get SMS total count. type:[%d].", GetErrorMessage(r), (int) type);
 230                 SetLastResult(r);
 231                 return -1;
 232         }
 233
 234         return count;
 235 }
 236
 237 Tizen::Base::Collection::IList*
 238 SmsManager::SearchInboxN(const Tizen::Base::String* pKeyword, const Tizen::Base::String* pSenderAddress, int startIndex, int count,
 239                                                  int& totalResultCount) const
 240 {
 241         IList* pList = null;
 242         result r = E_SUCCESS;
 243
 244         ClearLastResult();
 245
 246         // checking privilege
 247         r = _AccessController::CheckUserPrivilege(_PRV_MESSAGING_SMS);
 248         if (r != E_SUCCESS)
 249         {
 250                 SetLastResult(E_PRIVILEGE_DENIED);
 251                 SysLogException(NID_MSG, GetLastResult(), "[E_PRIVILEGE_DENIED] Propagated.");
 252
 253                 goto CATCH;
 254         }
 255
 256         // checking condition
 257         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 258
 259         // checking arguments
 260         if (pKeyword)
 261         {
 262                 if (pKeyword->GetLength() == MIN_KEYWORD_LENGTH || pKeyword->GetLength() > MAX_KEYWORD_LENGTH)
 263                 {
 264                         SetLastResult(E_INVALID_ARG);
 265                         SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] The specified keyword string length [%d] is smaller than 2 or greater than 30.",
 266                                                          pKeyword->GetLength());
 267                         goto CATCH;
 268                 }
 269         }
 270
 271         if (pSenderAddress)
 272         {
 273                 if (!pSenderAddress->IsEmpty())
 274                 {
 275                         if (pSenderAddress->GetLength() < MIN_LENGTH_PHONE || pSenderAddress->GetLength() > MAX_LENGTH_PHONE)
 276                         {
 277                                 SetLastResult(E_INVALID_ARG);
 278                                 SysLogException(NID_MSG, GetLastResult(),
 279                                         "[E_INVALID_ARG] The length of the given sender address should be greater than 3 and less than 41.");
 280                                 goto CATCH;
 281                         }
 282                         else if (_MsgUtil::IsValidPhoneNumber(*pSenderAddress) != true)
 283                         {
 284                                 SetLastResult(E_INVALID_ARG);
 285                                 SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] The sender address may contain non-digit characters.");
 286                                 goto CATCH;
 287                         }
 288                 }
 289         }
 290
 291         if (startIndex < 0)
 292         {
 293                 SetLastResult(E_INVALID_ARG);
 294                 SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] The start index [%d] should be equal to or greater than 0.", startIndex);
 295                 goto CATCH;
 296         }
 297
 298         if (count < 0 || count > 20)
 299         {
 300                 SetLastResult(E_INVALID_ARG);
 301                 SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] The count value [%d] is too small (< 0) or too big (> 20).", count);
 302                 goto CATCH;
 303         }
 304
 305
 306         if (count == 0)
 307         {
 308                 SetLastResult(E_SUCCESS);
 309                 totalResultCount = 0;
 310                 return null;
 311         }
 312
 313         // searching...
 314         pList = __pImpl->SearchInboxN(pKeyword, pSenderAddress, startIndex, count, totalResultCount);
 315         r = GetLastResult();
 316         if (IsFailed(r) || !pList)
 317         {
 318                 SetLastResult(r);
 319                 SysLogException(NID_MSG, r, "[%s] Failed to search.", GetErrorMessage(r));
 320                 goto CATCH;
 321         }
 322
 323         return pList;
 324
 325 CATCH:
 326         if (pList)
 327         {
 328                 if (pList->GetCount() > 0)
 329                 {
 330                         pList->RemoveAll(true);
 331                 }
 332                 delete pList;
 333                 pList = null;
 334         }
 335         return null;
 336 }
 337
 338 Tizen::Base::Collection::IList*
 339 SmsManager::SearchMessageBoxN(SmsMessageBoxType type, const Tizen::Base::String* pKeyword, int startIndex, int count,
 340                                                           int& totalResultCount) const
 341 {
 342         IList* pList = null;
 343         result r = E_SUCCESS;
 344
 345         ClearLastResult();
 346
 347         // checking privilege
 348         r = _AccessController::CheckUserPrivilege(_PRV_MESSAGING_SMS);
 349         if (r != E_SUCCESS)
 350         {
 351                 SetLastResult(E_PRIVILEGE_DENIED);
 352                 SysLogException(NID_MSG, GetLastResult(), "[E_PRIVILEGE_DENIED] Propagated.");
 353
 354                 goto CATCH;
 355         }
 356
 357         // checking condition
 358         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 359
 360         // checking sms message box type argument
 361         if (type <= SMS_MESSAGE_BOX_TYPE_NONE || type > SMS_MESSAGE_BOX_TYPE_ALL)
 362         {
 363                 SetLastResult(E_INVALID_ARG);
 364                 SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] The SmsMessageBoxType value [%d] is invalid.", (int) type);
 365                 goto CATCH;
 366         }
 367
 368         if (type > SMS_MESSAGE_BOX_TYPE_OUTBOX && type < SMS_MESSAGE_BOX_TYPE_ALL)
 369         {
 370                 SetLastResult(E_INVALID_ARG);
 371                 SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] The SmsMessageBoxType value [%d] is invalid.", (int) type);
 372                 goto CATCH;
 373         }
 374
 375         // checking keyword arguments
 376         if (pKeyword)
 377         {
 378                 if (pKeyword->GetLength() == MIN_KEYWORD_LENGTH || pKeyword->GetLength() > MAX_KEYWORD_LENGTH)
 379                 {
 380                         SetLastResult(E_INVALID_ARG);
 381                         SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] The specified keyword string length [%d] is smaller than 2 or greater than 30.",
 382                                                          pKeyword->GetLength());
 383                         goto CATCH;
 384                 }
 385         }
 386
 387         // checking start index argument
 388         if (startIndex < 0)
 389         {
 390                 SetLastResult(E_INVALID_ARG);
 391                 SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] The start index [%d] should be equal to or greater than 0.", startIndex);
 392                 goto CATCH;
 393         }
 394
 395         // checking count argument
 396         if (count < 0 || count > 20)
 397         {
 398                 SetLastResult(E_INVALID_ARG);
 399                 SysLogException(NID_MSG, GetLastResult(), "[E_INVALID_ARG] The count value [%d] is too small (< 0) or too big (> 20).", count);
 400                 goto CATCH;
 401         }
 402
 403         if (count == 0)
 404         {
 405                 SetLastResult(E_SUCCESS);
 406                 totalResultCount = 0;
 407                 return null;
 408         }
 409
 410         // searching...
 411         pList = __pImpl->SearchMessageBoxN(type, pKeyword, startIndex, count, totalResultCount);
 412         r = GetLastResult();
 413         if (IsFailed(r) || !pList)
 414         {
 415                 SetLastResult(r);
 416                 SysLogException(NID_MSG, r, "[%s] Failed to search.", GetErrorMessage(r));
 417                 goto CATCH;
 418         }
 419
 420         return pList;
 421
 422 CATCH:
 423         if (pList)
 424         {
 425                 if (pList->GetCount() > 0)
 426                 {
 427                         pList->RemoveAll(true);
 428                 }
 429                 delete pList;
 430                 pList = null;
 431         }
 432         return null;
 433 }
 434
 435 Tizen::Base::String
 436 SmsManager::GetFullText(int messageId) const
 437 {
 438         result r = E_SUCCESS;
 439         String fullText;
 440
 441         ClearLastResult();
 442
 443         // checking privilege
 444         r = _AccessController::CheckUserPrivilege(_PRV_MESSAGING_SMS);
 445         if (r != E_SUCCESS)
 446         {
 447                 SetLastResult(E_PRIVILEGE_DENIED);
 448                 SysLogException(NID_MSG, GetLastResult(), "[E_PRIVILEGE_DENIED] Propagated.");
 449                 goto CATCH;
 450         }
 451
 452         // checking condition
 453         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 454
 455         // checking argument
 456         if (messageId < 0)
 457         {
 458                 SetLastResult(E_INVALID_ARG);
 459                 SysLogException(NID_MSG, GetLastResult(), "[%s] exception occurred. The value [%d] of message ID is invalid.", GetErrorMessage(r), messageId);
 460                 goto CATCH;
 461         }
 462
 463         fullText = __pImpl->GetFullText(messageId);
 464         r = GetLastResult();
 465         if (IsFailed(r))
 466         {
 467                 SetLastResult(r);
 468                 SysLogException(NID_MSG, r, "[%s] exception occurred. Failed to get SMS message using message ID [%d].", GetErrorMessage(
 469                                                          r), messageId);
 470                 goto CATCH;
 471         }
 472
 473         SysLog(NID_MSG, "Returned Full Text : [%ls]", fullText.GetPointer());
 474
 475         return fullText;
 476
 477 CATCH:
 478         return L"";
 479 }
 480
 481 result
 482 SmsManager::Send(const SmsMessage& message, const RecipientList& recipientList, bool saveToSentBox)
 483 {
 484         result r = E_SUCCESS;
 485
 486         // checking privilege
 487         r = _AccessController::CheckUserPrivilege(_PRV_MESSAGING_SMS);
 488         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
 489
 490         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 491         SysTryReturnResult(NID_MSG,
 492                 MAX_SMS_RECIPIENT_COUNT >= _RecipientListImpl::GetInstance(recipientList)->GetTotalRecipientCount(), E_MAX_EXCEEDED,
 493                 "[E_MAX_EXCEEDED] The number of recipients exceeds the limit (%d).", MAX_SMS_RECIPIENT_COUNT);
 494         SysTryReturnResult(NID_MSG,
 495                 0 < _RecipientListImpl::GetInstance(recipientList)->GetTotalRecipientCount(), E_INVALID_ARG, "[E_INVALID_ARG] The number of recipients is 0.");
 496
 497         // check the validity of the phone number in recipient list
 498         r = _MsgUtil::CheckPhoneNumberValidity(_MSG_SMS, recipientList);
 499         if (IsFailed(r))
 500         {
 501                 SysLogException(NID_MSG, r, "[%s] There is an invalid phone number in the recipient list.", GetErrorMessage(r));
 502                 goto CATCH;
 503         }
 504
 505         // send an SMS message
 506         r = __pImpl->Send(message, recipientList, saveToSentBox);
 507         if (IsFailed(r))
 508         {
 509                 SysLogException(NID_MSG, r, "[%s] Failed to send the SMS message.", GetErrorMessage(r));
 510                 goto CATCH;
 511         }
 512
 513         return E_SUCCESS;
 514
 515 CATCH:
 516         return r;
 517 }
 518
 519 result
 520 SmsManager::SetCbsMessageEventListener(ICbsMessageEventListener* pListener)
 521 {
 522         result r = E_SUCCESS;
 523
 524         ClearLastResult();
 525
 526         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 527
 528         // checking privilege
 529         r = _AccessController::CheckUserPrivilege(_PRV_CELLBROADCAST);
 530         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
 531
 532         // add listener
 533         r = __pImpl->SetCbsMessageEventListener(pListener);
 534
 535         return r;
 536 }
 537
 538 result
 539 SmsManager::SetEtwsPrimaryNotificationEventListener(IEtwsPrimaryNotificationEventListener* pListener)
 540 {
 541         result r = E_SUCCESS;
 542
 543         ClearLastResult();
 544
 545         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 546
 547         // checking privilege
 548         r = _AccessController::CheckUserPrivilege(_PRV_CELLBROADCAST);
 549         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
 550
 551         // add listener
 552         r = __pImpl->SetEtwsPrimaryNotificationEventListener(pListener);
 553
 554         return r;
 555 }
 556
 557 result
 558 SmsManager::SetSavingToCbsBoxEnabled(bool enable)
 559 {
 560         result r = E_SUCCESS;
 561
 562         ClearLastResult();
 563
 564         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 565
 566         // checking privilege
 567         r = _AccessController::CheckUserPrivilege(_PRV_CELLBROADCAST);
 568         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
 569
 570         r = __pImpl->SetSavingToCbsBoxEnabled(enable);
 571
 572         return r;
 573 }
 574
 575 bool
 576 SmsManager::IsCbsEnabled(void) const
 577 {
 578         result r = E_SUCCESS;
 579         bool isCbsEnabled = false;
 580
 581         ClearLastResult();
 582
 583         // checking conditions
 584         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 585
 586         // checking privilege
 587         r = _AccessController::CheckUserPrivilege(_PRV_CELLBROADCAST);
 588         SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
 589
 590         isCbsEnabled = __pImpl->IsCbsEnabled();
 591
 592         r = GetLastResult();
 593         SetLastResult(r);
 594
 595         return isCbsEnabled;
 596
 597 CATCH:
 598         SetLastResult(r);
 599         return isCbsEnabled;
 600 }
 601
 602 result
 603 SmsManager::SetCbsEnabled(bool enable)
 604 {
 605         result r = E_SUCCESS;
 606
 607         ClearLastResult();
 608
 609         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 610
 611         // checking privilege
 612         r = _AccessController::CheckUserPrivilege(_PRV_CELLBROADCAST);
 613         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
 614
 615         r = __pImpl->SetCbsEnabled(enable);
 616
 617         return r;
 618 }
 619
 620 result
 621 SmsManager::AddCbsChannel(int from, int to, Tizen::Base::String& name, bool activate)
 622 {
 623         result r = E_SUCCESS;
 624
 625         ClearLastResult();
 626
 627         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 628
 629         // checking privilege
 630         r = _AccessController::CheckUserPrivilege(_PRV_CELLBROADCAST);
 631         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
 632
 633         // argument check
 634         SysTryReturn(NID_MSG,
 635                         name.GetLength() <= MAX_CBS_CHANNEL_NAME_LENGTH, E_INVALID_ARG, r = E_INVALID_ARG, "[E_INVALID_ARG] invalid channel name.");
 636         SysTryReturn(NID_MSG,
 637                         ((to >= 0) && (from >= 0) && (to >= from) && (to <= MAX_CBS_CHANNEL_LIMIT) && ((to - from) <= MAX_CBS_CHANNEL_RANGE)),
 638                         E_INVALID_ARG, r = E_INVALID_ARG, "[E_INVALID_ARG] Failed to add construct channel, invalid arguments.");
 639
 640         r = __pImpl->AddCbsChannel(from, to, name, activate);
 641
 642         return r;
 643 }
 644
 645 result
 646 SmsManager::RemoveCbsChannel(int from, int to)
 647 {
 648         result r = E_SUCCESS;
 649
 650         ClearLastResult();
 651
 652         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 653
 654         // checking privilege
 655         r = _AccessController::CheckUserPrivilege(_PRV_CELLBROADCAST);
 656         SysTryReturn(NID_MSG, r == E_SUCCESS, E_PRIVILEGE_DENIED, r = E_PRIVILEGE_DENIED, "[E_PRIVILEGE_DENIED] Propagated.");
 657
 658         SysTryReturn(NID_MSG,
 659                         ((to >= 0) && (from >= 0) && (to >= from) && (to <= MAX_CBS_CHANNEL_LIMIT) && ((to - from) <= MAX_CBS_CHANNEL_RANGE)),
 660                         E_INVALID_ARG, r = E_INVALID_ARG, "[E_INVALID_ARG] Failed to add construct channel, invalid arguments.");
 661
 662         r = __pImpl->RemoveCbsChannel(from, to);
 663
 664         return r;
 665 }
 666
 667 CbsChannel*
 668 SmsManager::GetCbsChannelN(int from, int to) const
 669 {
 670         result r = E_SUCCESS;
 671         CbsChannel* pCbsChannel = null;
 672
 673         ClearLastResult();
 674
 675         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 676
 677         // checking privilege
 678         r = _AccessController::CheckUserPrivilege(_PRV_CELLBROADCAST);
 679         SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_PRIVILEGE_DENIED, r, "[E_PRIVILEGE_DENIED] Propagated.");
 680
 681         SysTryCatch(NID_MSG,
 682                         ((to >= 0) && (from >= 0) && (to >= from) && (to <= MAX_CBS_CHANNEL_LIMIT) && ((to - from) <= MAX_CBS_CHANNEL_RANGE)),
 683                         r = E_INVALID_ARG, r, "[E_INVALID_ARG] Failed to add construct channel, invalid arguments.");
 684
 685         pCbsChannel = __pImpl->GetCbsChannelN(from, to);
 686
 687         r = GetLastResult();
 688         SetLastResult(r);
 689
 690         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] Failed to get Cbs channel", GetErrorMessage(r));
 691
 692         return pCbsChannel;
 693
 694 CATCH:
 695         SetLastResult(r);
 696
 697         if (pCbsChannel)
 698         {
 699                 delete pCbsChannel;
 700                 pCbsChannel = null;
 701         }
 702         return null;
 703 }
 704
 705 Tizen::Base::Collection::IList*
 706 SmsManager::GetCbsChannelListN(void)
 707 {
 708         result r = E_SUCCESS;
 709         IList* pList = null;
 710
 711         ClearLastResult();
 712
 713         SysAssertf(__pImpl != null, "The SmsManager instance is not constructed yet.");
 714
 715         // checking privilege
 716         r = _AccessController::CheckUserPrivilege(_PRV_CELLBROADCAST);
 717         SysTryCatch(NID_MSG, r == E_SUCCESS, r = E_PRIVILEGE_DENIED, r, "[E_PRIVILEGE_DENIED] Propagated.");
 718
 719         pList = __pImpl->GetCbsChannelListN();
 720
 721         r = GetLastResult();
 722         SetLastResult(r);
 723
 724         SysTryCatch(NID_MSG, r == E_SUCCESS, , r, "[%s] Failed to get Cbs channel list", GetErrorMessage(r));
 725
 726         return pList;
 727
 728 CATCH:
 729         SetLastResult(r);
 730         if (pList)
 731         {
 732                 if (pList->GetCount() > 0)
 733                 {
 734                         pList->RemoveAll(true);
 735                 }
 736                 delete pList;
 737                 pList = null;
 738         }
 739         return null;
 740 }
 741
 742 } } // Tizen::Messaging