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