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