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_registerService",
  44         std::bind(&PushInstance::registerService, this, _1, _2));
  45     REGISTER_ASYNC("Push_unregisterService",
  46         std::bind(&PushInstance::unregisterService, 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     PushManager::getInstance().setListener(this);
  56
  57     #undef REGISTER_ASYNC
  58     #undef REGISTER_SYNC
  59 }
  60
  61 void PushInstance::registerService(const picojson::value& args,
  62         picojson::object& out) {
  63     LoggerD("Enter");
  64
  65     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
  66
  67     PushManager::ApplicationControl appControl;
  68     appControl.operation = args.get("operation").get<std::string>();
  69     if (args.get("uri").is<std::string>()) {
  70         appControl.uri = args.get("uri").get<std::string>();
  71     }
  72     if (args.get("mime").is<std::string>()) {
  73         appControl.mime = args.get("mime").get<std::string>();
  74     }
  75     if (args.get("category").is<std::string>()) {
  76         appControl.category = args.get("category").get<std::string>();
  77     }
  78     if (args.get("data").is<picojson::null>() == false) {
  79         std::vector<picojson::value> dataArray =
  80                 args.get("data").get<picojson::array>();
  81         for (auto &item : dataArray) {
  82             std::string key = item.get("key").get<std::string>();
  83             std::vector<picojson::value> values =
  84                     item.get("value").get<picojson::array>();
  85             for (auto &value : values) {
  86                 appControl.data[key].push_back(value.to_str());
  87             }
  88         }
  89     }
  90     common::PlatformResult result = PushManager::getInstance().registerService(
  91             appControl,
  92             args.get("callbackId").get<double>());
  93     if (result.IsError()) {
  94         LogAndReportError(result, &out, ("Error occured"));
  95     } else {
  96         picojson::value result;
  97         ReportSuccess(result, out);
  98     }
  99 }
 100
 101 void PushInstance::unregisterService(const picojson::value& args,
 102         picojson::object& out) {
 103     LoggerD("Enter");
 104
 105     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 106
 107     common::PlatformResult result = PushManager::getInstance()
 108             .unregisterService(args.get("callbackId").get<double>());
 109     if (result.IsError()) {
 110         LogAndReportError(result, &out, ("Error occured"));
 111     } else {
 112         picojson::value res;
 113         ReportSuccess(res, out);
 114     }
 115 }
 116
 117 void PushInstance::connectService(const picojson::value& args,
 118         picojson::object& out) {
 119     LoggerD("Enter");
 120
 121     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 122
 123     m_ignoreNotificationEvents = false;
 124     picojson::value result;
 125     ReportSuccess(result, out);
 126 }
 127
 128 void PushInstance::disconnectService(const picojson::value& args,
 129         picojson::object& out) {
 130     LoggerD("Enter");
 131
 132     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 133
 134     m_ignoreNotificationEvents = true;
 135     picojson::value result;
 136     ReportSuccess(result, out);
 137 }
 138
 139 void PushInstance::getRegistrationId(const picojson::value& args,
 140         picojson::object& out) {
 141     LoggerD("Enter");
 142
 143     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 144
 145     std::string id;
 146     common::PlatformResult result = PushManager::getInstance()
 147             .getRegistrationId(id);
 148     if (result.IsError()) {
 149         // this method should fail silently and return null
 150         picojson::value res = picojson::value();
 151         ReportSuccess(res, out);
 152     } else {
 153         picojson::value res(id);
 154         ReportSuccess(res, out);
 155     }
 156 }
 157
 158 void PushInstance::getUnreadNotifications(const picojson::value& args,
 159         picojson::object& out) {
 160     LoggerD("Enter");
 161
 162     CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
 163
 164     common::PlatformResult result = PushManager::getInstance()
 165             .getUnreadNotifications();
 166     if (result.IsError()) {
 167         LogAndReportError(result, &out, ("Error occured"));
 168     } else {
 169         picojson::value res;
 170         ReportSuccess(res, out);
 171     }
 172 }
 173
 174 void PushInstance::onPushRegister(double callbackId,
 175         common::PlatformResult result, const std::string& id) {
 176     LoggerD("Enter");
 177     picojson::value::object dict;
 178     dict["callbackId"] = picojson::value(callbackId);
 179     if (result.IsError()) {
 180         dict["error"] = result.ToJSON();
 181     } else {
 182         dict["registrationId"] = picojson::value(id);
 183     }
 184     picojson::value res(dict);
 185     Instance::PostMessage(this, res.serialize().c_str());
 186 }
 187
 188 void PushInstance::onPushNotify(const std::string& appData,
 189         const std::string& alertMessage, double date) {
 190     LoggerD("Enter");
 191     if (m_ignoreNotificationEvents) {
 192         LoggerD("Listener not set, ignoring event");
 193     }
 194     picojson::value::object dict;
 195     dict["listenerId"] = picojson::value("Push_Notification_Listener");
 196     picojson::value::object pushMessage;
 197     pushMessage["appData"] = picojson::value(appData);
 198     pushMessage["alertMessage"] = picojson::value(alertMessage);
 199     pushMessage["date"] = picojson::value(date);
 200     dict["pushMessage"] = picojson::value(pushMessage);
 201     picojson::value resultListener(dict);
 202     Instance::PostMessage(this, resultListener.serialize().c_str());
 203 }
 204
 205 void PushInstance::onDeregister(double callbackId,
 206         common::PlatformResult result) {
 207     LoggerD("Enter");
 208     picojson::value::object dict;
 209     dict["callbackId"] = picojson::value(callbackId);
 210     if (result.IsError()) {
 211         dict["error"] = result.ToJSON();
 212     }
 213     picojson::value res(dict);
 214     Instance::PostMessage(this, res.serialize().c_str());
 215 }
 216
 217 PushInstance::~PushInstance() {
 218     LoggerD("Enter");
 219 }
 220
 221 }  // namespace push
 222 }  // namespace extension