src/push/push_instance.cc

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