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(): m_ignoreNotificationEvents(true) {
  34     LoggerD("Enter");
  35     using std::placeholders::_1;
  36     using std::placeholders::_2;
  37
  38     #define REGISTER_ASYNC(c, func) \
  39         RegisterSyncHandler(c, func);
  40     #define REGISTER_SYNC(c, func) \
  41         RegisterSyncHandler(c, func);
  42
  43     REGISTER_ASYNC("Push_registerApplication",
  44         std::bind(&PushInstance::registerApplication, this, _1, _2));
  45     REGISTER_ASYNC("Push_unregisterApplication",
  46         std::bind(&PushInstance::unregisterApplication, this, _1, _2));
  47     REGISTER_SYNC("Push_connectService",
  48         std::bind(&PushInstance::connectService, this, _1, _2));
  49     REGISTER_SYNC("Push_disconnectService",
  50         std::bind(&PushInstance::disconnectService, this, _1, _2));
  51     REGISTER_SYNC("Push_getRegistrationId",
  52         std::bind(&PushInstance::getRegistrationId, this, _1, _2));
  53     REGISTER_SYNC("Push_getUnreadNotifications",
  54         std::bind(&PushInstance::getUnreadNotifications, this, _1, _2));
  55     REGISTER_SYNC("Push_getPushMessage",
  56         std::bind(&PushInstance::getPushMessage, this, _1, _2));
  57     PushManager::getInstance().setListener(this);
  58
  59     #undef REGISTER_ASYNC
  60     #undef REGISTER_SYNC
  61 }
  62
  63 void PushInstance::registerApplication(const picojson::value& args,
  64         picojson::object& out) {
  65     LoggerD("Enter");
  66
  67     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
  68     common::PlatformResult result = PushManager::getInstance().registerApplication(
  69             args.get("callbackId").get<double>());
  70     if (result.IsError()) {
  71         LogAndReportError(result, &out, ("Error occured"));
  72     } else {
  73         picojson::value result;
  74         ReportSuccess(result, out);
  75     }
  76 }
  77
  78 void PushInstance::unregisterApplication(const picojson::value& args,
  79         picojson::object& out) {
  80     LoggerD("Enter");
  81
  82     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
  83
  84     common::PlatformResult result = PushManager::getInstance()
  85             .unregisterApplication(args.get("callbackId").get<double>());
  86     if (result.IsError()) {
  87         LogAndReportError(result, &out, ("Error occured"));
  88     } else {
  89         picojson::value res;
  90         ReportSuccess(res, out);
  91     }
  92 }
  93
  94 void PushInstance::connectService(const picojson::value& args,
  95         picojson::object& out) {
  96     LoggerD("Enter");
  97
  98     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
  99
 100     m_ignoreNotificationEvents = false;
 101     picojson::value result;
 102     ReportSuccess(result, out);
 103 }
 104
 105 void PushInstance::disconnectService(const picojson::value& args,
 106         picojson::object& out) {
 107     LoggerD("Enter");
 108
 109     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 110
 111     m_ignoreNotificationEvents = true;
 112     picojson::value result;
 113     ReportSuccess(result, out);
 114 }
 115
 116 void PushInstance::getRegistrationId(const picojson::value& args,
 117         picojson::object& out) {
 118     LoggerD("Enter");
 119
 120     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 121
 122     std::string id;
 123     common::PlatformResult result = PushManager::getInstance()
 124             .getRegistrationId(id);
 125     if (result.IsError()) {
 126         // this method should fail silently and return null
 127         picojson::value res = picojson::value();
 128         ReportSuccess(res, out);
 129     } else {
 130         picojson::value res(id);
 131         ReportSuccess(res, out);
 132     }
 133 }
 134
 135 void PushInstance::getUnreadNotifications(const picojson::value& args,
 136         picojson::object& out) {
 137     LoggerD("Enter");
 138
 139     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 140
 141     common::PlatformResult result = PushManager::getInstance()
 142             .getUnreadNotifications();
 143     if (result.IsError()) {
 144         LogAndReportError(result, &out, ("Error occured"));
 145     } else {
 146         picojson::value res;
 147         ReportSuccess(res, out);
 148     }
 149 }
 150
 151 void PushInstance::getPushMessage(const picojson::value& args,
 152                                   picojson::object& out) {
 153   LoggerD("Enter");
 154
 155   CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 156
 157   picojson::value msg;
 158   common::PlatformResult result = PushManager::getInstance().getPushMessage(&msg);
 159
 160   if (result.IsError()) {
 161     LoggerE("Error occurred");
 162     ReportError(result, &out);
 163   } else {
 164     ReportSuccess(msg, out);
 165   }
 166 }
 167
 168 void PushInstance::onPushRegister(double callbackId,
 169         common::PlatformResult result, const std::string& id) {
 170     LoggerD("Enter");
 171     picojson::value::object dict;
 172     dict["callbackId"] = picojson::value(callbackId);
 173     if (result.IsError()) {
 174         dict["error"] = result.ToJSON();
 175     } else {
 176         dict["registrationId"] = picojson::value(id);
 177     }
 178     picojson::value res(dict);
 179     Instance::PostMessage(this, res.serialize().c_str());
 180 }
 181
 182 void PushInstance::onPushNotify(push_service_notification_h noti) {
 183     LoggerD("Enter");
 184     if (m_ignoreNotificationEvents) {
 185         LoggerD("Listener not set, ignoring event");
 186     }
 187     picojson::value::object dict;
 188     picojson::value::object pushMessage;
 189     PushManager::getInstance().notificationToJson(noti, &pushMessage);
 190
 191     dict["listenerId"] = picojson::value("Push_Notification_Listener");
 192     dict["pushMessage"] = picojson::value(pushMessage);
 193     picojson::value resultListener(dict);
 194     Instance::PostMessage(this, resultListener.serialize().c_str());
 195 }
 196
 197 void PushInstance::onDeregister(double callbackId,
 198         common::PlatformResult result) {
 199     LoggerD("Enter");
 200     picojson::value::object dict;
 201     dict["callbackId"] = picojson::value(callbackId);
 202     if (result.IsError()) {
 203         dict["error"] = result.ToJSON();
 204     }
 205     picojson::value res(dict);
 206     Instance::PostMessage(this, res.serialize().c_str());
 207 }
 208
 209 PushInstance::~PushInstance() {
 210     LoggerD("Enter");
 211     PushManager::getInstance().setListener(nullptr);
 212 }
 213
 214 }  // namespace push
 215 }  // namespace extension