src/app/FApp_NotificationManagerImpl.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file                FApp_NotificationManagerImpl.cpp
  19  * @brief               This is the placeholder for _NotificationManagerImpl class.
  20  */
  21
  22 #include <unique_ptr.h>
  23
  24 #include <appsvc/appsvc.h>
  25 #include <bundle.h>
  26 #include <badge.h>
  27 #include <notification/notification.h>
  28 #include <appfw/app.h>
  29 #include <appfw/app_ui_notification.h>
  30 #include <appinfo.h>
  31
  32 #include <FBaseSysLog.h>
  33 #include <FAppNotificationManager.h>
  34
  35 #include <FBaseInternalTypes.h>
  36 #include <FBase_StringConverter.h>
  37 #include "FApp_NotificationManagerImpl.h"
  38 #include "FApp_AppInfo.h"
  39 #include "FIoFile.h"
  40 #include "FAppPkg_PackageManagerImpl.h"
  41 #include "FApp_Aul.h"
  42 #include "FApp_AppArg.h"
  43 #include "FAppPkgPackageAppInfo.h"
  44 #include "FAppPkg_PackageAppInfoImpl.h"
  45
  46 using namespace Tizen::Base;
  47 using namespace Tizen::App;
  48 using namespace Tizen::App::Package;
  49 using namespace Tizen::Io;
  50
  51 extern "C" int service_create_request(bundle *data, service_h *service);
  52
  53 namespace
  54 {
  55
  56 result
  57 ConvertNotificationResult(int error)
  58 {
  59         switch (error)
  60         {
  61         case UI_NOTIFICATION_ERROR_NONE:
  62                 return E_SUCCESS;
  63         case UI_NOTIFICATION_ERROR_INVALID_PARAMETER:
  64                 return E_INVALID_ARG;
  65         case UI_NOTIFICATION_ERROR_OUT_OF_MEMORY:
  66                 return E_OUT_OF_MEMORY;
  67         case UI_NOTIFICATION_ERROR_DB_FAILED:
  68                 return E_DATABASE;
  69         case UI_NOTIFICATION_ERROR_NO_SUCH_FILE:
  70                 return E_SYSTEM;
  71         case UI_NOTIFICATION_ERROR_INVALID_STATE:
  72                 return E_SYSTEM;
  73         default:
  74                 return E_SYSTEM;
  75         }
  76 }
  77
  78 bool
  79 IsPosted(ui_notification_h handle)
  80 {
  81         struct ui_notification_s
  82         {
  83                 void* raw_handle;
  84                 bool ongoing;
  85                 bool posted;
  86                 bool removed;
  87                 char *icon;
  88                 struct tm *time;
  89                 char *title;
  90                 char *content;
  91                 service_h service;
  92                 char *sound;
  93                 bool vibration;
  94         };
  95
  96         if (handle == NULL)
  97         {
  98                 return false;
  99         }
 100
 101         ui_notification_s* pStruct = reinterpret_cast<ui_notification_s*>(handle);
 102
 103         return pStruct->posted;
 104 }
 105
 106 }
 107
 108 namespace Tizen { namespace App
 109 {
 110
 111 _NotificationManagerImpl::_NotificationManagerImpl(void)
 112 {
 113 }
 114
 115 _NotificationManagerImpl::~_NotificationManagerImpl(void)
 116 {
 117 }
 118
 119 result
 120 _NotificationManagerImpl::Construct(void)
 121 {
 122         return E_SUCCESS;
 123 }
 124
 125 const _NotificationManagerImpl*
 126 _NotificationManagerImpl::GetInstance(const NotificationManager& notiMgr)
 127 {
 128         return notiMgr.__pNotificationManagerImpl;
 129 }
 130
 131 _NotificationManagerImpl*
 132 _NotificationManagerImpl::GetInstance(NotificationManager& notiMgr)
 133 {
 134         return notiMgr.__pNotificationManagerImpl;
 135 }
 136
 137 int
 138 _NotificationManagerImpl::GetBadgeNumber(void) const
 139 {
 140         unsigned int count = 0;
 141
 142         badge_error_e badgeError = badge_get_count(appinfo_get_appid(), &count);
 143
 144         if (badgeError == BADGE_ERROR_NONE)
 145         {
 146                 SysLog(NID_APP, "badge_get_count(%d)", count);
 147         }
 148         else
 149         {
 150                 SysLog(NID_APP, "badge_get_count failed(%d).", badgeError);
 151                 return -1;
 152         }
 153         return count;
 154 }
 155
 156 result
 157 _NotificationManagerImpl::OngoingImpl(const String& messageText, const String& launchArguments) const
 158 {
 159         return NotifyImpl(messageText, -1, launchArguments, true);
 160 }
 161
 162 result
 163 _NotificationManagerImpl::OngoingImpl(const AppId& appId, const String& messageText, const String& launchArguments) const
 164 {
 165
 166         return NotifyImpl(appId, messageText, -1, launchArguments, true);
 167 }
 168
 169 result
 170 _NotificationManagerImpl::NotifyImpl(const String& messageText, int badgeNumber,
 171                                                                          const String& launchArguments,
 172                                                                          bool isOngoing) const
 173 {
 174         result r = E_SUCCESS;
 175         int retcode = 0;
 176         char* pMsg = null;
 177         char* pkgname = NULL;
 178         char* pIcon = NULL;
 179         bundle* pKb = NULL;
 180         service_h svc = NULL;
 181         _AppArg arg;
 182         String iconPath;
 183         ui_notification_h core = NULL;
 184         PackageAppInfo* pPackageAppInfo = NULL;
 185
 186         if (!messageText.IsEmpty())
 187         {
 188                 SysTryReturnResult(NID_APP,
 189                                           messageText.GetLength() <= MAX_NOTIFICATION_MESSAGE_LENGTH, E_INVALID_ARG,
 190                                           "MessageText is greater than MAX_NOTIFICATION_MESSAGE_LENGTH.");
 191
 192                 retcode = ui_notification_create(isOngoing, &core);
 193                 SysTryReturnResult(NID_APP, retcode == UI_NOTIFICATION_ERROR_NONE, E_SYSTEM, "Notification creation error : 0x%x.", retcode);
 194
 195                 pMsg = _StringConverter::CopyToCharArrayN(messageText);
 196
 197                 int ret = ui_notification_set_content(core, pMsg);
 198                 SysTryLog(NID_APP, ret == UI_NOTIFICATION_ERROR_NONE, "Setting notification content failure : %d.", ret);
 199
 200                 const String& currappId = _AppInfo::GetApplicationId();
 201
 202                 pPackageAppInfo = _PackageManagerImpl::GetInstance()->GetPackageAppInfoN(currappId);
 203                 iconPath = _PackageAppInfoImpl::GetInstance(pPackageAppInfo)->GetAppNotificationIconPath();
 204
 205                 if (!iconPath.IsEmpty() && File::IsFileExist(iconPath))
 206                 {
 207                         pIcon = _StringConverter::CopyToCharArrayN(iconPath);
 208                         r = ConvertNotificationResult(ui_notification_set_icon(core, pIcon));
 209                         SysTryLog(NID_APP, !IsFailed(r), "[%s] Notification set icon failed.", GetErrorMessage(r));
 210                 }
 211
 212                 app_get_package(&pkgname);
 213                 SysTryCatch(NID_APP, pkgname != NULL, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Cannot acquire package name for current application.");
 214
 215                 r = arg.Construct(launchArguments);
 216                 SysTryCatch(NID_APP, !IsFailed(r), , r, "[%s] Propagating.", GetErrorMessage(r));
 217
 218                 pKb = arg.GetBundle();
 219                 service_create_request(pKb, &svc);
 220
 221                 service_set_package(svc, pkgname);
 222                 r = ConvertNotificationResult(ui_notification_set_service(core, svc));
 223                 SysTryLog(NID_APP, !IsFailed(r), "[%s] Notification set service failed.", GetErrorMessage(r));
 224
 225                 SysLog(NID_APP, "Sending notification[%ls] for package %s.", messageText.GetPointer(), pkgname);
 226
 227                 r = ConvertNotificationResult(ui_notification_post(core));
 228                 SysTryLog(NID_APP, !IsFailed(r), "[%s] Notification post failure.", GetErrorMessage(r));
 229         }
 230
 231         if (badgeNumber >= 0)
 232         {
 233                 badge_error_e badgeError = badge_set_count(appinfo_get_appid(), badgeNumber);
 234                 SysTryLog(NID_APP, badgeError == BADGE_ERROR_NONE, "badge_set_count failed(%d).", badgeError);
 235         }
 236
 237 CATCH:
 238         delete pPackageAppInfo;
 239         delete[] pMsg;
 240         delete[] pIcon;
 241
 242         if (pkgname)
 243         {
 244                 free(pkgname);
 245         }
 246         if (core)
 247         {
 248                 ui_notification_destroy(core);
 249         }
 250         service_destroy(svc);
 251         return r;
 252 }
 253
 254 result
 255 _NotificationManagerImpl::NotifyImpl(const AppId& appId, const String& messageText, int badgeNumber,
 256                                                                          const String& launchArguments,
 257                                                                          bool isOngoing) const
 258 {
 259         result r = E_SUCCESS;
 260         int retcode = 0;
 261         String iconPath;
 262         char* pMsg = null;
 263         char* pIcon = null;
 264         char* pName = null;
 265         ui_notification_h core = NULL;
 266         char buffer[256];
 267         bundle* pKb = NULL;
 268         service_h svc = NULL;
 269         _AppArg arg;
 270         PackageAppInfo* pPackageAppInfo = null;
 271
 272         memset(buffer, 0, 256);
 273
 274         bool inInstalled = _Aul::IsInstalled(appId);
 275         SysTryReturnResult(NID_APP, inInstalled == true, E_APP_NOT_INSTALLED, "The application %ls is not installed", appId.GetPointer());
 276
 277         if (!isOngoing || !messageText.IsEmpty())
 278         {
 279                 SysTryReturnResult(NID_APP,
 280                                           messageText.GetLength() <= MAX_NOTIFICATION_MESSAGE_LENGTH, E_INVALID_ARG,
 281                                           "MessageText is greater than MAX_NOTIFICATION_MESSAGE_LENGTH.");
 282
 283                 retcode = ui_notification_create(isOngoing, &core);
 284                 SysTryReturnResult(NID_APP, retcode == UI_NOTIFICATION_ERROR_NONE, E_SYSTEM, "Notification creation error : 0x%x.", retcode);
 285
 286                 pMsg = _StringConverter::CopyToCharArrayN(messageText);
 287
 288                 int ret = ui_notification_set_content(core, pMsg);
 289                 SysTryLog(NID_APP, ret == UI_NOTIFICATION_ERROR_NONE, "Setting notification content failure : %d.", ret);
 290
 291                 snprintf(buffer, 256, "%ls", appId.GetPointer());
 292
 293                 pPackageAppInfo = _PackageManagerImpl::GetInstance()->GetPackageAppInfoN(appId);
 294                 if (pPackageAppInfo)
 295                 {
 296                         iconPath = pPackageAppInfo->GetAppNotificationIconPath();
 297
 298                         if (!iconPath.IsEmpty() && File::IsFileExist(iconPath))
 299                         {
 300                                 pIcon = _StringConverter::CopyToCharArrayN(iconPath);
 301                                 r = ConvertNotificationResult(ui_notification_set_icon(core, pIcon));
 302                                 SysTryLog(NID_APP, !IsFailed(r), "[%s] Notification set icon failed.", GetErrorMessage(r));
 303                         }
 304                         else
 305                         {
 306                                 iconPath = pPackageAppInfo->GetAppMenuIconPath();
 307                                 pIcon = _StringConverter::CopyToCharArrayN(iconPath);
 308                                 r = ConvertNotificationResult(ui_notification_set_icon(core, pIcon));
 309                                 SysTryLog(NID_APP, !IsFailed(r), "[%s] Notification Set icon path  failed.", GetErrorMessage(r));
 310                         }
 311
 312                         const String& displayName = pPackageAppInfo->GetAppDisplayName();
 313                         pName = _StringConverter::CopyToCharArrayN(displayName);
 314
 315                         r = ConvertNotificationResult(ui_notification_set_title(core, pName));
 316                         SysTryLog(NID_APP, !IsFailed(r), "[%s] Notification set title failed.", GetErrorMessage(r));
 317                 }
 318                 else
 319                 {
 320                         SysLog(NID_APP, "No packageInfo found for %ls", appId.GetPointer());
 321                 }
 322
 323
 324                 r = arg.Construct(launchArguments);
 325                 SysTryCatch(NID_APP, !IsFailed(r), , r, "[%s] Propagating.", GetErrorMessage(r));
 326
 327                 pKb = arg.GetBundle();
 328                 service_create_request(pKb, &svc);
 329
 330                 service_set_app_id(svc, buffer);
 331                 r = ConvertNotificationResult(ui_notification_set_service(core, svc));
 332                 SysTryLog(NID_APP, !IsFailed(r), "[%s] Notification set service failed.", GetErrorMessage(r));
 333
 334                 SysLog(NID_APP, "Sending notification[%ls] for package %s.", messageText.GetPointer(), buffer);
 335
 336                 r = ConvertNotificationResult(ui_notification_post(core));
 337                 SysTryLog(NID_APP, !IsFailed(r), "[%s] Notification post failure.", GetErrorMessage(r));
 338         }
 339
 340         if (badgeNumber >= 0)
 341         {
 342                 badge_error_e badgeError = badge_set_count(buffer, badgeNumber);
 343                 SysTryLog(NID_APP, badgeError == BADGE_ERROR_NONE, "badge_set_count failed(%d).", badgeError);
 344         }
 345
 346 CATCH:
 347         delete pPackageAppInfo;
 348         delete[] pMsg;
 349         delete[] pIcon;
 350         delete[] pName;
 351
 352         if (core)
 353         {
 354                 ui_notification_destroy(core);
 355         }
 356         service_destroy(svc);
 357         return r;
 358 }
 359
 360
 361 result
 362 _NotificationManagerImpl::RemoveImpl(const char* pAppId, notification_type_e type)
 363 {
 364         result r = E_SUCCESS;
 365
 366         notification_error_e err = notification_delete_all_by_type(pAppId, type);
 367         switch (err)
 368         {
 369         case NOTIFICATION_ERROR_NONE:
 370                 r = E_SUCCESS;
 371                 break;
 372
 373         case NOTIFICATION_ERROR_INVALID_DATA:
 374                 r = E_INVALID_ARG;
 375                 break;
 376
 377         default:
 378                 r = E_SYSTEM;
 379                 break;
 380         }
 381
 382         return r;
 383 }
 384
 385
 386 result
 387 _NotificationManagerImpl::RemoveImpl(const AppId& appId, bool isOngoing)
 388 {
 389         const bool isValidAppId = _Aul::IsInstalled(appId);
 390         SysTryReturnResult(NID_APP, isValidAppId, E_APP_NOT_INSTALLED, "The application %ls is not installed", appId.GetPointer());
 391
 392         std::unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(appId));
 393         const notification_type_e notiType = (isOngoing) ? NOTIFICATION_TYPE_ONGOING : NOTIFICATION_TYPE_NOTI;
 394
 395         return RemoveImpl(pAppId.get(), notiType);
 396 }
 397
 398 result
 399 _NotificationManagerImpl::Notify(int badgeNumber) const
 400 {
 401         SysTryReturnResult(NID_APP, badgeNumber >= 0, E_INVALID_ARG, "BadgeNumber is less than 0.");
 402
 403         if (badgeNumber > MAX_NOTIFICATION_BADGE_NUMBER)
 404         {
 405                 badgeNumber = MAX_NOTIFICATION_BADGE_NUMBER;
 406         }
 407
 408         String messageText = String(L"");
 409         String appMessage = String(L"");
 410
 411         return NotifyImpl(messageText, badgeNumber, appMessage, false);
 412 }
 413
 414 result
 415 _NotificationManagerImpl::Notify(const String& messageText) const
 416 {
 417         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 418
 419         String appMessage = String(L"");
 420
 421         return NotifyImpl(messageText, -1, appMessage, false);
 422 }
 423
 424 result
 425 _NotificationManagerImpl::Notify(const String& messageText, int badgeNumber) const
 426 {
 427         SysTryReturnResult(NID_APP, badgeNumber >= 0, E_INVALID_ARG, "BadgeNumber is less than 0.");
 428         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 429
 430         if (badgeNumber > MAX_NOTIFICATION_BADGE_NUMBER)
 431         {
 432                 badgeNumber = MAX_NOTIFICATION_BADGE_NUMBER;
 433         }
 434
 435         String appMessage = String(L"");
 436
 437         return NotifyImpl(messageText, badgeNumber, appMessage, false);
 438 }
 439
 440 result
 441 _NotificationManagerImpl::Notify(const String& messageText, int badgeNumber, const String& launchArguments) const
 442 {
 443         SysTryReturnResult(NID_APP, badgeNumber >= 0, E_INVALID_ARG, "BadgeNumber is less than 0.");
 444         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 445         SysTryReturnResult(NID_APP,
 446                                           launchArguments != null && launchArguments.GetLength() > 0, E_INVALID_ARG,
 447                                           "launchArguments is less than 0.");
 448
 449         SysTryReturnResult(NID_APP,
 450                                           launchArguments.GetLength() <= MAX_NOTIFICATION_LAUNCH_ARGUMENTS_LENGTH, E_INVALID_ARG,
 451                                           "launchArguments is greater than MAX_NOTIFICATION_LAUNCH_ARGUMENTS_LENGTH.");
 452
 453         if (badgeNumber > MAX_NOTIFICATION_BADGE_NUMBER)
 454         {
 455                 badgeNumber = MAX_NOTIFICATION_BADGE_NUMBER;
 456         }
 457
 458         return NotifyImpl(messageText, badgeNumber, launchArguments, false);
 459 }
 460
 461 int
 462 _NotificationManagerImpl::GetBadgeNumber(const AppId& appId) const
 463 {
 464         bool b = _Aul::IsInstalled(appId);
 465
 466         SysTryReturn(NID_APP, b == true, -1, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] The application %ls is not installed",
 467                                 appId.GetPointer());
 468
 469         char buffer[256];
 470         unsigned int count = 0;
 471
 472         memset(buffer, 0, 256);
 473
 474         snprintf(buffer, 256, "%ls", appId.GetPointer());
 475
 476         std::unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(appId));
 477
 478         badge_error_e badgeError = badge_get_count(pAppId.get(), &count);
 479
 480         if (badgeError == BADGE_ERROR_NONE)
 481         {
 482                 SysLog(NID_APP, "badge_get_count(%d)", count);
 483         }
 484         else
 485         {
 486                 SysLog(NID_APP, "badge_get_count failed(%d).", badgeError);
 487                 return -1;
 488         }
 489
 490         return count;
 491 }
 492
 493
 494 result
 495 _NotificationManagerImpl::NotifyOnBehalf(const AppId& appId, int badgeNumber) const
 496 {
 497         SysTryReturnResult(NID_APP, badgeNumber >= 0, E_INVALID_ARG, "BadgeNumber is less than 0.");
 498
 499         String messageText = String(L"");
 500         String appMessage = String(L"");
 501         return NotifyImpl(appId, messageText, badgeNumber, appMessage);
 502 }
 503
 504 result
 505 _NotificationManagerImpl::NotifyOnBehalf(const AppId& appId, const String& messageText) const
 506 {
 507         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 508
 509         return NotifyImpl(appId, messageText, -1, String(L""));
 510 }
 511
 512 result
 513 _NotificationManagerImpl::NotifyOnBehalf(const AppId& appId, const String& messageText, int badgeNumber) const
 514 {
 515         SysTryReturnResult(NID_APP, badgeNumber >= 0, E_INVALID_ARG, "BadgeNumber is less than 0.");
 516         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 517
 518         return NotifyImpl(appId, messageText, badgeNumber, String(L""));
 519 }
 520
 521 result
 522 _NotificationManagerImpl::NotifyOnBehalf(const AppId& appId, const String& messageText, const String& launchArguments) const
 523 {
 524         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 525         SysTryReturnResult(NID_APP, launchArguments.GetLength() > 0, E_INVALID_ARG, "launchArguments is less than 0.");
 526         SysTryReturnResult(NID_APP,
 527                                           launchArguments.GetLength() <= MAX_NOTIFICATION_LAUNCH_ARGUMENTS_LENGTH, E_INVALID_ARG,
 528                                           "launchArguments is greater than MAX_NOTIFICATION_LAUNCH_ARGUMENTS_LENGTH.");
 529
 530         return NotifyImpl(appId, messageText, -1, launchArguments);
 531 }
 532
 533 result
 534 _NotificationManagerImpl::NotifyOnBehalf(const AppId& appId, const String& messageText, int badgeNumber,
 535                                                                                  const String& launchArguments) const
 536 {
 537         SysTryReturnResult(NID_APP, badgeNumber >= 0, E_INVALID_ARG, "BadgeNumber is less than 0.");
 538         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 539         SysTryReturnResult(NID_APP, launchArguments.GetLength() > 0, E_INVALID_ARG, "launchArguments is less than 0.");
 540         SysTryReturnResult(NID_APP,
 541                                           launchArguments.GetLength() <= MAX_NOTIFICATION_LAUNCH_ARGUMENTS_LENGTH, E_INVALID_ARG,
 542                                           "launchArguments is greater than MAX_NOTIFICATION_LAUNCH_ARGUMENTS_LENGTH.");
 543
 544         return NotifyImpl(appId, messageText, badgeNumber, launchArguments);
 545 }
 546
 547 result
 548 _NotificationManagerImpl::NotifyOngoingActivity(const String& messageText) const
 549 {
 550         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 551
 552         return OngoingImpl(messageText, String(L""));
 553 }
 554
 555 result
 556 _NotificationManagerImpl::NotifyOngoingActivity(const String& messageText, const String& launchArguments) const
 557 {
 558         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 559         SysTryReturnResult(NID_APP, launchArguments.GetLength() > 0, E_INVALID_ARG, "launchArguments is less than 0.");
 560         SysTryReturnResult(NID_APP,
 561                                           launchArguments.GetLength() <= MAX_NOTIFICATION_LAUNCH_ARGUMENTS_LENGTH, E_INVALID_ARG,
 562                                           "launchArguments is greater than MAX_NOTIFICATION_LAUNCH_ARGUMENTS_LENGTH.");
 563
 564         return OngoingImpl(messageText, launchArguments);
 565 }
 566
 567 result
 568 _NotificationManagerImpl::NotifyOngoingActivityOnBehalf(const AppId& appId, const String& messageText) const
 569 {
 570         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 571
 572         return OngoingImpl(appId, messageText, String(L""));
 573 }
 574
 575 result
 576 _NotificationManagerImpl::NotifyOngoingActivityOnBehalf(const AppId& appId, const String& messageText,
 577                                                                                                                 const String& launchArguments) const
 578 {
 579         SysTryReturnResult(NID_APP, messageText.GetLength() > 0, E_INVALID_ARG, "MessageText is less than 0.");
 580         SysTryReturnResult(NID_APP, launchArguments.GetLength() > 0, E_INVALID_ARG, "launchArguments is less than 0.");
 581         SysTryReturnResult(NID_APP,
 582                                           launchArguments.GetLength() <= MAX_NOTIFICATION_LAUNCH_ARGUMENTS_LENGTH, E_INVALID_ARG,
 583                                           "launchArguments is greater than MAX_NOTIFICATION_LAUNCH_ARGUMENTS_LENGTH.");
 584
 585         return OngoingImpl(appId, messageText, launchArguments);
 586 }
 587
 588 result
 589 _NotificationManagerImpl::RemoveOngoingActivityNotification(void)
 590 {
 591         return RemoveImpl(NULL, NOTIFICATION_TYPE_ONGOING);
 592 }
 593
 594 result
 595 _NotificationManagerImpl::RemoveOngoingActivityNotificationOnBehalf(const AppId& appId)
 596 {
 597         return RemoveImpl(appId, true);
 598 }
 599
 600 result
 601 _NotificationManagerImpl::RemoveNotification(void)
 602 {
 603         return RemoveImpl(NULL, NOTIFICATION_TYPE_NOTI);
 604 }
 605
 606 result
 607 _NotificationManagerImpl::RemoveNotificationOnBehalf(const AppId& appId)
 608 {
 609         return RemoveImpl(appId, false);
 610 }
 611
 612 };
 613 };    // Tizen::App