Merge "[sensor] add getHardwareInfo()" into tizen_3.0

diff --git a/src/sensor/sensor_api.js b/src/sensor/sensor_api.js
index 151c17b..d20b1a3 100755 (executable)
--- a/src/sensor/sensor_api.js
+++ b/src/sensor/sensor_api.js
@@ -69,7 +69,7 @@ SensorListener.prototype.start = function (successCallback, errorCallback) {
         native_.call('Sensor_start', {'sensorType' : thisObject.sensorType},
                 function(result) {
                     if (native_.isFailure(result)) {
-                        if(!T_.isNullOrUndefined(errorCallback)) {
+                        if (!T_.isNullOrUndefined(errorCallback)) {
                             errorCallback(native_.getErrorObject(result));
                         }
                     } else {
@@ -130,7 +130,7 @@ SensorListener.prototype.getData = function (successCallback, errorCallback) {
         native_.call('Sensor_getData', { type : thisObj.sensorType },
                 function(result) {
             if (native_.isFailure(result)) {
-                if(!T_.isNullOrUndefined(errorCallback)) {
+                if (!T_.isNullOrUndefined(errorCallback)) {
                     errorCallback(native_.getErrorObject(result));
                 }
             } else {
@@ -204,9 +204,9 @@ function getDefaultSensor() {
         return new HRMRawSensor();
     } else if (_supportedSensors[index] === SensorType.GRAVITY) {
         return new GravitySensor();
-    } else if(_supportedSensors[index] === SensorType.GYROSCOPE){
+    } else if (_supportedSensors[index] === SensorType.GYROSCOPE){
         return new GyroscopeSensor();
-    } else if(_supportedSensors[index] === SensorType.GYROSCOPE_ROTATION_VECTOR){
+    } else if (_supportedSensors[index] === SensorType.GYROSCOPE_ROTATION_VECTOR){
         return new GyroscopeRotationVectorSensor();
     }
 };
@@ -278,6 +278,33 @@ Sensor.prototype.unsetChangeListener = function() {
     _sensorListeners[this.sensorType].unsetListener();
 };
 
+Sensor.prototype.getSensorHardwareInfo = function(){
+  var args = validator_.validateArgs(arguments, [
+       {
+           name : 'successCallback',
+           type : types_.FUNCTION
+       },
+       {
+           name : 'errorCallback',
+           type : types_.FUNCTION,
+           optional : true,
+           nullable : true
+       }
+    ]);
+
+  var callback = function(result){
+    if (native_.isFailure(result)){
+      if (!T_.isNullOrUndefined(errorCallback)) {
+        errorCallback(native_.getErrorObject(result));
+      }
+    }else {
+      args.successCallback(new SensorHardwareInfo(result));
+    }
+  }
+
+  var result = native_.call("Sensor_getSensorHardwareInfo", {type: this.sensorType}, callback);
+}
+
 //// LightSensor
 var LightSensor = function(data) {
     Sensor.call(this, SensorType.LIGHT);
@@ -674,5 +701,18 @@ SensorGyroscopeRotationVectorData.prototype.constructor = SensorData;
 _sensorListeners[SensorType.GYROSCOPE_ROTATION_VECTOR] = new SensorListener(SensorType.GYROSCOPE_ROTATION_VECTOR,
         SensorGyroscopeRotationVectorData);
 
+//////////////////////SensorHardwareInfo classes//////////////////////////////////////////////////////////
+function SensorHardwareInfo(data) {
+    Object.defineProperties(this, {
+        name : {value: data.name, writable: false, enumerable: true},
+        type : {value: data.type, writable: false, enumerable: true},
+        vendor : {value: data.vendor, writable: false, enumerable: true},
+        minValue : {value: data.minValue, writable: false, enumerable: true},
+        maxValue : {value: data.maxValue, writable: false,  enumerable: true},
+        resolution : {value: data.resolution, writable: false, enumerable: true},
+        minInterval : {value: data.minInterval, writable: false, enumerable: true},
+        maxBatchCount : {value: data.batchCount, writable: false, enumerable: true}
+    });
+}
 // Exports
 exports = new SensorService();

diff --git a/src/sensor/sensor_instance.cc b/src/sensor/sensor_instance.cc
index ca0e37a..ddacd9a 100644 (file)
--- a/src/sensor/sensor_instance.cc
+++ b/src/sensor/sensor_instance.cc
@@ -42,6 +42,7 @@ SensorInstance::SensorInstance()
     RegisterSyncHandler(c, std::bind(&SensorInstance::x, this, _1, _2));
   REGISTER_ASYNC("Sensor_start", SensorStart);
   REGISTER_ASYNC("Sensor_getData", SensorGetData);
+  REGISTER_ASYNC("Sensor_getSensorHardwareInfo", GetSensorHardwareInfo);
 #undef REGISTER_ASYNC
 }
 
@@ -80,5 +81,11 @@ void SensorInstance::SensorGetData(const picojson::value& args, picojson::object
   service_.GetSensorData(args, out);
 }
 
+void SensorInstance::GetSensorHardwareInfo(const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
+
+  service_.GetSensorHardwareInfo(args, out);
+}
+
 } // namespace sensor
 } // namespace extension

diff --git a/src/sensor/sensor_instance.h b/src/sensor/sensor_instance.h
index c798e16..9aec82f 100644 (file)
--- a/src/sensor/sensor_instance.h
+++ b/src/sensor/sensor_instance.h
@@ -36,6 +36,7 @@ class SensorInstance : public common::ParsedInstance {
   void SensorUnsetChangeListener(const picojson::value& args, picojson::object& out);
   void SensorStart(const picojson::value& args, picojson::object& out);
   void SensorGetData(const picojson::value& args, picojson::object& out);
+  void GetSensorHardwareInfo(const picojson::value& args, picojson::object& out);
 
   SensorService service_;
 };

diff --git a/src/sensor/sensor_service.cc b/src/sensor/sensor_service.cc
index ff313ef..45eab7c 100755 (executable)
--- a/src/sensor/sensor_service.cc
+++ b/src/sensor/sensor_service.cc
@@ -23,6 +23,7 @@
 #include "common/logger.h"
 #include "common/optional.h"
 #include "common/platform_exception.h"
+#include "common/scope_exit.h"
 #include "common/task-queue.h"
 #include "common/tools.h"
 
@@ -191,6 +192,7 @@ class SensorData {
   virtual PlatformResult SetChangeListener(unsigned int interval);
   virtual PlatformResult UnsetChangeListener();
   virtual PlatformResult GetSensorData(picojson::object* data);
+  virtual PlatformResult GetHardwareInfo(picojson::object* data);
 
   sensor_type_e type() const { return type_enum_; }
   bool is_supported();
@@ -444,6 +446,98 @@ PlatformResult SensorData::GetSensorData(picojson::object* data) {
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
+PlatformResult SensorData::GetHardwareInfo(picojson::object* data) {
+  LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+
+  auto res = CheckInitialization();
+
+  if (!res) {
+    LoggerE("Sensor initialization for sensor %s failed", type_to_string_map[type_enum_].c_str());
+    return res;
+  }
+
+  sensor_type_e type = type_enum_;
+  char *vendor = nullptr;
+  char *name = nullptr;
+  float min_range = 0;
+  float max_range = 0;
+  float resolution = 0;
+  int min_interval = 0;
+  int max_batch_count = 0;
+
+  SCOPE_EXIT {
+    free(name);
+    free(vendor);
+  };
+
+  auto native_result = [](int ret) -> PlatformResult{
+    switch(ret){
+      case SENSOR_ERROR_IO_ERROR:
+        return PlatformResult(ErrorCode::IO_ERR);
+
+      case SENSOR_ERROR_OPERATION_FAILED:
+        return PlatformResult(ErrorCode::ABORT_ERR);
+
+      default:
+        return PlatformResult(ErrorCode::ABORT_ERR);
+    }
+  };
+
+  int ret = sensor_get_name(handle_, &name);
+  if (ret != SENSOR_ERROR_NONE) {
+    LoggerE("Failed to sensor_get_name error code: %d", &ret);
+    return native_result(ret);
+  }
+  ret = sensor_get_vendor(handle_, &vendor);
+  if (ret != SENSOR_ERROR_NONE) {
+    LoggerE("Failed to sensor_get_vendor error code: %d", &ret);
+    return native_result(ret);
+  }
+  ret = sensor_get_type(handle_, &type);
+  if (ret != SENSOR_ERROR_NONE) {
+    LoggerE("Failed to sensor_get_type error code: %d", &ret);
+    return native_result(ret);
+  }
+  ret = sensor_get_min_range(handle_, &min_range);
+  if (ret != SENSOR_ERROR_NONE) {
+    LoggerE("Failed to sensor_get_min_range error code: %d", &ret);
+    return native_result(ret);
+  }
+  ret = sensor_get_max_range(handle_, &max_range);
+  if (ret != SENSOR_ERROR_NONE) {
+    LoggerE("Failed to sensor_get_max_range error code: %d", &ret);
+    return native_result(ret);
+  }
+  ret = sensor_get_resolution(handle_, &resolution);
+  if (ret != SENSOR_ERROR_NONE) {
+    LoggerE("Failed to sensor_get_resolution error code: %d", &ret);
+    return native_result(ret);
+  }
+  ret = sensor_get_min_interval(handle_, &min_interval);
+  if (ret != SENSOR_ERROR_NONE) {
+    LoggerE("Failed to sensor_get_min_interval error code: %d", &ret);
+    return native_result(ret);
+  }
+  ret = sensor_get_max_batch_count(handle_, &max_batch_count);
+  if (ret != SENSOR_ERROR_NONE) {
+    LoggerE("Failed to sensor_get_max_batch_count error code: %d", &ret);
+    return native_result(ret);
+  }
+
+  (*data)["name"] = picojson::value(std::string(name));
+  (*data)["type"] = picojson::value(type_to_string_map[type]);
+  (*data)["vendor"] = picojson::value(std::string(vendor));
+  (*data)["minValue"] = picojson::value(static_cast<double>(min_range));
+  (*data)["maxValue"] = picojson::value(static_cast<double>(max_range));
+  (*data)["resolution"] = picojson::value(static_cast<double>(resolution));
+  (*data)["minInterval"] = picojson::value(static_cast<double>(min_interval));
+  (*data)["batchCount"] = picojson::value(static_cast<double>(max_batch_count));
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+
+
 class HrmSensorData : public SensorData {
  public:
   explicit HrmSensorData(SensorInstance& instance);
@@ -454,6 +548,7 @@ class HrmSensorData : public SensorData {
   virtual PlatformResult SetChangeListener(unsigned int interval);
   virtual PlatformResult UnsetChangeListener();
   virtual PlatformResult GetSensorData(picojson::object* data);
+  virtual PlatformResult GetHardwareInfo(picojson::object* data);
 
  private:
   void AddSensor(SensorData* sensor);
@@ -490,7 +585,6 @@ PlatformResult HrmSensorData::CallMember(PlatformResult (SensorData::*member) ()
       }
     }
   }
-
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
@@ -500,7 +594,7 @@ PlatformResult HrmSensorData::IsSupportedImpl(bool* supported) const {
 
   bool hrm_supported = false;
   int ret = sensor_is_supported(SENSOR_HRM, &hrm_supported);
-  if (ret == SENSOR_ERROR_NONE){
+  if (ret == SENSOR_ERROR_NONE) {
     LoggerD("HRM support is: %d", hrm_supported);
     result |= hrm_supported;
   }
@@ -539,7 +633,6 @@ PlatformResult HrmSensorData::SetChangeListener(unsigned int interval) {
       }
     }
   }
-
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
@@ -570,6 +663,17 @@ PlatformResult HrmSensorData::GetSensorData(picojson::object* data) {
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
+PlatformResult HrmSensorData::GetHardwareInfo(picojson::object* data) {
+  LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+  for (const auto& sensor : hrm_sensors_) {
+    if (sensor.second->is_supported()) {
+      return sensor.second->GetHardwareInfo(data);
+    }
+  }
+
+  return PlatformResult(ErrorCode::ABORT_ERR);
+}
+
 SensorService::SensorService(SensorInstance& instance)
     : instance_(instance) {
   LoggerD("Entered");
@@ -777,5 +881,48 @@ void SensorService::GetSensorData(const picojson::value& args, picojson::object&
   ReportSuccess(out);
 }
 
+void SensorService::GetSensorHardwareInfo(const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
+
+  CHECK_EXIST(args, "callbackId", out);
+  CHECK_EXIST(args, "type", out);
+
+  int callback_id = static_cast<int>(args.get("callbackId").get<double>());
+  sensor_type_e sensor_type = string_to_type_map[args.get("type").get<std::string>()];
+
+  auto get_info = [this, sensor_type](const std::shared_ptr<picojson::value>& result) {
+    picojson::object& object = result->get<picojson::object>();
+
+    auto sensor_data = this->GetSensor(sensor_type);
+
+    if (!sensor_data) {
+      LogAndReportError(PlatformResult(ErrorCode::ABORT_ERR, "Sensor data is null"), &(result->get<picojson::object>()));
+      return;
+    }
+
+    PlatformResult res = sensor_data->GetHardwareInfo(&object);
+
+    if (!res) {
+      LogAndReportError(res, &object, ("Failed to read data for sensor: %s", type_to_string_map[sensor_type].c_str()));
+
+    }else {
+      ReportSuccess(object);
+    }
+  };
+
+  auto get_info_result = [this, callback_id](const std::shared_ptr<picojson::value>& result){
+    result->get<picojson::object>()["callbackId"] = picojson::value{static_cast<double>(callback_id)};
+    Instance::PostMessage(&instance_, result->serialize().c_str());
+  };
+
+  auto info = std::shared_ptr<picojson::value>{new picojson::value{picojson::object()}};
+
+  TaskQueue::GetInstance().Queue<picojson::value>(
+      get_info,
+      get_info_result,
+      info);
+  ReportSuccess(out);
+}
+
 } // namespace sensor
 } // namespace extension

diff --git a/src/sensor/sensor_service.h b/src/sensor/sensor_service.h
index 6de19d5..73b322e 100644 (file)
--- a/src/sensor/sensor_service.h
+++ b/src/sensor/sensor_service.h
@@ -41,6 +41,7 @@ class SensorService {
   void SensorSetChangeListener(const picojson::value& args, picojson::object& out);
   void SensorUnsetChangeListener(const picojson::value& args, picojson::object& out);
   void GetSensorData(const picojson::value& args, picojson::object& out);
+  void GetSensorHardwareInfo(const picojson::value& args, picojson::object& out);
 
  private:
   std::shared_ptr<SensorData> GetSensor(sensor_type_e type_enum);