[HRM] getHumanActivityData

Change-Id: I0a2d9332c578169a8662ca82a75d128e1e4019c4

diff --git a/src/humanactivitymonitor/humanactivitymonitor_api.js b/src/humanactivitymonitor/humanactivitymonitor_api.js
index 75cac484c4d6d89be0520ba1afd8f7469c2b98d2..ab1f1f84e1821166368ba3522b5cc846142572b0 100644 (file)
--- a/src/humanactivitymonitor/humanactivitymonitor_api.js
+++ b/src/humanactivitymonitor/humanactivitymonitor_api.js
@@ -36,17 +36,43 @@ var PedometerStepStatus = {
   RUNNING: 'RUNNING'
 };
 
+function convertActivityData(type, data) {
+  switch (type) {
+    case HumanActivityType.PEDOMETER:
+      // TODO(r.galka) Not Supported in current implementation
+      return undefined;
+    case HumanActivityType.WRIST_UP:
+      return null;
+    case HumanActivityType.HRM:
+      return new HumanActivityHRMData(data);
+    case HumanActivityType.GPS:
+      var gpsInfo = [];
+      for (var i = 0, max = data.length; i < max; i++) {
+        gpsInfo.push(new HumanActivityGPSInfo(data[i]));
+      }
+      return new HumanActivityGPSInfoArray(gpsInfo);
+  }
+}
 
 function HumanActivityMonitorManager() {
 }
 
 HumanActivityMonitorManager.prototype.getHumanActivityData = function(type, successCallback, errorCallback) {
   var args = validator_.validateArgs(arguments, [
-    {name: 'type', type: types_.ENUM, values: ['PEDOMETER', 'WRIST_UP', 'HRM', 'GPS']},
+    {name: 'type', type: types_.ENUM, values: Object.keys(HumanActivityType)},
     {name: 'successCallback', type: types_.FUNCTION},
     {name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true}
   ]);
 
+  if (args.type === HumanActivityType.WRIST_UP) {
+    throw new WebAPIException(WebAPIException.NOT_SUPPORTED_ERR);
+  }
+
+  var listenerId ='HumanActivityMonitor_'  + args.type;
+  if (!native_.isListenerSet(listenerId)) {
+    throw new WebAPIException(WebAPIException.SERVICE_NOT_AVAILABLE_ERR);
+  }
+
   var data = {
     type: args.type
   };
@@ -56,7 +82,9 @@ HumanActivityMonitorManager.prototype.getHumanActivityData = function(type, succ
       native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
       return;
     }
-    native_.callIfPossible(args.successCallback);
+
+    native_.callIfPossible(args.successCallback,
+        convertActivityData(args.type, native_.getResultObject(result)));
   };
 
   native_.call('HumanActivityMonitorManager_getHumanActivityData', data, callback);
@@ -87,25 +115,7 @@ HumanActivityMonitorManager.prototype.start = function(type, changedCallback) {
   }
 
   var listener = function(result) {
-    switch (args.type) {
-      case HumanActivityType.PEDOMETER:
-        // TODO(r.galka) Not Supported in current implementation
-        break;
-      case HumanActivityType.WRIST_UP:
-        native_.callIfPossible(args.changedCallback, null);
-        break;
-      case HumanActivityType.HRM:
-        native_.callIfPossible(args.changedCallback, new HumanActivityHRMData(result));
-        break;
-      case HumanActivityType.GPS:
-        var gpsInfo = [];
-        for (var i = 0, max = result.length; i < max; i++) {
-          gpsInfo.push(new HumanActivityGPSInfo(result[i]));
-        }
-        native_.callIfPossible(args.changedCallback, new HumanActivityGPSInfoArray(gpsInfo));
-        break;
-    }
-
+    native_.callIfPossible(args.changedCallback, convertActivityData(args.type, result));
   };
   native_.addListener(listenerId, listener);
 };

diff --git a/src/humanactivitymonitor/humanactivitymonitor_instance.cc b/src/humanactivitymonitor/humanactivitymonitor_instance.cc
index fb5d77c78701ba5abc95c4c2d75ee4af44c733d0..eea1ca346d98e0bafa69b4db443c2fc73139c96d 100644 (file)
--- a/src/humanactivitymonitor/humanactivitymonitor_instance.cc
+++ b/src/humanactivitymonitor/humanactivitymonitor_instance.cc
@@ -11,6 +11,7 @@
 #include "common/picojson.h"
 #include "common/logger.h"
 #include "common/platform_result.h"
+#include "common/task-queue.h"
 #include "humanactivitymonitor/humanactivitymonitor_manager.h"
 
 namespace extension {
@@ -18,6 +19,7 @@ namespace humanactivitymonitor {
 
 using common::PlatformResult;
 using common::ErrorCode;
+using common::TaskQueue;
 
 HumanActivityMonitorInstance::HumanActivityMonitorInstance() {
   using std::placeholders::_1;
@@ -66,7 +68,36 @@ PlatformResult HumanActivityMonitorInstance::Init() {
 
 void HumanActivityMonitorInstance::HumanActivityMonitorManagerGetHumanActivityData(
     const picojson::value& args, picojson::object& out) {
-  // TODO(r.galka) implement
+  CHECK_EXIST(args, "type", out)
+
+  PlatformResult result = Init();
+  if (!result) {
+    ReportError(result, &out);
+    return;
+  }
+
+  auto get = [this, args]() -> void {
+    picojson::value response = picojson::value(picojson::object());
+    picojson::object& response_obj = response.get<picojson::object>();
+    response_obj["callbackId"] = args.get("callbackId");
+
+    picojson::value data = picojson::value();
+    PlatformResult result = manager_->GetHumanActivityData(
+        args.get("type").get<std::string>(),
+        &data);
+
+    if (result) {
+      ReportSuccess(data, response_obj);
+    } else {
+      ReportError(result, &response_obj);
+    }
+
+    PostMessage(response.serialize().c_str());
+  };
+
+  TaskQueue::GetInstance().Async(get);
+
+  ReportSuccess(out);
 }
 
 void HumanActivityMonitorInstance::HumanActivityMonitorManagerStart(

diff --git a/src/humanactivitymonitor/humanactivitymonitor_manager.cc b/src/humanactivitymonitor/humanactivitymonitor_manager.cc
index f3fc15db622f11d5e74f77705eeca7b1a67acb73..db09a300c98aa8cf6a5ce66c5474a79617c0878d 100644 (file)
--- a/src/humanactivitymonitor/humanactivitymonitor_manager.cc
+++ b/src/humanactivitymonitor/humanactivitymonitor_manager.cc
@@ -76,22 +76,18 @@ PlatformResult HumanActivityMonitorManager::SetListener(
     return result;
   }
 
-  // PEDOMETER
   if (type == kActivityTypePedometer) {
     // TODO(r.galka) Not Supported in current implementation.
   }
 
-  // WRIST_UP
   if (type == kActivityTypeWristUp) {
     return SetWristUpListener(callback);
   }
 
-  // HRM
   if (type == kActivityTypeHrm) {
     return SetHrmListener(callback);
   }
 
-  // GPS
   if (type == kActivityTypeGps) {
     return SetGpsListener(callback);
   }
@@ -107,22 +103,18 @@ PlatformResult HumanActivityMonitorManager::UnsetListener(
     return result;
   }
 
-  // PEDOMETER
   if (type == kActivityTypePedometer) {
     // TODO(r.galka) Not Supported in current implementation.
   }
 
-  // WRIST_UP
   if (type == kActivityTypeWristUp) {
     return UnsetWristUpListener();
   }
 
-  // HRM
   if (type == kActivityTypeHrm) {
     return UnsetHrmListener();
   }
 
-  // GPS
   if (type == kActivityTypeGps) {
     return UnsetGpsListener();
   }
@@ -130,6 +122,29 @@ PlatformResult HumanActivityMonitorManager::UnsetListener(
   return PlatformResult(ErrorCode::UNKNOWN_ERR, "Undefined activity type");
 }
 
+PlatformResult HumanActivityMonitorManager::GetHumanActivityData(
+    const std::string& type,
+    picojson::value* data) {
+
+  if (type == kActivityTypePedometer) {
+    // TODO(r.galka) Not Supported in current implementation.
+  }
+
+  if (type == kActivityTypeWristUp) {
+    return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR);
+  }
+
+  if (type == kActivityTypeHrm) {
+    return GetHrmData(data);
+  }
+
+  if (type == kActivityTypeGps) {
+    return GetGpsData(data);
+  }
+
+  return PlatformResult(ErrorCode::UNKNOWN_ERR, "Undefined activity type");
+}
+
 // WRIST_UP
 PlatformResult HumanActivityMonitorManager::SetWristUpListener(
     JsonCallback callback) {
@@ -268,8 +283,8 @@ PlatformResult HumanActivityMonitorManager::UnsetHrmListener() {
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void HumanActivityMonitorManager::OnHrmSensorEvent(
-    sensor_h sensor, sensor_event_s *event, void *user_data) {
+static PlatformResult ConvertHrmEvent(sensor_event_s* event,
+                                      picojson::object* data) {
   LOGGER(DEBUG) << "Sensor event:";
   LOGGER(DEBUG) << "  |- accuracy: " << event->accuracy;
   LOGGER(DEBUG) << "  |- timestamp: " << event->timestamp;
@@ -277,7 +292,7 @@ void HumanActivityMonitorManager::OnHrmSensorEvent(
 
   if (event->value_count < 2) {
     LOGGER(ERROR) << "To few values of HRM event";
-    return;
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, "To few values of HRM event");
   }
 
   LOGGER(DEBUG) << "  |- values[0]: " << event->values[0];
@@ -290,6 +305,16 @@ void HumanActivityMonitorManager::OnHrmSensorEvent(
   // or unofficially values[1] is rri (0 ~ 5000 ms)
   float rri = event->values[1];
 
+
+  (*data)["heartRate"] = picojson::value(static_cast<double>(hr));
+  (*data)["rRInterval"] = picojson::value(static_cast<double>(rri));
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+void HumanActivityMonitorManager::OnHrmSensorEvent(
+    sensor_h /*sensor*/, sensor_event_s *event, void *user_data) {
+
   HumanActivityMonitorManager* manager =
       static_cast<HumanActivityMonitorManager*>(user_data);
 
@@ -299,14 +324,41 @@ void HumanActivityMonitorManager::OnHrmSensorEvent(
   }
 
   picojson::value hrm_data = picojson::value(picojson::object());
-  picojson::object& hrm_data_o = hrm_data.get<picojson::object>();
-
-  hrm_data_o["heartRate"] = picojson::value(static_cast<double>(hr));
-  hrm_data_o["rRInterval"] = picojson::value(static_cast<double>(rri));
+  PlatformResult result = ConvertHrmEvent(event,
+                                          &hrm_data.get<picojson::object>());
+  if (!result) {
+    LOGGER(ERROR) << "Failed to convert HRM data: " << result.message();
+    return;
+  }
 
   manager->hrm_event_callback_(&hrm_data);
 }
 
+PlatformResult HumanActivityMonitorManager::GetHrmData(picojson::value* data) {
+  if (!hrm_sensor_listener_) {
+    return PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR);
+  }
+
+  int ret;
+
+  sensor_event_s event;
+  ret = sensor_listener_read_data(hrm_sensor_listener_, &event);
+  if (ret != SENSOR_ERROR_NONE) {
+    LOGGER(ERROR) << "Failed to get HRM sensor data, error: " << ret;
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Failed to get HRM sensor data");
+  }
+
+  *data = picojson::value(picojson::object());
+  PlatformResult result = ConvertHrmEvent(&event,
+                                          &data->get<picojson::object>());
+  if (!result) {
+    return result;
+  }
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
 // GPS
 PlatformResult HumanActivityMonitorManager::SetGpsListener(
     JsonCallback callback) {
@@ -423,5 +475,31 @@ void HumanActivityMonitorManager::OnGpsEvent(int num_of_location,
   manager->gps_event_callback_(&gps_info);
 }
 
+PlatformResult HumanActivityMonitorManager::GetGpsData(picojson::value* data) {
+  if (!location_handle_) {
+    return PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR);
+  }
+
+  int ret;
+  double altitude, latitude, longitude, climb,
+      direction, speed, horizontal, vertical;
+  location_accuracy_level_e level;
+  time_t timestamp;
+  ret = location_manager_get_location(location_handle_, &altitude, &latitude,
+                                      &longitude, &climb, &direction, &speed,
+                                      &level, &horizontal, &vertical,
+                                      &timestamp);
+  if (ret != LOCATIONS_ERROR_NONE) {
+    LOGGER(ERROR) << "Failed to get location, error: " << ret;
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get location");
+  }
+
+  *data = picojson::value(picojson::array());
+  ConvertGpsEvent(latitude, longitude, altitude, speed, direction, horizontal,
+                  vertical, timestamp, &data->get<picojson::array>());
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
 }  // namespace humanactivitymonitor
 }  // namespace extension

diff --git a/src/humanactivitymonitor/humanactivitymonitor_manager.h b/src/humanactivitymonitor/humanactivitymonitor_manager.h
index 45c1328eeffef74195f4623cd70cb3c8e217f908..9d1ef6623b6719ea3034a44bf804e2ca5a23fd4d 100644 (file)
--- a/src/humanactivitymonitor/humanactivitymonitor_manager.h
+++ b/src/humanactivitymonitor/humanactivitymonitor_manager.h
@@ -32,14 +32,17 @@ class HumanActivityMonitorManager {
   virtual ~HumanActivityMonitorManager();
 
   common::PlatformResult Init();
-  common::PlatformResult IsSupported(const std::string& type);
 
   common::PlatformResult SetListener(const std::string& type,
                                      JsonCallback callback);
   common::PlatformResult UnsetListener(const std::string& type);
 
+  common::PlatformResult GetHumanActivityData(const std::string& type,
+                                              picojson::value* data);
+
  private:
   std::map<std::string, bool> supported_;
+  common::PlatformResult IsSupported(const std::string& type);
 
   // WRIST_UP
   gesture_h gesture_handle_;
@@ -60,6 +63,7 @@ class HumanActivityMonitorManager {
   static void OnHrmSensorEvent(sensor_h sensor,
                                sensor_event_s *event,
                                void *user_data);
+  common::PlatformResult GetHrmData(picojson::value* data);
 
   // GPS
   location_manager_h location_handle_;
@@ -67,6 +71,7 @@ class HumanActivityMonitorManager {
   common::PlatformResult SetGpsListener(JsonCallback callback);
   common::PlatformResult UnsetGpsListener();
   static void OnGpsEvent(int num_of_location, void *user_data);
+  common::PlatformResult GetGpsData(picojson::value* data);
 };
 
 } // namespace humanactivitymonitor