src/device_context_provider.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   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 <glib.h>
  18 #include <string>
  19 #include <map>
  20 #include <utility>
  21
  22 #include <types_internal.h>
  23 #include <json.h>
  24 #include <context_mgr.h>
  25 #include <device_context_provider.h>
  26 #include "device_status/device_status_types.h"
  27 #include "social_status/social_status_types.h"
  28
  29 #include "device_status/wifi.h"
  30 #include "device_status/headphone.h"
  31
  32 #ifdef _MOBILE_
  33 #include "device_status/runtime-info/charger.h"
  34 #include "device_status/runtime-info/gps.h"
  35 #include "device_status/runtime-info/usb.h"
  36 #include "device_status/battery.h"
  37 #include "device_status/psmode.h"
  38 #include "device_status/activity.h"
  39 #include "social_status/call.h"
  40 #include "social_status/email.h"
  41 #include "social_status/message.h"
  42 #endif
  43
  44 #ifdef _WEARABLE_
  45 #include "device_status/runtime-info/charger.h"
  46 #include "device_status/runtime-info/gps.h"
  47 #include "device_status/runtime-info/usb.h"
  48 #include "device_status/battery.h"
  49 #include "device_status/psmode.h"
  50 #include "device_status/activity.h"
  51 #include "social_status/call.h"
  52 #include "social_status/message.h"
  53 #endif
  54
  55 #define CREATE_SUB_PROVIDER(subject, subprovider) do { \
  56         ctx::sub_provider_base *sub = new ctx::subprovider(); \
  57         if (sub->is_supported(subject, NULL)) { \
  58                 subject_map[(subject)] = sub; \
  59         } else { \
  60                 _E("%s is not supported", subject); \
  61                 delete sub; \
  62         }} while (0)
  63
  64 typedef std::map<std::string, ctx::sub_provider_base*> subject_map_t;
  65 static subject_map_t subject_map;
  66
  67 static void load_sub_providers()
  68 {
  69         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_WIFI, device_status_wifi);
  70         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_HEADPHONE, device_status_headphone);
  71
  72 #ifdef _MOBILE_
  73         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_CHARGER, device_status_charger);
  74         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_GPS, device_status_gps);
  75         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_USB, device_status_usb);
  76         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_BATTERY, device_status_battery_level);
  77         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_POWER_SAVING_MODE, device_status_power_saving_mode);
  78         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_ACTIVITY_WALKING, device_status_activity);
  79         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_ACTIVITY_RUNNING, device_status_activity);
  80         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_ACTIVITY_STATIONARY, device_status_activity);
  81         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_ACTIVITY_IN_VEHICLE, device_status_activity);
  82         CREATE_SUB_PROVIDER(SOCIAL_ST_SUBJ_CALL, social_status_call);
  83         CREATE_SUB_PROVIDER(SOCIAL_ST_SUBJ_EMAIL, social_status_email);
  84         CREATE_SUB_PROVIDER(SOCIAL_ST_SUBJ_MESSAGE, social_status_message);
  85 #endif
  86
  87 #ifdef _WEARABLE_
  88         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_CHARGER, device_status_charger);
  89         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_GPS, device_status_gps);
  90         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_USB, device_status_usb);
  91         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_BATTERY, device_status_battery_level);
  92         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_POWER_SAVING_MODE, device_status_power_saving_mode);
  93         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_ACTIVITY_WALKING, device_status_activity);
  94         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_ACTIVITY_RUNNING, device_status_activity);
  95         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_ACTIVITY_STATIONARY, device_status_activity);
  96         CREATE_SUB_PROVIDER(DEVICE_ST_SUBJ_ACTIVITY_IN_VEHICLE, device_status_activity);
  97         CREATE_SUB_PROVIDER(SOCIAL_ST_SUBJ_CALL, social_status_call);
  98         CREATE_SUB_PROVIDER(SOCIAL_ST_SUBJ_MESSAGE, social_status_message);
  99 #endif
 100 }
 101
 102 static void unload_sub_providers()
 103 {
 104         for (subject_map_t::iterator it = subject_map.begin(); it != subject_map.end(); ++it) {
 105                 delete it->second;
 106         }
 107
 108         subject_map.clear();
 109 }
 110
 111 EXTAPI ctx::device_context_provider::device_context_provider()
 112 {
 113 }
 114
 115
 116 EXTAPI ctx::device_context_provider::~device_context_provider()
 117 {
 118         unload_sub_providers();
 119 }
 120
 121
 122 bool ctx::device_context_provider::init()
 123 {
 124         IF_FAIL_RETURN(subject_map.empty(), true);
 125
 126         try {
 127                 load_sub_providers();
 128         } catch (std::bad_alloc& ba) {
 129                 _E("Memory allocation failed");
 130                 return false;
 131         }
 132
 133         for (subject_map_t::iterator it = subject_map.begin(); it != subject_map.end(); ++it) {
 134                 context_manager::register_provider(it->first.c_str(), this);
 135         }
 136
 137         _D("Done");
 138         return true;
 139 }
 140
 141 bool ctx::device_context_provider::is_supported(const char* subject, const char* zone)
 142 {
 143         subject_map_t::iterator it = subject_map.find(subject);
 144
 145         if (it != subject_map.end())
 146                 return it->second->is_supported(subject, zone);
 147
 148         return false;
 149 }
 150
 151 int ctx::device_context_provider::subscribe(const char* subject, ctx::json option, ctx::json* request_result, const char* zone)
 152 {
 153         _D("Starts to publish '%s' on '%s'", subject, zone);
 154
 155         subject_map_t::iterator it = subject_map.find(subject);
 156
 157         if (it != subject_map.end())
 158                 return it->second->subscribe(subject, zone);
 159
 160         return ERR_NOT_SUPPORTED;
 161 }
 162
 163
 164 int ctx::device_context_provider::unsubscribe(const char* subject, ctx::json option, const char* zone)
 165 {
 166         _D("Stops publishing '%s' on '%s'", subject, zone);
 167
 168         subject_map_t::iterator it = subject_map.find(subject);
 169
 170         if (it != subject_map.end())
 171                 return it->second->unsubscribe(subject, zone);
 172
 173         return ERR_NOT_SUPPORTED;
 174 }
 175
 176
 177 int ctx::device_context_provider::read(const char* subject, ctx::json option, ctx::json* request_result, const char* zone)
 178 {
 179         _D("Reads '%s' on '%s'", subject, zone);
 180
 181         subject_map_t::iterator it = subject_map.find(subject);
 182
 183         if (it != subject_map.end())
 184                 return it->second->read(subject, zone);
 185
 186         return ERR_NOT_SUPPORTED;
 187 }
 188
 189
 190 int ctx::device_context_provider::write(const char* subject, ctx::json data, ctx::json* request_result, const char* zone)
 191 {
 192         return ERR_NOT_SUPPORTED;
 193 }