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