src/systeminfo/systeminfo_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 "systeminfo/systeminfo_instance.h"
  18
  19 #include <device/led.h>
  20 #include <functional>
  21 #include <memory>
  22
  23 #include "common/logger.h"
  24 #include "common/picojson.h"
  25 #include "common/platform_exception.h"
  26 #include "common/task-queue.h"
  27 #include "common/tools.h"
  28
  29 #include "systeminfo-utils.h"
  30 #include "systeminfo_device_capability.h"
  31
  32 namespace extension {
  33 namespace systeminfo {
  34
  35 using common::PlatformResult;
  36 using common::ErrorCode;
  37 using common::TypeMismatchException;
  38
  39 namespace {
  40 const std::string kPropertyIdString = "propertyId";
  41 const std::string kListenerIdString = "listenerId";
  42
  43 const std::string kPrivilegeLED = "http://tizen.org/privilege/led";
  44
  45 #define CHECK_EXIST(args, name, out)                                             \
  46   if (!args.contains(name)) {                                                    \
  47     LogAndReportError(TypeMismatchException(name " is required argument"), out); \
  48     return;                                                                      \
  49   }
  50 }
  51
  52 SysteminfoInstance::SysteminfoInstance() : manager_(this) {
  53   ScopeLogger();
  54   using std::placeholders::_1;
  55   using std::placeholders::_2;
  56
  57 #define REGISTER_METHOD(M) RegisterSyncHandler(#M, std::bind(&SysteminfoInstance::M, this, _1, _2))
  58   REGISTER_METHOD(SystemInfoGetCapabilities);
  59   REGISTER_METHOD(SystemInfoGetCapability);
  60   REGISTER_METHOD(SystemInfoAddPropertyValueChangeListener);
  61   REGISTER_METHOD(SystemInfoRemovePropertyValueChangeListener);
  62   REGISTER_METHOD(SystemInfoGetTotalMemory);
  63   REGISTER_METHOD(SystemInfoGetAvailableMemory);
  64   REGISTER_METHOD(SystemInfoGetCount);
  65   REGISTER_METHOD(SystemInfoSetBrightness);
  66   REGISTER_METHOD(SystemInfoGetBrightness);
  67   REGISTER_METHOD(SystemInfoGetMaxBrightness);
  68   REGISTER_METHOD(SystemInfoGetPropertyValue);
  69   REGISTER_METHOD(SystemInfoGetPropertyValueArray);
  70 #undef REGISTER_METHOD
  71 }
  72
  73 SysteminfoInstance::~SysteminfoInstance() {
  74   ScopeLogger();
  75 }
  76
  77 void SysteminfoInstance::SystemInfoGetCapabilities(const picojson::value& args,
  78                                                    picojson::object& out) {
  79   ScopeLogger();
  80   DEPRECATION_WARN(
  81       "getCapabilities() is deprecated and will be removed from next release. "
  82       "Use getCapability() instead.",
  83       "2.3");
  84
  85   manager_.GetCapabilities(args, &out);
  86 }
  87
  88 void SysteminfoInstance::SystemInfoGetCapability(const picojson::value& args,
  89                                                  picojson::object& out) {
  90   ScopeLogger();
  91   manager_.GetCapability(args, &out);
  92 }
  93
  94 void SysteminfoInstance::SystemInfoGetPropertyValue(const picojson::value& args,
  95                                                     picojson::object& out) {
  96   ScopeLogger();
  97   manager_.GetPropertyValue(args, &out);
  98 }
  99
 100 void SysteminfoInstance::SystemInfoGetPropertyValueArray(const picojson::value& args,
 101                                                          picojson::object& out) {
 102   ScopeLogger();
 103   manager_.GetPropertyValueArray(args, &out);
 104 }
 105
 106 void SysteminfoInstance::SystemInfoAddPropertyValueChangeListener(const picojson::value& args,
 107                                                                   picojson::object& out) {
 108   ScopeLogger();
 109   manager_.AddPropertyValueChangeListener(args, &out);
 110 }
 111
 112 void SysteminfoInstance::SystemInfoRemovePropertyValueChangeListener(const picojson::value& args,
 113                                                                      picojson::object& out) {
 114   ScopeLogger();
 115   manager_.RemovePropertyValueChangeListener(args, &out);
 116 }
 117
 118 void SysteminfoInstance::SystemInfoGetTotalMemory(const picojson::value& args,
 119                                                   picojson::object& out) {
 120   ScopeLogger();
 121   manager_.GetTotalMemory(args, &out);
 122 }
 123
 124 void SysteminfoInstance::SystemInfoGetAvailableMemory(const picojson::value& args,
 125                                                       picojson::object& out) {
 126   ScopeLogger();
 127   manager_.GetAvailableMemory(args, &out);
 128 }
 129
 130 void SysteminfoInstance::SystemInfoGetCount(const picojson::value& args, picojson::object& out) {
 131   ScopeLogger();
 132   manager_.GetCount(args, &out);
 133 }
 134
 135 void SysteminfoInstance::SystemInfoSetBrightness(const picojson::value& args,
 136                                                  picojson::object& out) {
 137   ScopeLogger();
 138   CHECK_PRIVILEGE_ACCESS(kPrivilegeLED, &out);
 139
 140   CHECK_EXIST(args, "brightness", out)
 141
 142   const double brightness = args.get("brightness").get<double>();
 143   int result = device_flash_set_brightness(brightness);
 144   if (result != DEVICE_ERROR_NONE) {
 145     if (DEVICE_ERROR_INVALID_PARAMETER == result) {
 146       LogAndReportError(
 147           PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Error occured"), &out,
 148           ("device_flash_set_brightness error: %d (%s)", result, get_error_message(result)));
 149     } else {
 150       LogAndReportError(
 151           PlatformResult(ErrorCode::UNKNOWN_ERR, "Error occured"), &out,
 152           ("device_flash_set_brightness error: %d (%s)", result, get_error_message(result)));
 153     }
 154     return;
 155   }
 156
 157   ReportSuccess(out);
 158 }
 159
 160 void SysteminfoInstance::SystemInfoGetBrightness(const picojson::value& args,
 161                                                  picojson::object& out) {
 162   ScopeLogger();
 163   CHECK_PRIVILEGE_ACCESS(kPrivilegeLED, &out);
 164
 165   int brightness = 0;
 166   int result = device_flash_get_brightness(&brightness);
 167   if (result != DEVICE_ERROR_NONE) {
 168     LogAndReportError(
 169         PlatformResult(ErrorCode::UNKNOWN_ERR, "Error occured"), &out,
 170         ("device_flash_get_brightness error: %d (%s)", result, get_error_message(result)));
 171     return;
 172   }
 173
 174   ReportSuccess(picojson::value(std::to_string(brightness)), out);
 175 }
 176
 177 void SysteminfoInstance::SystemInfoGetMaxBrightness(const picojson::value& args,
 178                                                     picojson::object& out) {
 179   ScopeLogger();
 180   CHECK_PRIVILEGE_ACCESS(kPrivilegeLED, &out);
 181
 182   int brightness = 0;
 183   int result = device_flash_get_max_brightness(&brightness);
 184   if (result != DEVICE_ERROR_NONE) {
 185     LogAndReportError(
 186         PlatformResult(ErrorCode::UNKNOWN_ERR, "Not supported property"), &out,
 187         ("device_flash_get_max_brightness error: %d (%s)", result, get_error_message(result)));
 188     return;
 189   }
 190   ReportSuccess(picojson::value(std::to_string(brightness)), out);
 191 }
 192
 193 }  // namespace systeminfo
 194 }  // namespace extension