src/Notification/StatusNotification.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <PlatformException.h>
  19 #include <Logger.h>
  20 #include <sstream>
  21 #include <appsvc/appsvc.h>
  22 #include <sstream>
  23
  24 #include <boost/algorithm/string.hpp>
  25 #include "StatusNotification.h"
  26
  27 namespace DeviceAPI {
  28 namespace Notification {
  29
  30 #define DEFAULT_ICON_PATH "/opt/share/icons/default/"
  31 #define MAX_NOTIFICATION_DETAIL_INFO_LENGTH 2
  32 #define MAX_THUMBNAIL_LENGTH 4
  33
  34 extern "C" int service_create_event(bundle *data, struct service_s **service);
  35 //tern "C" int service_to_bundle(service_h service, bundle **data);
  36
  37 //callback functions.
  38 static bool service_extra_data_cb(service_h service, const char *key, void *user_data)
  39 {
  40         LoggerI("OK");
  41         char **value = NULL;
  42         int length = 0;
  43
  44         if (user_data != NULL && key != NULL)
  45         {
  46                 LoggerI("user data & key is existed");
  47
  48                 DeviceAPI::Application::ApplicationControlPtr* appControl =
  49                         (DeviceAPI::Application::ApplicationControlPtr*)(user_data);
  50
  51                 DeviceAPI::Application::ApplicationControlDataPtr data(new DeviceAPI::Application::ApplicationControlData());
  52                 LoggerI("key = " << key);
  53                 std::string keyStr = key;
  54                 std::vector<std::string> keyValue;
  55                 int index = 0;
  56
  57                 if (service_get_extra_data_array((*appControl)->getService_h(), key, &value, &length) == SERVICE_ERROR_NONE)
  58                 {
  59                         LoggerI("extra_data_array length = " << length);
  60
  61                         if (value != NULL && length != 0)
  62                         {
  63                                 LoggerI("extra_data_length = " << length);
  64                                 data->setKey(key);
  65                                 for (index = 0; index < length; index++)
  66                                 {
  67                                         LoggerI("Value=" << value[index]);
  68                                         keyValue.push_back(value[index]);
  69                                 }
  70
  71                                 data->setValue(keyValue);
  72                                 (*appControl)->addAppControlData(data);
  73                         }
  74
  75                         if(value)
  76                                 free(value);
  77                 }
  78         }
  79         return true;
  80 }
  81
  82 StatusNotification::StatusNotification(NotificationType statusType) :
  83         m_notiType(NOTI_TYPE_NONE),
  84         m_service(NULL),
  85         m_notiHandle(NULL),
  86         m_progressType(NOTI_PROGRESS_TYPE_PERCENTAGE),
  87         m_notiUpdated(false),
  88         m_launchFlag(false)
  89 {
  90         LoggerI("statusType =" << statusType);
  91
  92         notification_type_e type = NOTIFICATION_TYPE_NONE;
  93         setNotiType(statusType);
  94
  95         if (statusType == NOTI_TYPE_SIMPLE || statusType == NOTI_TYPE_MUTIPLE || statusType == NOTI_TYPE_THUMBNAIL)
  96         {
  97                 type = NOTIFICATION_TYPE_NOTI;
  98         }
  99         else if ( statusType == NOTI_TYPE_ONGOING || statusType == NOTI_TYPE_PROGRESS)
 100         {
 101                 type = NOTIFICATION_TYPE_ONGOING;
 102         }
 103         else
 104         {
 105                 LoggerI(" invalide noti type");
 106                 throw TypeMismatchException("value is not notification type");
 107         }
 108
 109         //setProgressType(NOTI_PROGRESS_TYPE_PERCENTAGE);       //default
 110
 111         LoggerI("Notification Type : " << type);
 112
 113         notification_h noti = notification_create(type);        //create notificatin.
 114         if ( noti )
 115         {
 116                 LoggerI("noti =" << noti);
 117                 setNotificationHandle((void*)noti);
 118
 119                 if (NOTIFICATION_TYPE_ONGOING ==  type)
 120                 {       //ongoing no ticker.
 121                         LoggerI("ongoing type");
 122                         if ( NOTIFICATION_ERROR_NONE != notification_set_display_applist(noti, NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY |NOTIFICATION_DISPLAY_APP_INDICATOR ))
 123                         {
 124                                 throw UnknownException("can't set notification display applist");
 125                         }
 126                 }
 127
 128         }
 129         else
 130         {
 131                 throw UnknownException("can't make new notification object");
 132         }
 133
 134         //m_detailInfos = new std::vector<NotificationDetailInfo*>();
 135         //m_thumbs = new std::vector<std::string>();
 136
 137 }
 138
 139 StatusNotification::StatusNotification(void* noti) :
 140         m_notiType(NOTI_TYPE_NONE),
 141         m_service(NULL),
 142         m_notiHandle(NULL),
 143         m_progressType(NOTI_PROGRESS_TYPE_PERCENTAGE),
 144         m_notiUpdated(false),
 145         m_launchFlag(false)
 146 {
 147         LoggerI("noti : " << noti);
 148
 149         notification_h notification = (notification_h)noti;
 150
 151         if ( notification )
 152         {
 153                 NotificationType type = NOTI_TYPE_NONE;
 154                 notification_type_e noti_type = NOTIFICATION_TYPE_NONE;
 155                 notification_ly_type_e noti_layout = NOTIFICATION_LY_NONE;
 156
 157                 notification_get_type(notification, &noti_type);
 158                 notification_get_layout(notification, &noti_layout);
 159
 160                 //get type.
 161                 if ( noti_type == NOTIFICATION_TYPE_NOTI )
 162                 {
 163                         if ( noti_layout == NOTIFICATION_LY_NOTI_EVENT_SINGLE ||
 164                                 noti_layout == NOTIFICATION_LY_NOTI_EVENT_MULTIPLE )
 165                         {
 166                                 type = NOTI_TYPE_SIMPLE;
 167                         }
 168                         else if (noti_layout == NOTIFICATION_LY_NOTI_THUMBNAIL)
 169                         {
 170                                 type = NOTI_TYPE_THUMBNAIL;
 171                         }
 172                 }
 173                 else if ( noti_type == NOTIFICATION_TYPE_ONGOING)
 174                 {
 175                         if ( noti_layout == NOTIFICATION_LY_ONGOING_EVENT )
 176                         {
 177                                 type = NOTI_TYPE_ONGOING;
 178                         }
 179                         else if ( noti_layout == NOTIFICATION_LY_ONGOING_PROGRESS)
 180                         {
 181                                 type = NOTI_TYPE_PROGRESS;
 182                         }
 183                 }
 184
 185                 LoggerI(" notification type  =" << type);
 186                 setNotiType(type);
 187                 //setProgressType(NOTI_PROGRESS_TYPE_PERCENTAGE); //default.
 188                 //read Progress type value.
 189                 char *strProgressType = NULL;
 190                 if (NOTIFICATION_ERROR_NONE == notification_get_image(notification, NOTIFICATION_IMAGE_TYPE_LIST_5,  &strProgressType))
 191                 {
 192                         if ( strProgressType )
 193                         {
 194                                 std::string notiProgressType(strProgressType);
 195                                 if( notiProgressType.compare(TIZEN_NOTIFICATION_PROGRESS_TYPE_BYTE) == 0)
 196                                         m_progressType = NOTI_PROGRESS_TYPE_SIZE;
 197                         }
 198                 }
 199
 200                 setNotificationHandle((void*)notification);
 201                 loadThumbnails();
 202                 loadDetailInfos();
 203
 204 #if 0
 205                  if ( type  == NOTI_TYPE_PROGRESS)
 206                 {
 207                         notification_update_progress(notification, NOTIFICATION_PRIV_ID_NONE, getProgressValue());
 208                 }
 209 #endif
 210                 //service
 211                 bundle *bSvc = NULL;
 212
 213                 int ret =  notification_get_execute_option(notification, NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH, NULL, &bSvc);
 214                 LoggerI("ret = " << ret);
 215                 if (ret == NOTIFICATION_ERROR_NONE)
 216                 {
 217                         LoggerI(" bundle = " << bSvc);
 218                         if (bSvc)
 219                         {
 220                                 LoggerI("bundle is valid");
 221                                 int ret = service_create_event(bSvc, &m_service);
 222                                 if (ret != SERVICE_ERROR_NONE)
 223                                 {
 224                                         LoggerI("Service Create Event Error");
 225                                         throw UnknownException("can't make service object");
 226                                 }
 227                         }
 228                 }
 229                 else
 230                 {
 231                         notification_free(notification);
 232                         throw UnknownException("can't get service data");
 233                 }
 234
 235         }
 236         else
 237         {
 238                 throw InvalidValuesException("It is not notification object.");
 239         }
 240
 241 }
 242
 243 StatusNotification::StatusNotification(int privID) :
 244         m_notiType(NOTI_TYPE_NONE),
 245         m_service(NULL),
 246         m_notiHandle(NULL),
 247         m_progressType(NOTI_PROGRESS_TYPE_PERCENTAGE),
 248         m_notiUpdated(false),
 249         m_launchFlag(false)
 250 {
 251         LoggerI("priv ID : " << privID);
 252
 253         notification_h notification = notification_load( NULL, privID); //load notification.
 254         LoggerI(" notification " << notification);
 255
 256         if ( notification )
 257         {
 258                 NotificationType type = NOTI_TYPE_NONE;
 259                 notification_type_e noti_type = NOTIFICATION_TYPE_NONE;
 260                 notification_ly_type_e noti_layout = NOTIFICATION_LY_NONE;
 261
 262                 notification_get_type(notification, &noti_type);
 263                 notification_get_layout(notification, &noti_layout);
 264
 265                 if ( noti_type == NOTIFICATION_TYPE_NOTI )
 266                 {
 267                         if ( noti_layout == NOTIFICATION_LY_NOTI_EVENT_SINGLE ||
 268                                 noti_layout == NOTIFICATION_LY_NOTI_EVENT_MULTIPLE )
 269                         {
 270                                 type = NOTI_TYPE_SIMPLE;
 271                         }
 272                         else if (noti_layout == NOTIFICATION_LY_NOTI_THUMBNAIL)
 273                         {
 274                                 type = NOTI_TYPE_THUMBNAIL;
 275                         }
 276                 }
 277                 else if ( noti_type == NOTIFICATION_TYPE_ONGOING)
 278                 {
 279                         if ( noti_layout == NOTIFICATION_LY_ONGOING_EVENT )
 280                         {
 281                                 type = NOTI_TYPE_ONGOING;
 282                         }
 283                         else if ( noti_layout == NOTIFICATION_LY_ONGOING_PROGRESS)
 284                         {
 285                                 type = NOTI_TYPE_PROGRESS;
 286                         }
 287                 }
 288
 289                 LoggerI(" notification type  =" << type);
 290                 setNotiType(type);
 291                 //setProgressType(NOTI_PROGRESS_TYPE_PERCENTAGE); //default.
 292                 //read Progress type value.
 293                 char *strProgressType = NULL;
 294                 if (NOTIFICATION_ERROR_NONE == notification_get_image(notification, NOTIFICATION_IMAGE_TYPE_LIST_5,  &strProgressType))
 295                 {
 296                         if ( strProgressType )
 297                         {
 298                                 std::string notiProgressType(strProgressType);
 299                                 if( notiProgressType.compare(TIZEN_NOTIFICATION_PROGRESS_TYPE_BYTE) == 0)
 300                                         m_progressType = NOTI_PROGRESS_TYPE_SIZE;
 301                         }
 302                 }
 303
 304                 setNotificationHandle((void*)notification);
 305                 loadThumbnails();
 306                 loadDetailInfos();
 307 #if 0
 308                  if ( type  == NOTI_TYPE_PROGRESS)
 309                 {
 310                         notification_update_progress(notification, NOTIFICATION_PRIV_ID_NONE, getProgressValue());
 311                 }
 312 #endif
 313                 //service
 314                 bundle *bSvc = NULL;
 315
 316                 int ret =  notification_get_execute_option(notification, NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH, NULL, &bSvc);
 317                 LoggerI("ret = " << ret);
 318                 if (ret == NOTIFICATION_ERROR_NONE)
 319                 {
 320                         LoggerI(" bundle = " << bSvc);
 321                         if (bSvc)
 322                         {
 323                                 LoggerI("bundle is valid");
 324                                 int ret = service_create_event(bSvc, &m_service);
 325                                 if (ret != SERVICE_ERROR_NONE)
 326                                 {
 327                                         LoggerI("Service Create Event Error");
 328                                         throw UnknownException("can't make service object");
 329                                 }
 330                         }
 331                 }
 332                 else
 333                 {
 334                         notification_free(notification);
 335                         throw UnknownException("can't get service data");
 336                 }
 337
 338         }
 339         else
 340         {
 341                 throw NotFoundException("It is not notification ID or removed notification");
 342         }
 343
 344 }
 345
 346 StatusNotification::~StatusNotification()
 347 {
 348         LoggerI(" notification = " << m_notiHandle);
 349
 350         //clear thumbnail.
 351         //clearDetailInfos();
 352
 353         if (m_notiHandle)
 354         {
 355                 LoggerI(" service = " << m_service);
 356                 if (m_service != NULL)
 357                 {
 358                         service_destroy(m_service);
 359                         m_service = NULL;
 360                 }
 361
 362                 if (notification_free(m_notiHandle) != NOTIFICATION_ERROR_NONE)
 363                 {
 364                         throw UnknownException("notification free failed...");
 365                 }
 366
 367                 m_notiHandle = NULL;
 368         }
 369 }
 370
 371 int StatusNotification::getID()
 372 {
 373         int id = -1;    // notification not inserted yet.
 374         if (m_notiHandle)
 375         {
 376                 notification_get_id(m_notiHandle, NULL, &id);
 377         }
 378
 379         return id;
 380 }
 381
 382 std::string StatusNotification::getStatusType()
 383 {
 384         std::string type;
 385
 386         if ( NOTI_TYPE_SIMPLE ==  getNotiType())
 387         {
 388                 type = "SIMPLE";
 389         }
 390         else if ( NOTI_TYPE_ONGOING ==  getNotiType())
 391         {
 392                 type = "ONGOING";
 393         }
 394         else if ( NOTI_TYPE_PROGRESS ==  getNotiType())
 395         {
 396                 type = "PROGRESS";
 397         }
 398         else if ( NOTI_TYPE_THUMBNAIL ==  getNotiType())
 399         {
 400                 type = "THUMBNAIL";
 401         }
 402
 403         return type;
 404
 405 }
 406
 407
 408
 409 void StatusNotification::setStatusType(std::string type)
 410 {
 411         LoggerI("type = " << type);
 412
 413         NotificationType notiType = NOTI_TYPE_NONE;
 414
 415         if( type.compare(TIZEN_STATUS_NOTIFICATION_TYPE_SIMPLE) == 0)
 416                 notiType = NOTI_TYPE_SIMPLE;
 417         else if( type.compare(TIZEN_STATUS_NOTIFICATION_TYPE_THUMBNAIL) == 0)
 418                 notiType = NOTI_TYPE_THUMBNAIL;
 419         else if( type.compare(TIZEN_STATUS_NOTIFICATION_TYPE_ONGOING) == 0)
 420                 notiType = NOTI_TYPE_ONGOING;
 421         else if( type.compare(TIZEN_STATUS_NOTIFICATION_TYPE_PROGRESS) == 0)
 422                 notiType = NOTI_TYPE_PROGRESS;
 423         else
 424         throw InvalidValuesException("Invalid Status Type.");
 425
 426         LoggerI("Notification type = " << notiType);
 427         setNotiType(notiType);
 428 }
 429
 430 time_t StatusNotification::getPostedTime()
 431 {
 432         LoggerI("get m_notiHandle = " << m_notiHandle);
 433
 434         time_t postedTime = 0;
 435
 436         if (m_notiHandle)
 437         {
 438                 if (notification_get_insert_time(m_notiHandle, &postedTime) != NOTIFICATION_ERROR_NONE)
 439                 {
 440                         throw UnknownException("get notification posted time error");
 441                 }
 442         }
 443
 444         LoggerI("posted Time =" << ctime(&postedTime));
 445         return postedTime;
 446 }
 447
 448 std::string StatusNotification::getTitle()
 449 {
 450         if (m_notiHandle)
 451         {
 452                 char *title = NULL;
 453
 454                 if (notification_get_text(m_notiHandle,NOTIFICATION_TEXT_TYPE_TITLE, &title) != NOTIFICATION_ERROR_NONE)
 455                 {
 456                         throw UnknownException("get notification title error");
 457                 }
 458
 459                 std::string notiTitle;
 460                 if (title)
 461                 {
 462                         notiTitle = title;
 463                         LoggerI(" get title : " << title);
 464                 }
 465
 466                 return notiTitle;
 467         }
 468         else
 469         {
 470                 throw UnknownException("notification handle is null");
 471         }
 472 }
 473
 474 void StatusNotification::setTitle(std::string title)
 475 {
 476         LoggerI("Title : " << title);
 477         if (m_notiHandle)
 478         {
 479                 LoggerI("get Title : " << getTitle());
 480                 if((getTitle()).compare(title)) //different value.
 481                 {
 482                         if (notification_set_text(m_notiHandle, NOTIFICATION_TEXT_TYPE_TITLE, title.c_str(),
 483                                 NULL, NOTIFICATION_VARIABLE_TYPE_NONE ) != NOTIFICATION_ERROR_NONE)
 484                         {
 485                                 throw UnknownException("set notification title error");
 486                         }
 487
 488                         setUpdatedFlag(true);
 489                 }
 490                 else
 491                 {
 492                         LoggerI(" title = " << title << " getTitle = " << getTitle());
 493                 }
 494         }
 495         else
 496         {
 497                 LoggerD("noti Handle is NULL");
 498                 throw UnknownException("notification handle is null");
 499         }
 500 }
 501
 502 std::string StatusNotification::getContent()
 503 {
 504         LoggerI("get Content handle: " << m_notiHandle);
 505         if (m_notiHandle)
 506         {
 507                 char *content = NULL;
 508
 509                 if (notification_get_text(m_notiHandle, NOTIFICATION_TEXT_TYPE_CONTENT, &content) != NOTIFICATION_ERROR_NONE)
 510                 {
 511                         throw UnknownException("get notification Content error");
 512                 }
 513
 514                 std::string notiContent;
 515
 516                 if(content)
 517                 {
 518                         notiContent = content;
 519                         LoggerI(" get Content : " << content);
 520                 }
 521
 522                 return notiContent;
 523
 524         }
 525         else
 526         {
 527                 throw UnknownException("notification handle is null");
 528         }
 529
 530 }
 531
 532 char* StatusNotification::getStrContent()
 533 {
 534         LoggerI("get Content handle: " << m_notiHandle);
 535         if (m_notiHandle)
 536         {
 537                 char *content = NULL;
 538
 539                 if (notification_get_text(m_notiHandle, NOTIFICATION_TEXT_TYPE_CONTENT, &content) != NOTIFICATION_ERROR_NONE)
 540                 {
 541                         throw UnknownException("get notification Content error");
 542                 }
 543
 544                 return content;
 545         }
 546         else
 547         {
 548                 throw UnknownException("notification handle is null");
 549         }
 550 }
 551
 552 void StatusNotification::setContent(std::string content)
 553 {
 554         LoggerI("Content : " << content);
 555         if (m_notiHandle)
 556         {
 557                 if((getContent()).compare(content))     //different value.
 558                 {
 559                         if (notification_set_text(m_notiHandle, NOTIFICATION_TEXT_TYPE_CONTENT, content.c_str(),
 560                                 NULL, NOTIFICATION_VARIABLE_TYPE_NONE ) != NOTIFICATION_ERROR_NONE)
 561                         {
 562                                 throw UnknownException("set notification content error");
 563                         }
 564                         setUpdatedFlag(true);
 565                 }
 566         }
 567         else
 568         {
 569                 LoggerD("noti Handle is NULL");
 570                 throw UnknownException("notification handle is null");
 571         }
 572 }
 573
 574 std::string StatusNotification::getIconPath()
 575 {
 576
 577         LoggerI("m_notiHandle = " << m_notiHandle);
 578         if (m_notiHandle)
 579         {
 580                 char *iconPath = NULL;
 581                 if (notification_get_image(m_notiHandle, NOTIFICATION_IMAGE_TYPE_ICON,  &iconPath) != NOTIFICATION_ERROR_NONE)
 582                 {
 583                         throw UnknownException("get notification icon path error");
 584                 }
 585
 586                 std::string notiIconPath;
 587                 if (iconPath)
 588                 {
 589                         notiIconPath = iconPath;
 590                         LoggerI("icon Path = " << iconPath);
 591                 }
 592
 593                 //if icon path invalid, return empty string.
 594                 if ( notiIconPath.find(DEFAULT_ICON_PATH,0) == std::string::npos)
 595                         return notiIconPath;
 596                 else
 597                 {
 598                         return std::string(""); //return empty string.
 599                 }
 600         }
 601         else
 602         {
 603                 throw UnknownException("notification handle is null");
 604         }
 605 }
 606
 607 void StatusNotification::setIconPath(const std::string& iconPath)
 608 {
 609         if (m_notiHandle)
 610         {
 611                 LoggerI("icon path = " << iconPath << " origin icon path = " << getIconPath());
 612                 if( getIconPath().compare(iconPath))
 613                 {
 614                         if (notification_set_image(m_notiHandle,NOTIFICATION_IMAGE_TYPE_ICON, iconPath.c_str()) != NOTIFICATION_ERROR_NONE)
 615                         {
 616                                 throw UnknownException("set notification icon error");
 617                         }
 618                         setUpdatedFlag(true);
 619                 }
 620         }
 621         else
 622         {
 623                 LoggerD("noti Handle is NULL");
 624                 throw UnknownException("notification handle is null");
 625         }
 626 }
 627
 628 std::string StatusNotification::getSoundPath()
 629 {
 630         LoggerI("Handle = " << m_notiHandle);
 631
 632         if (m_notiHandle)
 633         {
 634                 const char *soundPath = NULL;
 635                 notification_sound_type_e type = NOTIFICATION_SOUND_TYPE_NONE;
 636
 637                 if (notification_get_sound(m_notiHandle, &type,  &soundPath) != NOTIFICATION_ERROR_NONE)
 638                 {
 639                         throw UnknownException("get notification sound error");
 640                 }
 641
 642                 std::string strSoundPath;
 643                 if (soundPath)
 644                 {
 645                         LoggerI(" soudn type=" << type);
 646                         if ( type == NOTIFICATION_SOUND_TYPE_USER_DATA)
 647                         {
 648                                 LoggerI("soundPath = " << soundPath);
 649                                 strSoundPath = soundPath;
 650                         }
 651                 }
 652
 653                 LoggerI("soundPath :" << strSoundPath);
 654                 return strSoundPath;
 655
 656         }
 657         else
 658         {
 659                 LoggerD("noti Handle is NULL");
 660                 throw UnknownException("notification handle is null");
 661         }
 662 }
 663
 664 void StatusNotification::setSoundPath(const std::string& sound)
 665 {
 666         if (m_notiHandle)
 667         {
 668                 LoggerI("sound path = " << sound << " origin sound path = " << getSoundPath());
 669
 670                 if( getSoundPath().compare(sound))
 671                 {
 672                         if (notification_set_sound(m_notiHandle,NOTIFICATION_SOUND_TYPE_USER_DATA, sound.c_str()) != NOTIFICATION_ERROR_NONE)
 673                         {
 674                                 throw UnknownException("set notification sound error");
 675                         }
 676                         setUpdatedFlag(true);
 677                 }
 678
 679                 if (sound.empty())
 680                 {
 681                     LoggerI("sound path is NULL");
 682                     if ( NOTI_TYPE_ONGOING == getNotiType() || NOTI_TYPE_PROGRESS == getNotiType())
 683                     {
 684                                 LoggerI("Ongoing Type" );
 685                                 if (notification_set_sound(m_notiHandle,NOTIFICATION_SOUND_TYPE_NONE, NULL) != NOTIFICATION_ERROR_NONE)
 686                                 {
 687                                         throw UnknownException("set notification sound error");
 688                                 }
 689                     }
 690                     else
 691                     {
 692                                 if (notification_set_sound(m_notiHandle,NOTIFICATION_SOUND_TYPE_DEFAULT, sound.c_str()) != NOTIFICATION_ERROR_NONE)
 693                                 {
 694                                         throw UnknownException("set notification sound error");
 695                                 }
 696                     }
 697
 698                 }
 699         }
 700         else
 701         {
 702                 LoggerD("noti Handle is NULL");
 703                 throw UnknownException("notification handle is null");
 704         }
 705 }
 706
 707 bool StatusNotification::getDefaultVibration()
 708 {
 709         LoggerI("getDefaultVibration");
 710         if (m_notiHandle)
 711         {
 712                 notification_vibration_type_e vib_type;
 713                 if (notification_get_vibration(m_notiHandle, &vib_type,  NULL) != NOTIFICATION_ERROR_NONE)
 714                 {
 715                         throw UnknownException("set notification sound error");
 716                 }
 717
 718                 if (NOTIFICATION_VIBRATION_TYPE_DEFAULT == vib_type  || NOTIFICATION_VIBRATION_TYPE_USER_DATA == vib_type)
 719                 {
 720                         return true;
 721                 }
 722                 else
 723                 {
 724                         return false;
 725                 }
 726         }
 727         else
 728         {
 729                 LoggerD("noti Handle is NULL");
 730                 throw UnknownException("notification handle is null");
 731         }
 732
 733         return false;
 734 }
 735
 736 void StatusNotification::setDefaultVibration(const bool& vibration)
 737 {
 738     LoggerI("vibration = " << vibration);
 739         if (m_notiHandle)
 740         {
 741                 notification_vibration_type_e vib_type = NOTIFICATION_VIBRATION_TYPE_NONE;
 742                 LoggerI("old vibration = " << getDefaultVibration());
 743                 if (getDefaultVibration() != vibration)
 744                 {
 745                         if (vibration)
 746                         {
 747                                 vib_type = NOTIFICATION_VIBRATION_TYPE_DEFAULT;
 748                         }
 749                         else
 750                         {
 751                                 vib_type = NOTIFICATION_VIBRATION_TYPE_NONE;
 752                         }
 753                         LoggerI("type vibration type= " << vib_type);
 754
 755                         if (notification_set_vibration(m_notiHandle, vib_type , NULL) != NOTIFICATION_ERROR_NONE)
 756                         {
 757                                 throw UnknownException("set notification sound error");
 758                         }
 759                         setUpdatedFlag(true);
 760                 }
 761         }
 762         else
 763         {
 764                 LoggerD("noti Handle is NULL");
 765                 throw UnknownException("notification handle is null");
 766         }
 767
 768 }
 769
 770 DeviceAPI::Application::ApplicationControlPtr StatusNotification::getApplicationControl()
 771 {
 772
 773     service_h service = NULL;
 774     char *tempStr = NULL;
 775
 776     DeviceAPI::Application::ApplicationControlPtr appControl(new DeviceAPI::Application::ApplicationControl());
 777
 778     try {
 779                 if (m_service)
 780                 {
 781                         appControl->setService_h(m_service);
 782                         // mandatory
 783                         if(service_get_operation(m_service, &tempStr) == SERVICE_ERROR_NONE)
 784                         {
 785                                 LoggerD("Operation Str = " << tempStr);
 786                                 if (tempStr)
 787                                 {
 788                                         appControl->setOperation(tempStr);
 789                                         free(tempStr);
 790                                         tempStr = NULL;
 791                                 }
 792                         }
 793
 794                         // optional
 795                         if (service_get_mime(m_service, &tempStr) == SERVICE_ERROR_NONE)
 796                         {
 797                                 LoggerD("Mime Str = " << tempStr);
 798                                 if (tempStr)
 799                                 {
 800                                         appControl->setMime(tempStr);
 801                                         free(tempStr);
 802                                         tempStr = NULL;
 803                                 }
 804                         }
 805
 806                         // optional
 807                         if (service_get_uri(m_service, &tempStr) == SERVICE_ERROR_NONE)
 808                         {
 809                                 LoggerD("Uri Str = " << tempStr);
 810                                 if (tempStr)
 811                                 {
 812                                         appControl->setUri(tempStr);
 813                                         free(tempStr);
 814                                         tempStr = NULL;
 815                                 }
 816                         }
 817
 818                         if (service_get_category(m_service, &tempStr) == SERVICE_ERROR_NONE)
 819                         {
 820                                 LoggerD("Category Str = " << tempStr);
 821                                 if (tempStr)
 822                                 {
 823                                         appControl->setCategory(tempStr);
 824                                         free(tempStr);
 825                                         tempStr = NULL;
 826                                 }
 827                         }
 828
 829                         // optional
 830                         if ( service_foreach_extra_data(m_service, service_extra_data_cb,(void*)&appControl) != SERVICE_ERROR_NONE)
 831                         {
 832                                 ThrowMsg(WrtDeviceApis::Commons::UnknownException, "get notification service uri error");
 833                         }
 834
 835                         return appControl;
 836                 }
 837
 838         }
 839         Catch (WrtDeviceApis::Commons::Exception)
 840         {
 841                 if (tempStr)
 842                 {
 843                         free(tempStr);
 844                         tempStr = NULL;
 845                 }
 846
 847                 if (service)
 848                 {
 849                         free(service);
 850                         service = NULL;
 851                 }
 852
 853                 LoggerW(_rethrown_exception.GetMessage());
 854         }
 855
 856     return appControl;
 857 }
 858
 859 void StatusNotification::setApplicationControl(DeviceAPI::Application::ApplicationControlPtr control)
 860 {
 861         LoggerI("Entered m_service : " << m_service << " control : " << control);
 862
 863         //delete old service.
 864         if (m_service)
 865         {
 866                 service_destroy(m_service);
 867                 m_service = NULL;
 868         }
 869
 870         if(service_create(&m_service) != SERVICE_ERROR_NONE)
 871         {
 872                 throw UnknownException("service creation error");
 873         }
 874         else
 875         {
 876                 LoggerI("getOperation : " << control->getOperation().c_str());
 877                 if (control->getOperation().size() != 0)
 878                 {
 879                         m_launchFlag = true;            //default attribute
 880                         if (service_set_operation(m_service, control->getOperation().c_str()) != SERVICE_ERROR_NONE)
 881                         {
 882                                 throw UnknownException("service set operation error");
 883                         }
 884                 }
 885
 886                 // optional
 887                 LoggerI("getUri : " << control->getUri().c_str());
 888                 if (control->getUri().size() != 0)
 889                 {
 890                         if (service_set_uri(m_service, control->getUri().c_str() ) != SERVICE_ERROR_NONE)
 891                         {
 892                                 throw UnknownException("service set uri error");
 893                         }
 894                 }
 895
 896                 // optional
 897                 LoggerI("getMime : " << control->getMime().c_str());
 898                 if (control->getMime().size() != 0)
 899                 {
 900                         if (service_set_mime(m_service, control->getMime().c_str() ) != SERVICE_ERROR_NONE)
 901                         {
 902                                 throw UnknownException("service set mime error");
 903                         }
 904                 }
 905
 906                 LoggerI("Category : " << control->getCategory().c_str());
 907                 if (control->getCategory().size() != 0)
 908                 {
 909                         if (service_set_category(m_service, control->getCategory().c_str() ) != SERVICE_ERROR_NONE)
 910                         {
 911                                 throw UnknownException("service set mime error");
 912                         }
 913                 }
 914 #if 0
 915                 //remove key
 916                 if ( service_foreach_extra_data(m_service, service_extra_data_delete_cb, NULL) != SERVICE_ERROR_NONE)
 917                 {
 918                         throw UnknownException("get notification service uri error");
 919                 }
 920 #endif
 921                 std::vector<DeviceAPI::Application::ApplicationControlDataPtr> appControlDataArray = control->getAppControlDataArray();
 922                 size_t index = 0;
 923
 924                 LoggerI (" App Control Datas Count : " << appControlDataArray.size());
 925
 926                 DeviceAPI::Application::ApplicationControlDataArray::iterator iter;
 927
 928                 for(iter = appControlDataArray.begin(); iter != appControlDataArray.end(); iter++)
 929                 {
 930                         DeviceAPI::Application::ApplicationControlDataPtr appControlData = *iter;
 931                         std::string key = appControlData->getKey();
 932                         LoggerI(" key : " << key);
 933
 934                         if (key.empty())
 935                                 continue;
 936
 937                         std::vector<std::string> value = appControlDataArray[index]->getValue();
 938                         const char **arrayValue = (const char**)calloc(sizeof(char*), value.size());
 939
 940                         for (size_t indexArray = 0; indexArray < value.size(); indexArray++)
 941                         {
 942                                 arrayValue[indexArray] = (char*)value[indexArray].c_str();
 943                                 LoggerI( " value : " << arrayValue[indexArray]);
 944                         }
 945
 946                         const char* strKey = key.c_str();
 947                         LoggerI( " value size: " << value.size());
 948                         if (service_add_extra_data_array(m_service, strKey, arrayValue, value.size()) != SERVICE_ERROR_NONE)
 949                         {
 950                                 throw UnknownException("service set extra data error");
 951                         }
 952
 953                         if (arrayValue)
 954                                 free(arrayValue);
 955                 }
 956
 957 #if 0
 958                 bundle *bundle_data=NULL;
 959
 960                 if(service_to_bundle(m_service, &bundle_data) != SERVICE_ERROR_NONE)
 961                 {
 962                         throw UnknownException("service get bundle");
 963                 }
 964
 965                 LoggerD("bundle_data : " << bundle_data);
 966
 967                 if (bundle_data)
 968                 {
 969                         notification_set_execute_option(m_notiHandle, NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH,
 970                                 NULL,NULL, bundle_data);
 971                 }
 972 #endif
 973
 974         }
 975
 976 }
 977
 978 void StatusNotification::setApplicationId(const std::string& appId)
 979 {
 980         LoggerI("m_service = "  << m_service << " appId = " << appId);
 981         if (!m_service)
 982         {
 983                 if (service_create(&m_service) != SERVICE_ERROR_NONE)
 984                 {
 985                         LoggerW("Create Service Failed..");
 986                         throw UnknownException("service creation error");
 987                 }
 988         }
 989
 990         if (m_service)
 991         {
 992                 if (!appId.empty())
 993                 {
 994                         m_launchFlag = true;
 995                         if (service_set_app_id(m_service, appId.c_str())!= SERVICE_ERROR_NONE)
 996                         {
 997                                 throw UnknownException("service set appId error");
 998                         }
 999                 }
1000         }
1001
1002 }
1003
1004 std::string StatusNotification::getApplicationId()
1005 {
1006         std::string retString;
1007         char* appIdStr = NULL;
1008 #if 0
1009         service_h service = NULL;
1010
1011         if (m_service != NULL)
1012         {
1013                 int retcode;
1014                 retcode = service_clone(&service, m_service);
1015
1016                 if (retcode != SERVICE_ERROR_NONE)
1017                 {
1018                         if (retcode == SERVICE_ERROR_OUT_OF_MEMORY)
1019                         {
1020                                 LoggerW("SERVICE_ERROR_OUT_OF_MEMORY");
1021                         }
1022                         else
1023                         {
1024                                 LoggerW("UI_NOTIFICATION_ERROR_INVALID_PARAMETER");
1025                         }
1026                         throw UnknownException ("get notification service error ");
1027                 }
1028                 else
1029                 {
1030                         if (service == NULL)
1031                         {
1032                                 throw UnknownException ("get notification service ok, but service null");
1033                         }
1034                 }
1035         }
1036 #endif
1037         if (m_service != NULL)
1038         {
1039                 if (service_get_app_id(m_service, &appIdStr) != SERVICE_ERROR_NONE)
1040                 {
1041                         throw UnknownException ("get a appId error");
1042                 }
1043
1044                 if (appIdStr != NULL)
1045                 {
1046                         retString = appIdStr;
1047                         free(appIdStr);
1048                 }
1049         }
1050         LoggerI(retString);
1051
1052         return retString;
1053
1054 }
1055
1056 double StatusNotification::getProgressValue()
1057 {
1058         double value = 0.0;
1059
1060         if (m_notiHandle)
1061         {
1062                 NotificationProgressType progressType = getProgressType();
1063
1064                 if (progressType == NOTI_PROGRESS_TYPE_SIZE)
1065                 {
1066                         if (notification_get_size(m_notiHandle, &value) != NOTIFICATION_ERROR_NONE)
1067                         {
1068                                 throw UnknownException("get notification size error");
1069                         }
1070                         LoggerI("Size Val = " << value);
1071                 }
1072                 else if ( progressType == NOTI_PROGRESS_TYPE_PERCENTAGE )
1073                 {
1074                         if (notification_get_progress(m_notiHandle, &value) != NOTIFICATION_ERROR_NONE)
1075                         {
1076                                 throw UnknownException("get notification percentage error");
1077                         }
1078                         LoggerI("Percentage Val = " << value);
1079                 }
1080                 else
1081                 {
1082                         throw UnknownException("get notification progress type error");
1083                 }
1084         }
1085         else
1086         {
1087                 LoggerD("noti Handle is NULL");
1088         }
1089         LoggerI("value = " << value);
1090         return value;
1091
1092 }
1093
1094 void StatusNotification::setProgressValue(const double &progressValue)
1095 {
1096         if (m_notiHandle)
1097         {
1098                 NotificationProgressType progressType = getProgressType();
1099                 LoggerI("Progress Type : " << progressType);
1100
1101                 double val = getProgressValue();
1102                 LoggerI("Progress value = " << progressValue << " origin Progress Value =" << val);
1103
1104                 if (progressType == NOTI_PROGRESS_TYPE_SIZE)
1105                 {
1106                         if (notification_set_size(m_notiHandle, progressValue) != NOTIFICATION_ERROR_NONE)
1107                         {
1108                                 throw UnknownException("set notification progress size error");
1109                         }
1110                 }
1111                 else if ( progressType == NOTI_PROGRESS_TYPE_PERCENTAGE )
1112                 {
1113                         if (notification_set_progress(m_notiHandle, progressValue) != NOTIFICATION_ERROR_NONE)
1114                         {
1115                                 throw UnknownException("set notification percentage error");
1116                         }
1117                 }
1118                 else
1119                 {
1120                         throw UnknownException("get notification progress type error");
1121                 }
1122         }
1123         else
1124         {
1125                 LoggerD("noti Handle is NULL");
1126                 throw UnknownException( "notification handle is null");
1127         }
1128 }
1129
1130 NotificationProgressType StatusNotification::getProgressType()
1131 {
1132         return m_progressType;
1133 }
1134
1135 void StatusNotification::setProgressType(NotificationProgressType type)
1136 {
1137
1138         if (m_notiHandle)
1139         {
1140                 LoggerI(" NotificationProgressType = " << type);
1141
1142                 std::string progressType;
1143
1144                 if ( type == NOTI_PROGRESS_TYPE_PERCENTAGE)
1145                 {
1146                         progressType = TIZEN_NOTIFICATION_PROGRESS_TYPE_PERCENTAGE;
1147                 }
1148                 else if ( type == NOTI_PROGRESS_TYPE_SIZE)
1149                 {
1150                         progressType = TIZEN_NOTIFICATION_PROGRESS_TYPE_BYTE;
1151                 }
1152                 else
1153                 {
1154                         throw TypeMismatchException("Invalid Progress Type.");
1155                 }
1156
1157                 if (notification_set_image(m_notiHandle,NOTIFICATION_IMAGE_TYPE_LIST_5, progressType.c_str()) != NOTIFICATION_ERROR_NONE)
1158                 {
1159                         throw UnknownException("set notification sound error");
1160                 }
1161
1162                 m_progressType = type;
1163         }
1164         else
1165         {
1166                 LoggerD("noti Handle is NULL");
1167                 throw UnknownException("notification handle is null");
1168         }
1169
1170 }
1171
1172 std::string StatusNotification::getSubIconPath()
1173 {
1174         LoggerI("Handle = " << m_notiHandle);
1175         if (m_notiHandle)
1176         {
1177                 char *subIconPath = NULL;
1178
1179                 if (notification_get_image(m_notiHandle, NOTIFICATION_IMAGE_TYPE_ICON_SUB,  &subIconPath) != NOTIFICATION_ERROR_NONE)
1180                 {
1181                         throw UnknownException("get notification sub icon error");
1182                 }
1183
1184                 std::string notiSubIconPath;
1185                 if(subIconPath)
1186                         notiSubIconPath = subIconPath;
1187                 return notiSubIconPath;
1188         }
1189         else
1190         {
1191                 throw UnknownException("notification handle is null");
1192         }
1193
1194 }
1195
1196 void StatusNotification::setSubIconPath(const std::string& subIconPath)
1197 {
1198         if (m_notiHandle)
1199         {
1200                 LoggerI(" subIconPath = " << subIconPath << " origin SubIconPath = " << getSubIconPath());
1201
1202                 if( getSubIconPath().compare(subIconPath))
1203                 {
1204                         if (notification_set_image(m_notiHandle,NOTIFICATION_IMAGE_TYPE_ICON_SUB, subIconPath.c_str()) != NOTIFICATION_ERROR_NONE)
1205                         {
1206                                 throw UnknownException("set notification sound error");
1207                         }
1208                         setUpdatedFlag(true);
1209                 }
1210         }
1211         else
1212         {
1213                 LoggerD("noti Handle is NULL");
1214                 throw UnknownException("notification handle is null");
1215         }
1216 }
1217
1218 #if 0
1219 std::string StatusNotification::getInformation(int index)
1220 {
1221         if (m_notiHandle)
1222         {
1223                 notification_text_type_e type = NOTIFICATION_TEXT_TYPE_NONE;
1224                 switch (index)
1225                 {
1226                         case 0:
1227                                 type = NOTIFICATION_TEXT_TYPE_INFO_1;
1228                                 break;
1229                         case 1:
1230                                 type = NOTIFICATION_TEXT_TYPE_INFO_2;
1231                                 break;
1232                         case 2:
1233                                 type = NOTIFICATION_TEXT_TYPE_INFO_3;
1234                                 break;
1235                         default :
1236                                 type = NOTIFICATION_TEXT_TYPE_NONE;
1237                 }
1238                 char *info = NULL;
1239
1240                 if (NOTIFICATION_TEXT_TYPE_NONE != type && notification_get_text(m_notiHandle, type, &info) != NOTIFICATION_ERROR_NONE)
1241                 {
1242                         throw UnknownException("get notification information error");
1243                 }
1244
1245                 std::string strInfo;
1246                 if (info)
1247                         strInfo = info;
1248                 LoggerD(" info " << strInfo);
1249                 return strInfo;
1250
1251         }
1252         else
1253         {
1254                 LoggerD("noti Handle is NULL");
1255                 throw UnknownException("notification handle is null");
1256         }
1257
1258 }
1259
1260 void StatusNotification::setInformation( const std::string& info, int index)
1261 {
1262
1263         if (m_notiHandle)
1264         {
1265                 int idx = index;
1266                 LoggerD(" index : " << idx);
1267                 LoggerD(" log : " << info);
1268                 notification_text_type_e type = NOTIFICATION_TEXT_TYPE_NONE;
1269
1270                 switch (idx)
1271                 {
1272                         case 0:
1273                                 type = NOTIFICATION_TEXT_TYPE_INFO_1;
1274                                 break;
1275                         case 1:
1276                                 type = NOTIFICATION_TEXT_TYPE_INFO_2;
1277                                 break;
1278                         case 2:
1279                                 type = NOTIFICATION_TEXT_TYPE_INFO_3;
1280                                 break;
1281                         default :
1282                                 type = NOTIFICATION_TEXT_TYPE_NONE;
1283                 }
1284
1285                 if ( type != NOTIFICATION_TEXT_TYPE_NONE)
1286                 {
1287                         if (getInformation(idx).compare(info))
1288                         {
1289                                 if (notification_set_text(m_notiHandle, type, info.c_str(),
1290                                         NULL, NOTIFICATION_VARIABLE_TYPE_NONE) != NOTIFICATION_ERROR_NONE)
1291                                 {
1292                                         throw UnknownException("set notification sound error");
1293                                 }
1294                                 setUpdatedFlag(true);
1295                         }
1296                 }
1297         }
1298         else
1299         {
1300                 LoggerD("noti Handle is NULL");
1301                 throw UnknownException("notification handle is null");
1302         }
1303 }
1304
1305 std::string StatusNotification::getSubInformation(int index)
1306 {
1307
1308         if (m_notiHandle)
1309         {
1310                 notification_text_type_e type = NOTIFICATION_TEXT_TYPE_NONE;
1311                 switch (index)
1312                 {
1313                         case 0:
1314                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_1;
1315                                 break;
1316                         case 1:
1317                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_2;
1318                                 break;
1319                         case 2:
1320                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_3;
1321                                 break;
1322                         default :
1323                                 type = NOTIFICATION_TEXT_TYPE_NONE;
1324                 }
1325
1326                 char *subInfo = NULL;
1327
1328                 if (NOTIFICATION_TEXT_TYPE_NONE != type && notification_get_text(m_notiHandle, type, &subInfo) != NOTIFICATION_ERROR_NONE)
1329                 {
1330                         throw UnknownException( "get notification sub information error");
1331                 }
1332
1333                 std::string strSubInfo;
1334                 if (subInfo)
1335                         strSubInfo = subInfo;
1336                 LoggerD(" subInfo " << strSubInfo);
1337                 return strSubInfo;
1338
1339         }
1340         else
1341         {
1342                 LoggerD("noti Handle is NULL");
1343                 throw UnknownException( "notification handle is null");
1344         }
1345
1346 }
1347
1348 void StatusNotification::setSubInformation( const std::string& subInfo, int index)
1349 {
1350         if (m_notiHandle)
1351         {
1352                 int idx = index;
1353                 LoggerD(" index : " << idx);
1354                 LoggerD(" log : " << subInfo);
1355                 notification_text_type_e type = NOTIFICATION_TEXT_TYPE_NONE;
1356
1357                 switch (idx)
1358                 {
1359                         case 0:
1360                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_1;
1361                                 break;
1362                         case 1:
1363                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_2;
1364                                 break;
1365                         case 2:
1366                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_3;
1367                                 break;
1368                         default :
1369                                 type = NOTIFICATION_TEXT_TYPE_NONE;
1370                 }
1371
1372                 if ( type != NOTIFICATION_TEXT_TYPE_NONE)
1373                 {
1374                         if (getSubInformation(idx).compare(subInfo))
1375                         {
1376                                 if (notification_set_text(m_notiHandle, type, subInfo.c_str(),
1377                                         NULL, NOTIFICATION_VARIABLE_TYPE_NONE) != NOTIFICATION_ERROR_NONE)
1378                                 {
1379                                         throw UnknownException( "set notification sound error");
1380                                 }
1381                                 setUpdatedFlag(true);
1382                         }
1383                 }
1384         }
1385         else
1386         {
1387                 LoggerD("noti Handle is NULL");
1388                 throw UnknownException( "notification handle is null");
1389         }
1390
1391 }
1392 #endif
1393
1394 void StatusNotification::loadThumbnails()
1395 {
1396         if (m_notiHandle)
1397         {
1398                 if (!m_thumbs.empty())
1399                         m_thumbs.clear();
1400
1401                 char *thumb = NULL;
1402                 if (notification_get_image(m_notiHandle, NOTIFICATION_IMAGE_TYPE_LIST_1, &thumb) != NOTIFICATION_ERROR_NONE)
1403                 {
1404                         throw UnknownException( "get notification thumbnail error");
1405                 }
1406                 if (thumb)
1407                         m_thumbs.push_back(thumb);
1408                 //else
1409                 //      m_thumbs.push_back(std::string("")); //set empty
1410                 thumb = NULL;
1411
1412                 if (notification_get_image(m_notiHandle, NOTIFICATION_IMAGE_TYPE_LIST_2, &thumb) != NOTIFICATION_ERROR_NONE)
1413                 {
1414                         throw UnknownException( "get notification sub information error");
1415                 }
1416                 if (thumb)
1417                         m_thumbs.push_back(thumb);
1418                 //else
1419                 //      m_thumbs.push_back(std::string("")); //set empty
1420                 thumb = NULL;
1421
1422                 if (notification_get_image(m_notiHandle, NOTIFICATION_IMAGE_TYPE_LIST_3, &thumb) != NOTIFICATION_ERROR_NONE)
1423                 {
1424                         throw UnknownException( "get notification sub information error");
1425                 }
1426
1427                 if (thumb)
1428                         m_thumbs.push_back(thumb);
1429                 //else
1430                 //      m_thumbs.push_back(std::string("")); //set empty
1431                 thumb = NULL;
1432
1433                 if (notification_get_image(m_notiHandle, NOTIFICATION_IMAGE_TYPE_LIST_4, &thumb) != NOTIFICATION_ERROR_NONE)
1434                 {
1435                         throw UnknownException( "get notification sub information error");
1436                 }
1437
1438                 if (thumb)
1439                         m_thumbs.push_back(thumb);
1440                 //else
1441                 //      m_thumbs.push_back(std::string("")); //set empty
1442                 thumb = NULL;
1443 #if 0
1444                 if (notification_get_image(m_notiHandle, NOTIFICATION_IMAGE_TYPE_LIST_5, &thumb) != NOTIFICATION_ERROR_NONE)
1445                 {
1446                         throw UnknownException( "get notification sub information error");
1447                 }
1448
1449                 if (thumb)
1450                         m_thumbs.push_back(thumb);
1451                 else
1452                         m_thumbs.push_back(std::string("")); //set empty
1453                 thumb = NULL;
1454 #endif
1455
1456         }
1457         else
1458         {
1459                 LoggerD("noti Handle is NULL");
1460                 throw UnknownException( "notification handle is null");
1461         }
1462 }
1463
1464 std::vector<std::string> StatusNotification::getThumbnails()
1465 {
1466         LoggerI(" thumbnail Size : " << m_thumbs.size());
1467         return m_thumbs;
1468 }
1469
1470 std::string StatusNotification::getThumbnail(int index)
1471 {
1472         if (m_notiHandle)
1473         {
1474                 LoggerI(" index : " << index);
1475
1476                 notification_image_type_e type = NOTIFICATION_IMAGE_TYPE_NONE;
1477
1478                 switch (index)
1479                 {
1480                         case 0:
1481                                 type = NOTIFICATION_IMAGE_TYPE_LIST_1;
1482                                 break;
1483                         case 1:
1484                                 type = NOTIFICATION_IMAGE_TYPE_LIST_2;
1485                                 break;
1486                         case 2:
1487                                 type = NOTIFICATION_IMAGE_TYPE_LIST_3;
1488                                 break;
1489                         case 3:
1490                                 type = NOTIFICATION_IMAGE_TYPE_LIST_4;
1491                                 break;
1492                         case 4:
1493                                 type = NOTIFICATION_IMAGE_TYPE_LIST_5;
1494                                 break;
1495                         default :
1496                                 type = NOTIFICATION_IMAGE_TYPE_NONE;
1497                 }
1498
1499                 if ( type != NOTIFICATION_IMAGE_TYPE_NONE)
1500                 {
1501                         char *thumb = NULL;
1502                         if (notification_get_image(m_notiHandle, type, &thumb) != NOTIFICATION_ERROR_NONE)
1503                         {
1504                                 throw UnknownException( "set notification thumbnail error");
1505                         }
1506
1507                         std::string thumbnail;
1508                         if(thumb)
1509                                 thumbnail = thumb;
1510                         return thumbnail;
1511                 }
1512                 else
1513                 {
1514                         throw UnknownException( "notification handle is null");
1515                 }
1516
1517         }
1518         else
1519         {
1520                 LoggerD("noti Handle is NULL");
1521                 throw UnknownException( "notification handle is null");
1522         }
1523 #if 0
1524         if (m_thumbs.size() > index)
1525                 return m_thumbs[index];
1526         else
1527                 return std::string("");
1528 #endif
1529
1530 }
1531
1532 void StatusNotification::setThumbnails(std::vector<std::string> thumbs)
1533 {
1534         LoggerI("set thumbnails");
1535         if (m_notiHandle)
1536         {
1537                 std::vector<std::string>::iterator it;
1538
1539                 int idx = 0;
1540                 for (it = thumbs.begin(); it < thumbs.end(); ++it)
1541                 {
1542                         std::string str = *it;
1543                         if ( idx < MAX_THUMBNAIL_LENGTH )
1544                                 setThumbnail(str, idx); //set notification's thumbnail value.
1545                         idx ++;
1546                 }
1547
1548                 m_thumbs = thumbs;
1549         }
1550         else
1551         {
1552                 LoggerD("noti Handle is NULL");
1553                 throw UnknownException( "notification handle is null");
1554         }
1555 }
1556
1557 void StatusNotification::setThumbnail( const std::string& thumb, int index)
1558 {
1559         if (m_notiHandle)
1560         {
1561                 LoggerI(" index : " << index);
1562                 LoggerI(" thumb : " << thumb);
1563                 notification_image_type_e type = NOTIFICATION_IMAGE_TYPE_NONE;
1564
1565                 switch (index)
1566                 {
1567                         case 0:
1568                                 type = NOTIFICATION_IMAGE_TYPE_LIST_1;
1569                                 break;
1570                         case 1:
1571                                 type = NOTIFICATION_IMAGE_TYPE_LIST_2;
1572                                 break;
1573                         case 2:
1574                                 type = NOTIFICATION_IMAGE_TYPE_LIST_3;
1575                                 break;
1576                         case 3:
1577                                 type = NOTIFICATION_IMAGE_TYPE_LIST_4;
1578                                 break;
1579                         case 4:
1580                                 type = NOTIFICATION_IMAGE_TYPE_LIST_5;
1581                                 break;
1582                         default :
1583                                 type = NOTIFICATION_IMAGE_TYPE_NONE;
1584                 }
1585
1586                 if ( type != NOTIFICATION_IMAGE_TYPE_NONE)
1587                 {
1588                         if (getThumbnail(index).compare(thumb))
1589                         {
1590                                 if (notification_set_image(m_notiHandle, type, thumb.c_str()) != NOTIFICATION_ERROR_NONE)
1591                                 {
1592                                         throw UnknownException( "set notification thumbnail error");
1593                                 }
1594                                 setUpdatedFlag(true);
1595                         }
1596                 }
1597         }
1598 }
1599
1600 std::string StatusNotification::getBackground()
1601 {
1602         LoggerI(" Handle : " << m_notiHandle);
1603
1604         if (m_notiHandle)
1605         {
1606                 char *background = NULL;
1607
1608                 if (notification_get_image(m_notiHandle, NOTIFICATION_IMAGE_TYPE_BACKGROUND, &background) != NOTIFICATION_ERROR_NONE)
1609                 {
1610                         throw UnknownException( "get notification background error");
1611                 }
1612
1613                 std::string notiBackground;
1614                 if (background)
1615                         notiBackground = background;
1616                 return notiBackground;
1617         }
1618         else
1619         {
1620                 LoggerD("noti Handle is NULL");
1621                 throw UnknownException( "notification handle is null");
1622         }
1623
1624 }
1625
1626 void StatusNotification::setBackground(const std::string imagePath)
1627 {
1628         LoggerI(" imagePath : " << imagePath);
1629         if (m_notiHandle)
1630         {
1631                 if (getBackground().compare(imagePath))
1632                 {
1633                         if (notification_set_image(m_notiHandle,NOTIFICATION_IMAGE_TYPE_BACKGROUND, imagePath.c_str()) != NOTIFICATION_ERROR_NONE)
1634                         {
1635                                 throw UnknownException( "set notification sound error");
1636                         }
1637                         setUpdatedFlag(true);
1638                 }
1639         }
1640         else
1641         {
1642                 LoggerD("noti Handle is NULL");
1643                 throw UnknownException( "notification handle is null");
1644         }
1645 }
1646
1647 long StatusNotification::getNumber()
1648 {
1649         LoggerI("Handle = " << m_notiHandle);
1650         if (m_notiHandle)
1651         {
1652                 long number = 0;
1653                 char *strNumber = NULL;
1654
1655                 if (notification_get_text(m_notiHandle, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, &strNumber) != NOTIFICATION_ERROR_NONE)
1656                 {
1657                         throw UnknownException( "get notification background error");
1658                 }
1659
1660                 if (strNumber)
1661                         std::istringstream(strNumber) >> number;
1662                 else
1663                         LoggerI("Number Is NULL");
1664
1665                 LoggerI("number = " << number);
1666
1667                 return number;
1668         }
1669         else
1670         {
1671                 LoggerD("noti Handle is NULL");
1672                 return 0;
1673         }
1674 }
1675
1676 const char* StatusNotification::getStrNumber()
1677 {
1678         LoggerI("Handle = " << m_notiHandle);
1679         if (m_notiHandle)
1680         {
1681                 char *strNumber = NULL;
1682
1683                 if (notification_get_text(m_notiHandle, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, &strNumber) != NOTIFICATION_ERROR_NONE)
1684                 {
1685                         throw UnknownException( "get notification background error");
1686                 }
1687
1688                 if (!strNumber)
1689                 {
1690                         return NULL;
1691                 }
1692
1693                 return strNumber;
1694         }
1695         else
1696         {
1697                 LoggerD("noti Handle is NULL");
1698                 return NULL;
1699         }
1700 }
1701
1702 void StatusNotification::setNumber(const long number)
1703 {
1704         LoggerI("Number = " << number);
1705         if (m_notiHandle)
1706         {
1707                 if(number!=getNumber())
1708                 {
1709                         std::stringstream stream;
1710                         stream << number;
1711                         if (stream.fail()) {
1712                                 throw UnknownException(
1713                                                  "Couldn't convert notification number");
1714                         }
1715
1716                         std::string strNumber = stream.str();
1717                         if (notification_set_text(m_notiHandle, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, strNumber.c_str(),
1718                                 NULL, NOTIFICATION_VARIABLE_TYPE_NONE) != NOTIFICATION_ERROR_NONE)
1719                         {
1720                                 throw UnknownException( "set notification text error");
1721                         }
1722                         setUpdatedFlag(true);
1723                 }
1724         }
1725         else
1726         {
1727                 LoggerD("noti Handle is NULL");
1728                 throw UnknownException( "notification handle is null");
1729         }
1730 }
1731
1732 void* StatusNotification::getNotificationHandle()
1733 {
1734         return m_notiHandle;
1735 }
1736
1737 void StatusNotification::setNotificationHandle(void *handle)
1738 {
1739         if (handle == NULL)
1740         {
1741                 throw UnknownException( "notification handle null error");
1742         }
1743         LoggerI("handle = " << handle << " m_notiHandle = " << m_notiHandle);
1744
1745         if (m_notiHandle != NULL)
1746         {
1747                 //delete old noti.
1748                 if ( notification_delete(m_notiHandle) != NOTIFICATION_ERROR_NONE)
1749                 {
1750                         throw UnknownException( "notification delete error");
1751                 }
1752                 m_notiHandle = NULL;
1753         }
1754
1755         m_notiHandle = (notification_h)handle;
1756 }
1757
1758 service_h StatusNotification::getService()
1759 {
1760         return m_service;
1761 }
1762
1763 std::string StatusNotification::getLight()
1764 {
1765         LoggerI("get Light handle: " << m_notiHandle);
1766         if (m_notiHandle)
1767         {
1768                 int ledColor = 0;
1769                 notification_led_op_e type = NOTIFICATION_LED_OP_ON;
1770                 if (notification_get_led(m_notiHandle, &type, &ledColor) != NOTIFICATION_ERROR_NONE)
1771                 {
1772                         throw UnknownException("get notification Content error");
1773                 }
1774                 std::string light;
1775                 std::stringstream stream;
1776                 if (NOTIFICATION_LED_OP_OFF != type)
1777                 {
1778                         stream <<  std::hex  << ledColor;
1779                         light = "#" + stream.str();
1780                 }
1781
1782                 return boost::to_lower_copy(light);
1783         }
1784         else
1785         {
1786                 throw UnknownException("notification handle is null");
1787         }
1788 }
1789
1790 bool StatusNotification::isColorFormatNumberic(std::string& color)
1791 {
1792         //first check length
1793         std::string hexCode = "0123456789abcdef";
1794         if (color.length() == 7 && !color.compare(0, 1, "#") )
1795         {
1796                 for ( size_t i = 1 ; i < color.length() ; i++)
1797                 {
1798                         if (std::string::npos == hexCode.find(color[i]))
1799                                 return false;
1800                 }
1801                 return true;
1802         }
1803         return false;
1804 }
1805
1806 void StatusNotification::setLight(std::string color)
1807 {
1808         LoggerI("set Light handle: " << m_notiHandle);
1809         LoggerI("led Color : " << color);
1810         if (m_notiHandle)
1811         {
1812                 color = boost::to_lower_copy(color);     //convert lowercase.
1813                 if ( isColorFormatNumberic(color))
1814                 {
1815                         std::stringstream stream;
1816                         int ledColor = 0;
1817                         notification_led_op_e type = NOTIFICATION_LED_OP_ON;
1818                         std::string colorCode = color.substr(1, color.length());
1819
1820                         stream << std::hex << colorCode;
1821                         LoggerI("LedColor = " << stream.str());
1822                         stream >> ledColor;
1823                         LoggerI("LedColor = " << ledColor);
1824
1825                         if (ledColor != 0)
1826                                 type = NOTIFICATION_LED_OP_ON_CUSTOM_COLOR;
1827                         else
1828                                 type = NOTIFICATION_LED_OP_OFF;
1829
1830                         if (notification_set_led(m_notiHandle, type, ledColor) != NOTIFICATION_ERROR_NONE)
1831                         {
1832                                 throw UnknownException("set notification led ");
1833                         }
1834
1835                 }
1836                 else
1837                 {
1838                         LoggerI("color.length()=" << color.length());
1839                         if (color.length() == 0)
1840                         {
1841                                 if (notification_set_led(m_notiHandle, NOTIFICATION_LED_OP_OFF, 0) != NOTIFICATION_ERROR_NONE)
1842                                 {
1843                                         throw UnknownException("set notification led ");
1844                                 }
1845                         }
1846                         else
1847                         {
1848                                 throw InvalidValuesException("color code error!");
1849                         }
1850                 }
1851         }
1852         else
1853         {
1854                 throw UnknownException("notification handle is null");
1855         }
1856 }
1857
1858 unsigned long StatusNotification::getLightOnTime()
1859 {
1860         LoggerI("get Light on Time handle: " << m_notiHandle);
1861         if (m_notiHandle)
1862         {
1863                 int onTime = 0;
1864                 int offTime = 0;
1865
1866                 if (notification_get_led_time_period(m_notiHandle, &onTime, &offTime ) != NOTIFICATION_ERROR_NONE)
1867                 {
1868                         throw UnknownException("set notification led ");
1869                 }
1870                 LoggerI("onTime " << onTime);
1871
1872                 return (unsigned long) onTime;
1873         }
1874         else
1875         {
1876                 throw UnknownException("notification handle is null");
1877         }
1878 }
1879
1880 void StatusNotification::setLightOnTime(unsigned long time)
1881 {
1882         LoggerI("set Light on Time handle: " << m_notiHandle);
1883         LoggerI("itme = " << time);
1884         if (m_notiHandle)
1885         {
1886                 int offTime = getLightOffTime();
1887
1888                 if (notification_set_led_time_period(m_notiHandle, time, offTime ) != NOTIFICATION_ERROR_NONE)
1889                 {
1890                         throw UnknownException("set notification led ");
1891                 }
1892
1893         }
1894         else
1895         {
1896                 throw UnknownException("notification handle is null");
1897         }
1898 }
1899
1900 unsigned long StatusNotification::getLightOffTime()
1901 {
1902
1903         LoggerI("get Light on Time handle: " << m_notiHandle);
1904         if (m_notiHandle)
1905         {
1906                 int onTime = 0;
1907                 int offTime = 0;
1908
1909                 if (notification_get_led_time_period(m_notiHandle, &onTime, &offTime ) != NOTIFICATION_ERROR_NONE)
1910                 {
1911                         throw UnknownException("set notification led ");
1912                 }
1913                 LoggerI("offTime " << offTime);
1914
1915                 return offTime;
1916         }
1917         else
1918         {
1919                 throw UnknownException("notification handle is null");
1920         }
1921
1922 }
1923
1924 void StatusNotification::setLightOffTime(unsigned long time)
1925 {
1926         LoggerI("set Light off Time handle: " << m_notiHandle);
1927         LoggerI("time = " << time);
1928         if (m_notiHandle)
1929         {
1930                 int onTime = getLightOnTime();
1931
1932                 if (notification_set_led_time_period(m_notiHandle, onTime, time ) != NOTIFICATION_ERROR_NONE)
1933                 {
1934                         throw UnknownException("set notification led ");
1935                 }
1936         }
1937         else
1938         {
1939                 throw UnknownException("notification handle is null");
1940         }
1941 }
1942
1943 //Detail Info
1944 void StatusNotification::loadDetailInfos()
1945 {
1946         LoggerI("noti Handle = " << m_notiHandle);
1947
1948         if (m_notiHandle)
1949         {
1950                 for ( int idx = 0; idx < MAX_NOTIFICATION_DETAIL_INFO_LENGTH; idx++)
1951                 {
1952                     std::string main = getInformation(idx);
1953                     std::string sub = getSubInformation(idx);
1954                     LoggerI("Main : " << main << " Sub : " << sub);
1955                     NotificationDetailInfo *info = new NotificationDetailInfo(m_notiHandle, idx, main, sub);
1956                     m_detailInfos.push_back(info);
1957                 }
1958         }
1959         else
1960         {
1961                 LoggerD("noti Handle is NULL");
1962                 throw UnknownException( "notification handle is null");
1963         }
1964
1965 }
1966
1967 std::vector<NotificationDetailInfo*> StatusNotification::getDetailInfos() const
1968 {
1969         return m_detailInfos;
1970 }
1971
1972 void StatusNotification::setDetailInfos(const std::vector<NotificationDetailInfo*> value)
1973 {
1974     LoggerI("DetailInfos = " << value.size());
1975
1976     if (m_notiHandle)
1977     {
1978         std::vector<NotificationDetailInfo*>::const_iterator it;
1979
1980         int idx = 0;
1981         for (it = value.begin(); it < value.end(); ++it)
1982         {
1983             NotificationDetailInfo* info = *it;
1984             if ( idx < MAX_NOTIFICATION_DETAIL_INFO_LENGTH )
1985             {
1986                 LoggerI("main " << info->getMainText() << " sub " << info->getSubText() );
1987                 setInformation(info->getMainText(), idx);
1988                 setSubInformation(info->getSubText(), idx);
1989             }
1990             idx ++;
1991         }
1992
1993         m_detailInfos = value;
1994     }
1995     else
1996     {
1997         LoggerD("noti Handle is NULL");
1998         throw UnknownException( "notification handle is null");
1999     }
2000
2001 }
2002
2003 int StatusNotification::getDetailInfosNum() const
2004 {
2005         return m_detailInfos.size();
2006 }
2007
2008 void StatusNotification::clearDetailInfos()
2009 {
2010         if ( !m_detailInfos.empty() )
2011         {
2012                 std::vector<NotificationDetailInfo*>::const_iterator it;
2013
2014                 int idx = 0;
2015                 for (it = m_detailInfos.begin(); it < m_detailInfos.end(); ++it)
2016                 {
2017                     NotificationDetailInfo* info = *it;
2018                     LoggerI("Delete Detail Info : " << info);
2019                     if (info)
2020                         delete info;
2021                     idx ++;
2022                 }
2023                 m_detailInfos.clear();          //clear
2024         }
2025 }
2026
2027 std::string StatusNotification::getInformation(int index)
2028 {
2029         if (m_notiHandle)
2030         {
2031                 notification_text_type_e type = NOTIFICATION_TEXT_TYPE_NONE;
2032                 switch (index)
2033                 {
2034                         case 0:
2035                                 type = NOTIFICATION_TEXT_TYPE_INFO_1;
2036                                 break;
2037                         case 1:
2038                                 type = NOTIFICATION_TEXT_TYPE_INFO_2;
2039                                 break;
2040                         case 2:
2041                                 type = NOTIFICATION_TEXT_TYPE_INFO_3;
2042                                 break;
2043                         default :
2044                                 type = NOTIFICATION_TEXT_TYPE_NONE;
2045                 }
2046                 char *info = NULL;
2047
2048                 if (NOTIFICATION_TEXT_TYPE_NONE != type && notification_get_text(m_notiHandle, type, &info) != NOTIFICATION_ERROR_NONE)
2049                 {
2050                         throw UnknownException("Detail Info index value is invalid or mainText value getting is failed in Detail Info.");
2051                 }
2052
2053                 std::string strInfo;
2054                 if (info)
2055                         strInfo = info;
2056                 LoggerI(" info " << strInfo);
2057                 return strInfo;
2058
2059         }
2060         else
2061         {
2062                 LoggerW("noti Handle is NULL");
2063                 throw UnknownException( "notification handle is null");
2064         }
2065
2066 }
2067
2068 std::string StatusNotification::getSubInformation(int index)
2069 {
2070         if (m_notiHandle)
2071         {
2072                 notification_text_type_e type = NOTIFICATION_TEXT_TYPE_NONE;
2073                 switch (index)
2074                 {
2075                         case 0:
2076                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_1;
2077                                 break;
2078                         case 1:
2079                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_2;
2080                                 break;
2081                         case 2:
2082                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_3;
2083                                 break;
2084                         default :
2085                                 type = NOTIFICATION_TEXT_TYPE_NONE;
2086                 }
2087
2088                 char *subInfo = NULL;
2089
2090                 if (NOTIFICATION_TEXT_TYPE_NONE != type && notification_get_text(m_notiHandle, type, &subInfo) != NOTIFICATION_ERROR_NONE)
2091                 {
2092                         throw UnknownException("Detail Info index value is invalid or subText value getting is failed in Detail Info.");
2093                 }
2094
2095                 std::string strSubInfo;
2096                 if (subInfo)
2097                         strSubInfo = subInfo;
2098                 LoggerI(" subInfo " << strSubInfo);
2099                 return strSubInfo;
2100
2101         }
2102         else
2103         {
2104                 LoggerW("noti Handle is NULL");
2105                 throw UnknownException ("notification handle is null");
2106         }
2107
2108 }
2109
2110 void StatusNotification::setInformation( const std::string& info, int index)
2111 {
2112         if (m_notiHandle)
2113         {
2114                 int idx = index;
2115                 LoggerD(" index : " << idx);
2116                 LoggerD(" log : " << info);
2117                 notification_text_type_e type = NOTIFICATION_TEXT_TYPE_NONE;
2118
2119                 switch (idx)
2120                 {
2121                         case 0:
2122                                 type = NOTIFICATION_TEXT_TYPE_INFO_1;
2123                                 break;
2124                         case 1:
2125                                 type = NOTIFICATION_TEXT_TYPE_INFO_2;
2126                                 break;
2127                         case 2:
2128                                 type = NOTIFICATION_TEXT_TYPE_INFO_3;
2129                                 break;
2130                         default :
2131                                 type = NOTIFICATION_TEXT_TYPE_NONE;
2132                 }
2133
2134                 if ( type != NOTIFICATION_TEXT_TYPE_NONE)
2135                 {
2136                         if (getInformation(idx).compare(info))
2137                         {
2138                                 if (notification_set_text(m_notiHandle, type, info.c_str(),
2139                                         NULL, NOTIFICATION_VARIABLE_TYPE_NONE) != NOTIFICATION_ERROR_NONE)
2140                                 {
2141                                         throw UnknownException("set notification sound error");
2142                                 }
2143                                 setUpdatedFlag(true);
2144                         }
2145                 }
2146                 else
2147                 {
2148                         LoggerW("noti Handle is NULL");
2149                         throw UnknownException("notification handle is null");
2150                 }
2151         }
2152         else
2153         {
2154                 LoggerW("noti Handle is NULL");
2155                 throw UnknownException("notification handle is null");
2156         }
2157 }
2158
2159 void StatusNotification::setSubInformation( const std::string& subInfo, int index)
2160 {
2161
2162         if (m_notiHandle)
2163         {
2164                 int idx = index;
2165                 LoggerD(" index : " << idx);
2166                 LoggerD(" log : " << subInfo);
2167                 notification_text_type_e type = NOTIFICATION_TEXT_TYPE_NONE;
2168
2169                 switch (idx)
2170                 {
2171                         case 0:
2172                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_1;
2173                                 break;
2174                         case 1:
2175                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_2;
2176                                 break;
2177                         case 2:
2178                                 type = NOTIFICATION_TEXT_TYPE_INFO_SUB_3;
2179                                 break;
2180                         default :
2181                                 type = NOTIFICATION_TEXT_TYPE_NONE;
2182                 }
2183
2184                 if ( type != NOTIFICATION_TEXT_TYPE_NONE)
2185                 {
2186                         if (getSubInformation(idx).compare(subInfo))
2187                         {
2188                                 if (notification_set_text(m_notiHandle, type, subInfo.c_str(),
2189                                         NULL, NOTIFICATION_VARIABLE_TYPE_NONE) != NOTIFICATION_ERROR_NONE)
2190                                 {
2191                                         throw UnknownException("set notification sound error");
2192                                 }
2193                                 setUpdatedFlag(true);
2194                         }
2195                 }
2196         }
2197         else
2198         {
2199                 LoggerW("noti Handle is NULL");
2200                 throw UnknownException("notification handle is null");
2201         }
2202 }
2203
2204 } // Notification
2205 } // DeviceAPI