src/push/push_instance.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 "push/push_instance.h"
  18 #include <string>
  19 #include <vector>
  20 #include "common/logger.h"
  21 #include "common/tools.h"
  22 #include "push/push_manager.h"
  23
  24 namespace extension {
  25 namespace push {
  26
  27 namespace {
  28
  29 const std::string kPrivilegePush = "http://tizen.org/privilege/push";
  30
  31 }  // namespace
  32
  33 PushInstance::PushInstance() {
  34   LoggerD("Enter");
  35   using std::placeholders::_1;
  36   using std::placeholders::_2;
  37
  38 #define REGISTER_ASYNC(c, func) RegisterSyncHandler(c, func);
  39 #define REGISTER_SYNC(c, func) RegisterSyncHandler(c, func);
  40
  41   REGISTER_ASYNC("Push_registerService", std::bind(&PushInstance::registerService, this, _1, _2));
  42   REGISTER_ASYNC("Push_registerApplication",
  43                  std::bind(&PushInstance::registerApplication, this, _1, _2));
  44   REGISTER_ASYNC("Push_unregisterService",
  45                  std::bind(&PushInstance::unregisterService, this, _1, _2));
  46   REGISTER_ASYNC("Push_unregisterApplication",
  47                  std::bind(&PushInstance::unregisterApplication, this, _1, _2));
  48   REGISTER_SYNC("Push_connectService", std::bind(&PushInstance::connectService, this, _1, _2));
  49   REGISTER_SYNC("Push_connect", std::bind(&PushInstance::connect, this, _1, _2));
  50   REGISTER_SYNC("Push_disconnectService",
  51                 std::bind(&PushInstance::disconnectService, this, _1, _2));
  52   REGISTER_SYNC("Push_disconnect", std::bind(&PushInstance::disconnect, this, _1, _2));
  53   REGISTER_SYNC("Push_getRegistrationId",
  54                 std::bind(&PushInstance::getRegistrationId, this, _1, _2));
  55   REGISTER_SYNC("Push_getUnreadNotifications",
  56                 std::bind(&PushInstance::getUnreadNotifications, this, _1, _2));
  57   REGISTER_SYNC("Push_getPushMessage", std::bind(&PushInstance::getPushMessage, this, _1, _2));
  58
  59 #undef REGISTER_ASYNC
  60 #undef REGISTER_SYNC
  61
  62   impl = new PushManager(this);
  63 }
  64
  65 void PushInstance::registerService(const picojson::value& args, picojson::object& out) {
  66   LoggerD("Enter");
  67
  68   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
  69   common::PlatformResult result = impl->registerService(args.get("callbackId").get<double>());
  70   if (result.IsError()) {
  71     LogAndReportError(result, &out, ("Error occured"));
  72   } else {
  73     ReportSuccess(out);
  74   }
  75 }
  76
  77 void PushInstance::registerApplication(const picojson::value& args, picojson::object& out) {
  78   LoggerD("Enter");
  79
  80   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
  81   common::PlatformResult result = impl->registerApplication(args.get("callbackId").get<double>());
  82   if (result.IsError()) {
  83     LogAndReportError(result, &out, ("Error occured"));
  84   } else {
  85     ReportSuccess(out);
  86   }
  87 }
  88
  89 void PushInstance::unregisterService(const picojson::value& args, picojson::object& out) {
  90   LoggerD("Enter");
  91
  92   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
  93
  94   common::PlatformResult result = impl->unregisterService(args.get("callbackId").get<double>());
  95   if (result.IsError()) {
  96     LogAndReportError(result, &out, ("Error occured"));
  97   } else {
  98     ReportSuccess(out);
  99   }
 100 }
 101
 102 void PushInstance::unregisterApplication(const picojson::value& args, picojson::object& out) {
 103   LoggerD("Enter");
 104
 105   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 106
 107   common::PlatformResult result = impl->unregisterApplication(args.get("callbackId").get<double>());
 108   if (result.IsError()) {
 109     LogAndReportError(result, &out, ("Error occured"));
 110   } else {
 111     ReportSuccess(out);
 112   }
 113 }
 114
 115 void PushInstance::connectService(const picojson::value& args, picojson::object& out) {
 116   LoggerD("Enter");
 117
 118   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 119
 120   common::PlatformResult result = impl->connectService();
 121   if (result.IsError()) {
 122     LogAndReportError(result, &out, ("Error while connect service"));
 123   } else {
 124     ReportSuccess(out);
 125   }
 126 }
 127
 128 void PushInstance::connect(const picojson::value& args, picojson::object& out) {
 129   LoggerD("Enter");
 130
 131   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 132
 133   common::PlatformResult result = impl->connect();
 134   if (result.IsError()) {
 135     LogAndReportError(result, &out, ("Error while connect service"));
 136   } else {
 137     ReportSuccess(out);
 138   }
 139 }
 140
 141 void PushInstance::disconnectService(const picojson::value& args, picojson::object& out) {
 142   LoggerD("Enter");
 143
 144   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 145
 146   common::PlatformResult result = impl->disconnectService();
 147   if (result.IsError()) {
 148     LogAndReportError(result, &out, ("Error while disconnect service"));
 149   } else {
 150     ReportSuccess(out);
 151   }
 152 }
 153
 154 void PushInstance::disconnect(const picojson::value& args, picojson::object& out) {
 155   LoggerD("Enter");
 156
 157   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 158
 159   common::PlatformResult result = impl->disconnect();
 160   if (result.IsError()) {
 161     LogAndReportError(result, &out, ("Error while disconnect service"));
 162   } else {
 163     ReportSuccess(out);
 164   }
 165 }
 166
 167 void PushInstance::getRegistrationId(const picojson::value& args, picojson::object& out) {
 168   LoggerD("Enter");
 169
 170   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 171
 172   std::string id;
 173   common::PlatformResult result = impl->getRegistrationId(id);
 174   if (result.IsError()) {
 175     // this method should fail silently and return null
 176     picojson::value res = picojson::value();
 177     ReportSuccess(res, out);
 178   } else {
 179     picojson::value res(id);
 180     ReportSuccess(res, out);
 181   }
 182 }
 183
 184 void PushInstance::getUnreadNotifications(const picojson::value& args, picojson::object& out) {
 185   LoggerD("Enter");
 186
 187   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 188
 189   common::PlatformResult result = impl->getUnreadNotifications();
 190   if (result.IsError()) {
 191     LogAndReportError(result, &out, ("Error occured"));
 192   } else {
 193     ReportSuccess(out);
 194   }
 195 }
 196
 197 void PushInstance::getPushMessage(const picojson::value& args, picojson::object& out) {
 198   LoggerD("Enter");
 199
 200   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 201
 202   picojson::value msg;
 203   common::PlatformResult result = impl->getPushMessage(&msg);
 204
 205   if (result.IsError()) {
 206     LoggerE("Error occurred");
 207     ReportError(result, &out);
 208   } else {
 209     ReportSuccess(msg, out);
 210   }
 211 }
 212
 213 void PushInstance::onPushState(push_service_state_e state, common::PlatformResult result) {
 214   LoggerD("Enter");
 215   picojson::value res{picojson::object()};
 216   picojson::object& dict = res.get<picojson::object>();
 217
 218   dict["listenerId"] = picojson::value("Push_State_Listener");
 219   if (result.IsError()) {
 220     dict["error"] = result.ToJSON();
 221   } else {
 222     dict["state"] = picojson::value(PushManagerCommon::StateToString(state));
 223   }
 224   Instance::PostMessage(this, res.serialize().c_str());
 225 }
 226
 227 void PushInstance::onPushRegister(double callbackId, common::PlatformResult result,
 228                                   const std::string& id) {
 229   picojson::value res{picojson::object()};
 230   picojson::object& dict = res.get<picojson::object>();
 231
 232   dict["callbackId"] = picojson::value(callbackId);
 233   if (result.IsError()) {
 234     dict["error"] = result.ToJSON();
 235   } else {
 236     dict["registrationId"] = picojson::value(id);
 237   }
 238   Instance::PostMessage(this, res.serialize().c_str());
 239 }
 240
 241 void PushInstance::onPushNotify(push_service_notification_h noti) {
 242   LoggerD("Enter");
 243   picojson::value res{picojson::object()};
 244   picojson::object& dict = res.get<picojson::object>();
 245
 246   picojson::value push_message{picojson::object()};
 247   picojson::object& push_message_obj = push_message.get<picojson::object>();
 248
 249   PushManagerCommon::notificationToJson(noti, &push_message_obj);
 250
 251   dict["listenerId"] = picojson::value("Push_Notification_Listener");
 252   dict["pushMessage"] = push_message;
 253   Instance::PostMessage(this, res.serialize().c_str());
 254 }
 255
 256 void PushInstance::onDeregister(double callbackId, common::PlatformResult result) {
 257   LoggerD("Enter");
 258   picojson::value res{picojson::object()};
 259   picojson::object& dict = res.get<picojson::object>();
 260
 261   dict["callbackId"] = picojson::value(callbackId);
 262   if (result.IsError()) {
 263     dict["error"] = result.ToJSON();
 264   }
 265   Instance::PostMessage(this, res.serialize().c_str());
 266 }
 267
 268 PushInstance::~PushInstance() {
 269   LoggerD("Enter");
 270   if (impl) {
 271     delete impl;
 272     impl = nullptr;
 273   }
 274 }
 275
 276 }  // namespace push
 277 }  // namespace extension