[Sensor] Sensor.start() implemented

[Feature] added implementation of start() method

[Verification] Code compiles without errors.
  Checked in console.

Change-Id: If51ba3d8304c8570b7580c6e78f2325f70cff281
Signed-off-by: Piotr Kosko <p.kosko@samsung.com>

diff --git a/src/sensor/sensor_api.js b/src/sensor/sensor_api.js
index 75e92aa32015df5091b8482ee78327880add3325..1d0d04661b2ccd8cc00f80535ae33da0db0fc8ad 100644 (file)
--- a/src/sensor/sensor_api.js
+++ b/src/sensor/sensor_api.js
@@ -31,6 +31,13 @@ var MagneticSensorAccuracy = {
 };
 
 var _supportedSensors = [];
+var _startedSensors = {
+    LIGHT : false,
+    MAGNETIC : false,
+    PRESSURE : false,
+    PROXIMITY : false,
+    ULTRAVIOLET : false
+};
 var _isChecked = false;
 
 function getAvailableSensors() {
@@ -102,23 +109,31 @@ Sensor.prototype.start = function() {
            optional : true,
            nullable : true
        }
-   ]);
+    ]);
 
-    native_.call('Sensor_start', {},
-        function(result) {
-            if (native_.isFailure(result)) {
-                if(!T_.isNullOrUndefined(args.errorCallback)) {
-                    args.errorCallback(native_.getErrorObject(result));
+    if (!_startedSensors[this.sensorType]) {
+        // sensor not started
+        var type = this.sensorType;
+        native_.call('Sensor_start', {'sensorType' : type},
+            function(result) {
+                if (native_.isFailure(result)) {
+                    if(!T_.isNullOrUndefined(args.errorCallback)) {
+                        args.errorCallback(native_.getErrorObject(result));
+                    }
+                } else {
+                    _startedSensors[type] = true;
+                    args.successCallback();
                 }
-            } else {
-                args.successCallback();
             }
-        }
-    );
+        );
+    } else {
+        // sensor is already started - just call success callback
+        setTimeout(function(){args.successCallback()}, 0);
+    }
 };
 
 Sensor.prototype.stop = function() {
-    var result = native_.callSync('Sensor_stop', {});
+    var result = native_.callSync('Sensor_stop', {'sensorType' : this.sensorType});
     if (native_.isFailure(result)) {
         throw native_.getErrorObject(result);
     }
@@ -132,14 +147,14 @@ Sensor.prototype.setChangeListener = function() {
        }
    ]);
 
-    var result = native_.callSync('Sensor_setChangeListener', {});
+    var result = native_.callSync('Sensor_setChangeListener', {'sensorType' : this.sensorType});
     if (native_.isFailure(result)) {
         throw native_.getErrorObject(result);
     }
 };
 
 Sensor.prototype.unsetChangeListener = function() {
-    var result = native_.callSync('Sensor_unsetChangeListener', {});
+    var result = native_.callSync('Sensor_unsetChangeListener', {'sensorType' : this.sensorType});
     if (native_.isFailure(result)) {
         throw native_.getErrorObject(result);
     }

diff --git a/src/sensor/sensor_extension.cc b/src/sensor/sensor_extension.cc
index 7b06fb672a9f310877f3bf182849de7b75c61ea3..4b71b4e2894a0d7615af271b095c5bd31672b737 100644 (file)
--- a/src/sensor/sensor_extension.cc
+++ b/src/sensor/sensor_extension.cc
@@ -20,5 +20,5 @@ SensorExtension::SensorExtension() {
 SensorExtension::~SensorExtension() {}
 
 common::Instance* SensorExtension::CreateInstance() {
-  return &extension::sensor::SensorInstance::getInstance();
+  return &extension::sensor::SensorInstance::GetInstance();
 }

diff --git a/src/sensor/sensor_instance.cc b/src/sensor/sensor_instance.cc
index 47c83b983065d6131142cb704f74d025b37fa761..7e0a4a0547ce8829557511c7cf056ed5e96a9953 100644 (file)
--- a/src/sensor/sensor_instance.cc
+++ b/src/sensor/sensor_instance.cc
@@ -14,7 +14,7 @@ namespace sensor {
 
 using namespace common;
 
-SensorInstance& SensorInstance::getInstance() {
+SensorInstance& SensorInstance::GetInstance() {
   static SensorInstance instance;
   return instance;
 }
@@ -50,22 +50,22 @@ void SensorInstance::GetAvailableSensors(const picojson::value& args, picojson::
 
 void SensorInstance::SensorStop(const picojson::value& args, picojson::object& out) {
   LoggerD("Entered");
-  //empty stub
+  SensorService::GetInstance()->SensorStop(args, out);
 }
 
 void SensorInstance::SensorSetChangeListener(const picojson::value& args, picojson::object& out) {
   LoggerD("Entered");
-  //empty stub
+  SensorService::GetInstance()->SensorSetChangeListener(args, out);
 }
 
 void SensorInstance::SensorUnsetChangeListener(const picojson::value& args, picojson::object& out) {
   LoggerD("Entered");
-  //empty stub
+  SensorService::GetInstance()->SensorUnsetChangeListener(args, out);
 }
 
 void SensorInstance::SensorStart(const picojson::value& args, picojson::object& out) {
   LoggerD("Entered");
-  //empty stub
+  SensorService::GetInstance()->SensorStart(args, out);
 }
 
 void SensorInstance::LightSensorGetData(const picojson::value& args, picojson::object& out) {

diff --git a/src/sensor/sensor_instance.h b/src/sensor/sensor_instance.h
index bcf13db60a65bd3a3bf0c4599898653e60309030..de4aa364203b1f8e1722c5ebdef9f5c62eb890f1 100644 (file)
--- a/src/sensor/sensor_instance.h
+++ b/src/sensor/sensor_instance.h
@@ -12,7 +12,7 @@ namespace sensor {
 
 class SensorInstance : public common::ParsedInstance {
  public:
-  static SensorInstance& getInstance();
+  static SensorInstance& GetInstance();
 
  private:
   SensorInstance();

diff --git a/src/sensor/sensor_service.cc b/src/sensor/sensor_service.cc
index 2fe338fba5ce7b03a662a92f086867ce133ae1c8..4999c350003b318b56eeda1c236d36e169fb6ed6 100644 (file)
--- a/src/sensor/sensor_service.cc
+++ b/src/sensor/sensor_service.cc
@@ -4,8 +4,13 @@
 
 #include "sensor_service.h"
 
+#include <string>
+#include <memory>
+
+#include "common/task-queue.h"
 #include "common/logger.h"
-#include "common/extension.h"
+#include "common/platform_exception.h"
+#include "sensor_instance.h"
 
 using namespace common;
 using namespace common::tools;
@@ -14,6 +19,12 @@ namespace extension {
 namespace sensor {
 
 namespace {
+#define CHECK_EXIST(args, name, out) \
+  if (!args.contains(name)) {\
+    ReportError(TypeMismatchException(name" is required argument"), out);\
+      return;\
+    }
+
 static std::map<sensor_type_e, std::string> type_to_string_map = {
     {SENSOR_LIGHT, "LIGHT"},
     {SENSOR_MAGNETIC, "MAGNETIC"},
@@ -36,7 +47,21 @@ SensorService::SensorService() {
 }
 
 SensorService::~SensorService() {
-
+  if (light_sensor_.listener) {
+    sensor_destroy_listener(light_sensor_.listener);
+  }
+  if (magnetic_sensor_.listener) {
+    sensor_destroy_listener(magnetic_sensor_.listener);
+  }
+  if (pressure_sensor_.listener) {
+    sensor_destroy_listener(pressure_sensor_.listener);
+  }
+  if (proximity_sensor_.listener) {
+    sensor_destroy_listener(proximity_sensor_.listener);
+  }
+  if (ultraviolet_sensor_.listener) {
+    sensor_destroy_listener(ultraviolet_sensor_.listener);
+  }
 }
 
 SensorService* SensorService::GetInstance() {
@@ -104,5 +129,204 @@ void SensorService::GetAvailableSensors(picojson::object& out) {
   ReportSuccess(result, out);
 }
 
+void SensorService::SensorStart(const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
+  CHECK_EXIST(args, "callbackId", out)
+  int callback_id = static_cast<int>(args.get("callbackId").get<double>());
+  const std::string type_str =
+      args.contains("sensorType") ? args.get("sensorType").get<std::string>() : "";
+  LoggerD("input type: %s" , type_str.c_str());
+
+  sensor_type_e type_enum = string_to_type_map[type_str];
+
+  auto start = [this, type_enum, type_str](const std::shared_ptr<picojson::value>& result) {
+    PlatformResult res = CheckSensorInitialization(type_enum);
+    if (res.IsError()) {
+      LoggerE("Sensor initialization for sensor %s failed", type_str.c_str());
+      ReportError(res, &(result->get<picojson::object>()));
+      return;
+    }
+    SensorData* sensor_data = GetSensorStruct(type_enum);
+
+    if (!sensor_data) {
+      LoggerD("Sensor data is null");
+      ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Sensor data is null"),
+                         &(result->get<picojson::object>()));
+      return;
+    }
+
+    int ret = sensor_listener_start(sensor_data->listener);
+    if (ret != SENSOR_ERROR_NONE) {
+      LoggerE("ret : %d", ret);
+      ReportError(GetSensorPlatformResult(ret, "sensor_listener_start"),
+                  &(result->get<picojson::object>()));
+      return;
+    }
+
+    ReportSuccess(result->get<picojson::object>());
+  };
+  auto start_result = [callback_id](const std::shared_ptr<picojson::value>& result) {
+    result->get<picojson::object>()["callbackId"] = picojson::value{static_cast<double>(callback_id)};
+    SensorInstance::GetInstance().PostMessage(result->serialize().c_str());
+  };
+
+  TaskQueue::GetInstance().Queue<picojson::value>(
+      start,
+      start_result,
+      std::shared_ptr<picojson::value>{new picojson::value{picojson::object()}});
+  ReportSuccess(out);
+}
+
+void SensorService::SensorStop(const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
+  const std::string type_str =
+      args.contains("sensorType") ? args.get("sensorType").get<std::string>() : "";
+  LoggerD("input type: %s" , type_str.c_str());
+
+  sensor_type_e type_enum = string_to_type_map[type_str];
+
+  PlatformResult res = CheckSensorInitialization(type_enum);
+  SensorData* sensor_data = GetSensorStruct(type_enum);
+  //TODO fill
+}
+
+void SensorService::SensorSetChangeListener(const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
+  const std::string type_str =
+      args.contains("sensorType") ? args.get("sensorType").get<std::string>() : "";
+  LoggerD("input type: %s" , type_str.c_str());
+
+  sensor_type_e type_enum = string_to_type_map[type_str];
+
+  PlatformResult res = CheckSensorInitialization(type_enum);
+  SensorData* sensor_data = GetSensorStruct(type_enum);
+  //TODO fill
+}
+
+void SensorService::SensorUnsetChangeListener(const picojson::value& args, picojson::object& out) {
+  LoggerD("Entered");
+  const std::string type_str =
+      args.contains("sensorType") ? args.get("sensorType").get<std::string>() : "";
+  LoggerD("input type: %s" , type_str.c_str());
+
+  sensor_type_e type_enum = string_to_type_map[type_str];
+
+  PlatformResult res = CheckSensorInitialization(type_enum);
+  SensorData* sensor_data = GetSensorStruct(type_enum);
+  //TODO fill
+}
+
+PlatformResult SensorService::CheckSensorInitialization(sensor_type_e type_enum) {
+  LoggerD("Entered");
+
+  SensorData* sensor_data = NULL;
+  switch(type_enum) {
+    case SENSOR_LIGHT :
+      sensor_data = &light_sensor_;
+      break;
+    case SENSOR_MAGNETIC :
+      sensor_data = &magnetic_sensor_;
+      break;
+    case SENSOR_PRESSURE :
+      sensor_data = &pressure_sensor_;
+      break;
+    case SENSOR_PROXIMITY :
+      sensor_data = &proximity_sensor_;
+      break;
+    case SENSOR_ULTRAVIOLET :
+      sensor_data = &ultraviolet_sensor_;
+      break;
+  }
+  if (!(sensor_data->handle)) {
+    LoggerD("initialization of handle and listener");
+    int ret = sensor_get_default_sensor(type_enum, &(sensor_data->handle));
+    if (ret != SENSOR_ERROR_NONE) {
+      LoggerE("ret : %d", ret);
+      return PlatformResult(ErrorCode::UNKNOWN_ERR, "sensor_get_default_sensor");
+    }
+
+    ret = sensor_create_listener(sensor_data->handle, &(sensor_data->listener));
+    if (ret != SENSOR_ERROR_NONE) {
+      LoggerE("ret : %d", ret);
+      return PlatformResult(ErrorCode::UNKNOWN_ERR, "sensor_create_listener");
+    }
+  }
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+SensorService::SensorData* SensorService::GetSensorStruct(sensor_type_e type_enum) {
+  LoggerD("Entered");
+  switch(type_enum) {
+    case SENSOR_LIGHT :
+      return &light_sensor_;
+    case SENSOR_MAGNETIC :
+      return &magnetic_sensor_;
+    case SENSOR_PRESSURE :
+      return &pressure_sensor_;
+    case SENSOR_PROXIMITY :
+      return &proximity_sensor_;
+    case SENSOR_ULTRAVIOLET :
+      return &ultraviolet_sensor_;
+    default :
+      return nullptr;
+  }
+}
+
+void SensorLightCallback(sensor_h sensor, sensor_event_s *event, void *user_data)
+{
+    float lux = event->values[0];
+    LoggerD("enter %f", lux);
+    //TODO fill
+}
+
+void SensorMagneticCallback(sensor_h sensor, sensor_event_s *event, void *user_data)
+{
+    sensor_data_accuracy_e accuracy = static_cast<sensor_data_accuracy_e>(event->accuracy);
+    float x = event ->values[0];
+    float y = event ->values[1];
+    float z = event ->values[2];
+    LoggerD("enter [ %f , %f , %f ] [ %d ]",x, y, z, accuracy);
+    //TODO fill
+}
+
+void SensorPressureCallback(sensor_h sensor, sensor_event_s *event, void *user_data)
+{
+    float pressure = event->values[0];
+    LoggerD("enter %f", pressure);
+    //TODO fill
+}
+
+void SensorProximityCallback(sensor_h sensor, sensor_event_s *event, void *user_data)
+{
+    float distance = event->values[0];
+    LoggerD("enter %f", distance);
+    //TODO fill
+}
+
+void SensorUltravioletCallback(sensor_h sensor, sensor_event_s *event, void *user_data)
+{
+    float index = event->values[0];
+    LoggerD("enter %f", index);
+    //TODO fill
+}
+
+CallbackPtr SensorService::GetCallbackFunction(sensor_type_e type_enum) {
+  LoggerD("Entered");
+  switch(type_enum) {
+    case SENSOR_LIGHT :
+      return &SensorLightCallback;
+    case SENSOR_MAGNETIC :
+      return &SensorMagneticCallback;
+    case SENSOR_PRESSURE :
+      return &SensorPressureCallback;
+    case SENSOR_PROXIMITY :
+      return &SensorProximityCallback;
+    case SENSOR_ULTRAVIOLET :
+      return &SensorUltravioletCallback;
+    default :
+      return nullptr;
+  }
+}
+
 } // namespace sensor
 } // namespace extension

diff --git a/src/sensor/sensor_service.h b/src/sensor/sensor_service.h
index 833cab8ff2365a929b320df3178ec167714b004f..12868ce8523c6ce7ba2d5a161970dc8293de5dcc 100644 (file)
--- a/src/sensor/sensor_service.h
+++ b/src/sensor/sensor_service.h
@@ -13,6 +13,8 @@
 namespace extension {
 namespace sensor {
 
+typedef void (*CallbackPtr)(sensor_h sensor, sensor_event_s *event, void *user_data);
+
 class SensorService {
   typedef struct {
     sensor_h handle;
@@ -22,6 +24,10 @@ class SensorService {
  public:
   static SensorService* GetInstance();
   void GetAvailableSensors(picojson::object& out);
+  void SensorStart(const picojson::value& args, picojson::object& out);
+  void SensorStop(const picojson::value& args, picojson::object& out);
+  void SensorSetChangeListener(const picojson::value& args, picojson::object& out);
+  void SensorUnsetChangeListener(const picojson::value& args, picojson::object& out);
 
  private:
   SensorService();
@@ -29,6 +35,10 @@ class SensorService {
   std::string GetSensorErrorMessage(const int error_code);
   common::PlatformResult GetSensorPlatformResult(const int error_code, const std::string &hint);
 
+  common::PlatformResult CheckSensorInitialization(sensor_type_e type_enum);
+  SensorData* GetSensorStruct(sensor_type_e type_enum);
+  CallbackPtr GetCallbackFunction(sensor_type_e type_enum);
+
   SensorData light_sensor_;
   SensorData magnetic_sensor_;
   SensorData pressure_sensor_;