src/notification/notification_manager.cc

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   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 #include "notification/notification_manager.h"
  18
  19 #include <fcntl.h>
  20 #include <unistd.h>
  21
  22 #include <app_control_internal.h>
  23 #include <device/led.h>
  24 #include <notification_internal.h>
  25 #include <notification_list.h>
  26
  27 #include "common/converter.h"
  28 #include "common/logger.h"
  29 #include "common/scope_exit.h"
  30
  31 #include "notification/status_notification.h"
  32
  33 namespace extension {
  34 namespace notification {
  35
  36 using namespace common;
  37
  38 NotificationManager::NotificationManager() {
  39   LoggerD("Enter");
  40 }
  41
  42 NotificationManager::~NotificationManager() {
  43   LoggerD("Enter");
  44 }
  45
  46 NotificationManager* NotificationManager::GetInstance() {
  47   LoggerD("Enter");
  48   static NotificationManager instance;
  49   return &instance;
  50 }
  51
  52 PlatformResult NotificationManager::Post(const picojson::object& args,
  53                                          picojson::object& out) {
  54   LoggerD("Enter");
  55   return StatusNotification::FromJson(args, false, &out);
  56 }
  57
  58 PlatformResult NotificationManager::Update(const picojson::object& args) {
  59   LoggerD("Enter");
  60   return StatusNotification::FromJson(args, true, NULL);
  61 }
  62
  63 PlatformResult NotificationManager::Remove(const picojson::object& args) {
  64   LoggerD("Enter");
  65   int id = std::stoi(FromJson<std::string>(args, "id"));
  66
  67   int ret = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NONE, id);
  68   if (ret != NOTIFICATION_ERROR_NONE) {
  69     return LogAndCreateResult(ErrorCode::NOT_FOUND_ERR,
  70                           "Cannot remove notification error",
  71                           ("Cannot remove notification error: %d", ret));
  72   }
  73
  74   return PlatformResult(ErrorCode::NO_ERROR);
  75 }
  76
  77 PlatformResult NotificationManager::RemoveAll() {
  78   LoggerD("Enter");
  79   int ret = notification_delete_all(NOTIFICATION_TYPE_NOTI);
  80   if (ret != NOTIFICATION_ERROR_NONE) {
  81     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
  82                           "Notification noti remove all failed",
  83                           ("Notification remove all failed: %d", ret));
  84   }
  85
  86   ret = notification_delete_all(NOTIFICATION_TYPE_ONGOING);
  87   if (ret != NOTIFICATION_ERROR_NONE) {
  88     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
  89                           "Notification ongoing remove all failed",
  90                           ("Notification remove all failed: %d", ret));
  91   }
  92
  93   return PlatformResult(ErrorCode::NO_ERROR);
  94 }
  95
  96 PlatformResult NotificationManager::Get(const picojson::object& args,
  97                                         picojson::object& out) {
  98   LoggerD("Enter");
  99   int id;
 100   try {
 101     id = std::stoi(FromJson<std::string>(args, "id"));
 102   } catch (...) {
 103     LoggerE("Failed to convert string to int");
 104     return PlatformResult(ErrorCode::NOT_FOUND_ERR, "Failed to convert string to int.");
 105   }
 106
 107   app_control_h app_control = nullptr;
 108   notification_h noti_handle = nullptr;
 109
 110   SCOPE_EXIT {
 111     if (app_control) {
 112       app_control_destroy(app_control);
 113     }
 114     free(noti_handle);
 115   };
 116
 117   PlatformResult status = StatusNotification::GetNotiHandle(id, &noti_handle);
 118   if (status.IsError())
 119   {
 120     LoggerE("Failed: GetNotiHandle");
 121     return status;
 122   }
 123
 124   status = StatusNotification::GetAppControl(noti_handle, &app_control);
 125   if (status.IsError())
 126   {
 127     LoggerE("Failed: GetAppControl");
 128     return status;
 129   }
 130   status = StatusNotification::ToJson(id, noti_handle, app_control, &out);
 131   if (status.IsError())
 132   {
 133     LoggerE("Failed: ToJson");
 134     return status;
 135   }
 136   return PlatformResult(ErrorCode::NO_ERROR);
 137 }
 138
 139 PlatformResult NotificationManager::GetAll(picojson::array& out) {
 140   LoggerD("Enter");
 141   notification_h noti = nullptr;
 142   notification_list_h noti_list = nullptr;
 143   notification_list_h noti_list_iter = nullptr;
 144   char* package = nullptr;
 145
 146   if (APP_ERROR_NONE == app_get_id(&package)) {
 147     LoggerD("Package id: %s", package);
 148   } else {
 149     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
 150                           "Could not get package id");
 151   }
 152   const std::string package_str = package;
 153   free(package);
 154
 155   int ret = notification_get_detail_list(package_str.c_str(), NOTIFICATION_GROUP_ID_NONE,
 156                                          NOTIFICATION_PRIV_ID_NONE, -1, &noti_list);
 157   if (NOTIFICATION_ERROR_NONE != ret) {
 158     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
 159                           "Get notification list error",
 160                           ("Get notification list error: %d", ret));
 161   }
 162
 163   SCOPE_EXIT { notification_free_list(noti_list); };
 164
 165   noti_list_iter = notification_list_get_head(noti_list);
 166
 167   while (nullptr != noti_list_iter) {
 168     noti = notification_list_get_data(noti_list_iter);
 169     if (nullptr != noti) {
 170       int noti_priv = -1;
 171       ret = notification_get_id(noti, NULL, &noti_priv);
 172       if (NOTIFICATION_ERROR_NONE != ret) {
 173         return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
 174                               "Cannot get notification id error",
 175                               ("Cannot get notification id, error: %d", ret));
 176       }
 177
 178       app_control_h app_control = nullptr;
 179       PlatformResult status =
 180           StatusNotification::GetAppControl(noti, &app_control);
 181
 182       SCOPE_EXIT {
 183           if (app_control) {
 184               app_control_destroy(app_control);
 185           }
 186       };
 187
 188       if (status.IsError())
 189         return status;
 190
 191       picojson::object noti_item = picojson::object();
 192
 193       status =
 194           StatusNotification::ToJson(noti_priv, noti, app_control, &noti_item);
 195       if (status.IsError())
 196         return status;
 197
 198       out.push_back(picojson::value(noti_item));
 199     }
 200
 201     noti_list_iter = notification_list_get_next(noti_list_iter);
 202   }
 203
 204   return PlatformResult(ErrorCode::NO_ERROR);
 205 }
 206
 207 PlatformResult NotificationManager::PlayLEDCustomEffect(
 208     const picojson::object& args) {
 209   LoggerD("Enter");
 210
 211   int timeOn = FromJson<double>(args, "timeOn");
 212   int timeOff = FromJson<double>(args, "timeOff");
 213   unsigned int color = FromJson<double>(args, "color");
 214
 215   auto& flags = FromJson<picojson::array>(args, "flags");
 216   unsigned int platformFlags = 0;
 217   for (auto flag : flags) {
 218     std::string flagStr = JsonCast<std::string>(flag);
 219     if (flagStr == "LED_CUSTOM_DEFAULT")
 220       platformFlags |= LED_CUSTOM_DEFAULT;
 221     else if (flagStr == "LED_CUSTOM_DUTY_ON")
 222       platformFlags |= LED_CUSTOM_DUTY_ON;
 223   }
 224
 225   int ret;
 226   ret = device_led_play_custom(timeOn, timeOff, color, platformFlags);
 227   if (ret != DEVICE_ERROR_NONE) {
 228     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Cannot play LED custom effect",
 229                               ("Cannot play LED custom effect: ",ret));
 230   }
 231
 232   return PlatformResult(ErrorCode::NO_ERROR);
 233 }
 234
 235 PlatformResult NotificationManager::StopLEDCustomEffect() {
 236   LoggerD("Enter");
 237
 238   int ret = device_led_stop_custom();
 239   if (ret != DEVICE_ERROR_NONE) {
 240     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Cannot stop LED custom effect",
 241                               ("Cannot stop LED custom effect: ",ret));
 242   }
 243
 244   return PlatformResult(ErrorCode::NO_ERROR);
 245 }
 246
 247 common::PlatformResult NotificationManager::SaveTemplate(const picojson::object& args) {
 248   LoggerD("Enter");
 249   std::string name = FromJson<std::string>(args, "name");
 250   notification_h noti_handle = nullptr;
 251   int ret;
 252   SCOPE_EXIT {
 253     notification_free(noti_handle);
 254   };
 255
 256   PlatformResult status = StatusNotification::GetNotiHandleFromJson(args, false, &noti_handle);
 257
 258   if (status.IsError()){
 259     return status;
 260   }
 261
 262   ret = notification_save_as_template(noti_handle, name.c_str());
 263   if (ret != NOTIFICATION_ERROR_NONE) {
 264     LoggerD("Error: %d (%s)", ret, get_error_message(ret));
 265     if (ret == NOTIFICATION_ERROR_MAX_EXCEEDED) {
 266       return LogAndCreateResult(ErrorCode::QUOTA_EXCEEDED_ERR,
 267                                 "Maximum number of templates exceeded",
 268                                 ("Maximum number of templates exceeded, error: %d", ret));
 269     } else {
 270       return LogAndCreateResult(ErrorCode::ABORT_ERR,
 271                                 "Saving template failed",
 272                                 ("Saving template failed, error: %d", ret));
 273     }
 274   }
 275
 276   return PlatformResult(ErrorCode::NO_ERROR);
 277 }
 278
 279
 280 common::PlatformResult NotificationManager::CreateFromTemplate(const picojson::object& args,
 281                                                                picojson::object& out) {
 282   LoggerD("Enter");
 283   std::string name = FromJson<std::string>(args, "name");
 284
 285   notification_h noti_handle = nullptr;
 286   noti_handle = notification_create_from_template(name.c_str());
 287   if (!noti_handle) {
 288     return LogAndCreateResult(ErrorCode::NOT_FOUND_ERR,
 289                               "The template with given name not found",
 290                               ("The template with given name not found, handle is NULL"));
 291   }
 292
 293   SCOPE_EXIT {
 294     notification_free(noti_handle);
 295   };
 296
 297   PlatformResult status = StatusNotification::ToJson(0, noti_handle, nullptr, &out);
 298   if (status.IsError())
 299   {
 300     LoggerE("Failed: ToJson");
 301     return status;
 302   }
 303   return PlatformResult(ErrorCode::NO_ERROR);
 304 }
 305
 306 }  // namespace notification
 307 }  // namespace extension