[HRM] Fix for resetting pedometer data after calling start

[Bug] Pedometer properties were not reset
      back to zero after calling start again.

[Verification] Auto TCT passrate 100%
    Manual (wearable and mobile emulators) 100%

Change-Id: I4b961a5c05224accb7ff482c570b3dd3aa352bb4
Signed-off-by: Pawel Kaczmarczyk <p.kaczmarczy@samsung.com>

diff --git a/src/humanactivitymonitor/humanactivitymonitor_manager.cc b/src/humanactivitymonitor/humanactivitymonitor_manager.cc
index 9a52f2fdd4f2380058b99e282993fe18700af79d..1dc5779d59e101a01aa4b0c735cc668a079386b4 100644 (file)
--- a/src/humanactivitymonitor/humanactivitymonitor_manager.cc
+++ b/src/humanactivitymonitor/humanactivitymonitor_manager.cc
@@ -269,6 +269,7 @@ class HumanActivityMonitorManager::Monitor {
   class GestureMonitor;
   class SensorMonitor;
   class GpsMonitor;
+  class PedometerMonitor;
 
   explicit Monitor(const std::string& t) : type_(t) {
     ScopeLogger(type());
@@ -533,10 +534,10 @@ class HumanActivityMonitorManager::Monitor::SensorMonitor
   SensorMonitor(const std::string& t, sensor_type_e s, const SensorEventConverter& c,
                 const SensorRecordedConverter& r)
       : Monitor(t),
-        sensor_(s),
-        handle_(nullptr),
         converter_(c),
         converter_recorded_(r),
+        sensor_(s),
+        handle_(nullptr),
         recorded_data_(nullptr) {
     ScopeLogger(type());
   }
@@ -764,6 +765,9 @@ class HumanActivityMonitorManager::Monitor::SensorMonitor
     recorded_data_->push_back(*data);
   }
 
+  SensorEventConverter converter_;
+  SensorRecordedConverter converter_recorded_;
+
  private:
   static void OnSensorEvent(sensor_h, sensor_event_s* event, void* user_data) {
     ScopeLogger();
@@ -869,12 +873,123 @@ class HumanActivityMonitorManager::Monitor::SensorMonitor
 
   sensor_type_e sensor_;
   sensor_listener_h handle_;
-  SensorEventConverter converter_;
-  SensorRecordedConverter converter_recorded_;
   picojson::array* recorded_data_;
   std::mutex mutex_;
 };
 
+class HumanActivityMonitorManager::Monitor::PedometerMonitor
+    : public HumanActivityMonitorManager::Monitor::SensorMonitor {
+ private:
+  bool is_first_read;
+
+ public:
+  PedometerMonitor()
+      : SensorMonitor(kActivityTypePedometer, SENSOR_HUMAN_PEDOMETER, nullptr, nullptr),
+        is_first_read(true) {
+    ScopeLogger();
+    converter_ = [this](sensor_event_s* event, picojson::object* data) -> PlatformResult {
+
+      ScopeLogger("Entered into asynchronous function, convert_pedometer");
+
+      const auto pedometer_data = (PedometerDataWrapper*)event;
+
+      static PedometerDataWrapper initial_pedometer_data;
+
+      if (this->is_first_read) {
+        initial_pedometer_data = *pedometer_data;
+        this->is_first_read = false;
+      }
+
+      static float steps_so_far = 0.0;
+
+      const auto state = pedometer_data->state();
+
+      data->insert(std::make_pair(kStepStatus, picojson::value(FromSensorPedometerState(state))));
+      data->insert(std::make_pair(kSpeed, picojson::value(pedometer_data->speed())));
+      data->insert(std::make_pair(kWalkingFrequency, picojson::value(pedometer_data->frequency())));
+
+      data->insert(std::make_pair(
+          kCumulativeDistance,
+          picojson::value(pedometer_data->distance() - initial_pedometer_data.distance())));
+      data->insert(std::make_pair(
+          kCumulativeCalorie,
+          picojson::value(pedometer_data->calories() - initial_pedometer_data.calories())));
+      data->insert(std::make_pair(
+          kCumulativeTotalStepCount,
+          picojson::value(pedometer_data->steps() - initial_pedometer_data.steps())));
+      data->insert(std::make_pair(
+          kCumulativeWalkStepCount,
+          picojson::value(pedometer_data->walk_steps() - initial_pedometer_data.walk_steps())));
+      data->insert(std::make_pair(
+          kCumulativeRunStepCount,
+          picojson::value(pedometer_data->run_steps() - initial_pedometer_data.run_steps())));
+
+      data->insert(
+          std::make_pair(kAccumulativeDistance, picojson::value(pedometer_data->distance())));
+      data->insert(
+          std::make_pair(kAccumulativeCalorie, picojson::value(pedometer_data->calories())));
+      data->insert(
+          std::make_pair(kAccumulativeTotalStepCount, picojson::value(pedometer_data->steps())));
+      data->insert(std::make_pair(kAccumulativeWalkStepCount,
+                                  picojson::value(pedometer_data->walk_steps())));
+      data->insert(
+          std::make_pair(kAccumulativeRunStepCount, picojson::value(pedometer_data->run_steps())));
+
+      auto& diffs =
+          data->insert(std::make_pair(kStepCountDifferences, picojson::value{picojson::array{}}))
+              .first->second.get<picojson::array>();
+      LoggerD("pedometer_data->diffs_count: %d", pedometer_data->diffs_count);
+      if (pedometer_data->diffs_count > 0) {
+        for (int i = 0; i < pedometer_data->diffs_count; ++i) {
+          InsertStepDifference(pedometer_data->diffs[i].steps,
+                               getCurrentTimeStamp(pedometer_data->diffs[i].timestamp) / 1000,
+                               &diffs);
+        }
+      } else {
+        InsertStepDifference(steps_so_far > 0.0 ? pedometer_data->steps() - steps_so_far : 0.0,
+                             getCurrentTimeStamp(pedometer_data->timestamp) / 1000, &diffs);
+      }
+
+      steps_so_far = pedometer_data->steps();
+
+      return PlatformResult(ErrorCode::NO_ERROR);
+    };
+
+    converter_recorded_ = [](void* data, picojson::object* obj) -> PlatformResult {
+      ScopeLogger("Entered into asynchronous function, convert_recorded_pedometer");
+
+      SensorRecorderDataMap map_int{{SENSOR_RECORDER_DATA_STEPS, kRecordedTotalStepCount},
+                                    {SENSOR_RECORDER_DATA_WALK_STEPS, kRecordedWalkStepCount},
+                                    {SENSOR_RECORDER_DATA_RUN_STEPS, kRecordedRunStepCount}};
+
+      SensorRecorderDataMap map_double{{SENSOR_RECORDER_DATA_DISTANCE, kRecordedDistance},
+                                       {SENSOR_RECORDER_DATA_CALORIE, kRecordedCalorie}};
+
+      auto result = ConvertRecordedInt(data, obj, map_int);
+      if (!result) {
+        return result;
+      }
+
+      result = ConvertRecordedDouble(data, obj, map_double);
+      if (!result) {
+        return result;
+      }
+
+      return ConvertRecordedTime(data, obj);
+    };
+  }
+
+  virtual ~PedometerMonitor() {
+    ScopeLogger();
+  }
+
+  virtual PlatformResult SetListenerImpl(const picojson::value& args) override {
+    ScopeLogger();
+    is_first_read = true;
+    return HumanActivityMonitorManager::Monitor::SensorMonitor::SetListenerImpl(args);
+  }
+};
+
 class HumanActivityMonitorManager::Monitor::GpsMonitor
     : public HumanActivityMonitorManager::Monitor {
  public:
@@ -1299,66 +1414,6 @@ HumanActivityMonitorManager::HumanActivityMonitorManager()
     : activity_recognition_(std::make_shared<ActivityRecognition>()) {
   ScopeLogger();
 
-  auto convert_pedometer = [](sensor_event_s* event, picojson::object* data) -> PlatformResult {
-    ScopeLogger("Entered into asynchronous function, convert_pedometer");
-
-    const auto pedometer_data = (PedometerDataWrapper*)event;
-
-    static const auto initial_pedometer_data = *pedometer_data;  // will be initialized only once
-    static float steps_so_far = 0.0;
-
-    const auto state = pedometer_data->state();
-
-    data->insert(std::make_pair(kStepStatus, picojson::value(FromSensorPedometerState(state))));
-    data->insert(std::make_pair(kSpeed, picojson::value(pedometer_data->speed())));
-    data->insert(std::make_pair(kWalkingFrequency, picojson::value(pedometer_data->frequency())));
-
-    data->insert(std::make_pair(
-        kCumulativeDistance,
-        picojson::value(pedometer_data->distance() - initial_pedometer_data.distance())));
-    data->insert(std::make_pair(
-        kCumulativeCalorie,
-        picojson::value(pedometer_data->calories() - initial_pedometer_data.calories())));
-    data->insert(
-        std::make_pair(kCumulativeTotalStepCount,
-                       picojson::value(pedometer_data->steps() - initial_pedometer_data.steps())));
-    data->insert(std::make_pair(
-        kCumulativeWalkStepCount,
-        picojson::value(pedometer_data->walk_steps() - initial_pedometer_data.walk_steps())));
-    data->insert(std::make_pair(
-        kCumulativeRunStepCount,
-        picojson::value(pedometer_data->run_steps() - initial_pedometer_data.run_steps())));
-
-    data->insert(
-        std::make_pair(kAccumulativeDistance, picojson::value(pedometer_data->distance())));
-    data->insert(std::make_pair(kAccumulativeCalorie, picojson::value(pedometer_data->calories())));
-    data->insert(
-        std::make_pair(kAccumulativeTotalStepCount, picojson::value(pedometer_data->steps())));
-    data->insert(
-        std::make_pair(kAccumulativeWalkStepCount, picojson::value(pedometer_data->walk_steps())));
-    data->insert(
-        std::make_pair(kAccumulativeRunStepCount, picojson::value(pedometer_data->run_steps())));
-
-    auto& diffs =
-        data->insert(std::make_pair(kStepCountDifferences, picojson::value{picojson::array{}}))
-            .first->second.get<picojson::array>();
-    LOGGER(DEBUG) << "  pedometer_data->diffs_coun: " << pedometer_data->diffs_count;
-    if (pedometer_data->diffs_count > 0) {
-      for (int i = 0; i < pedometer_data->diffs_count; ++i) {
-        InsertStepDifference(pedometer_data->diffs[i].steps,
-                             getCurrentTimeStamp(pedometer_data->diffs[i].timestamp) / 1000,
-                             &diffs);
-      }
-    } else {
-      InsertStepDifference(steps_so_far > 0.0 ? pedometer_data->steps() - steps_so_far : 0.0,
-                           getCurrentTimeStamp(pedometer_data->timestamp) / 1000, &diffs);
-    }
-
-    steps_so_far = pedometer_data->steps();
-
-    return PlatformResult(ErrorCode::NO_ERROR);
-  };
-
   auto convert_hrm = [](sensor_event_s* event, picojson::object* data) -> PlatformResult {
     ScopeLogger("Entered into asynchronous function, convert_hrm");
 
@@ -1425,29 +1480,6 @@ HumanActivityMonitorManager::HumanActivityMonitorManager()
     return PlatformResult(ErrorCode::NO_ERROR);
   };
 
-  auto convert_recorded_pedometer = [](void* data, picojson::object* obj) -> PlatformResult {
-    ScopeLogger("Entered into asynchronous function, convert_recorded_pedometer");
-
-    SensorRecorderDataMap map_int{{SENSOR_RECORDER_DATA_STEPS, kRecordedTotalStepCount},
-                                  {SENSOR_RECORDER_DATA_WALK_STEPS, kRecordedWalkStepCount},
-                                  {SENSOR_RECORDER_DATA_RUN_STEPS, kRecordedRunStepCount}};
-
-    SensorRecorderDataMap map_double{{SENSOR_RECORDER_DATA_DISTANCE, kRecordedDistance},
-                                     {SENSOR_RECORDER_DATA_CALORIE, kRecordedCalorie}};
-
-    auto result = ConvertRecordedInt(data, obj, map_int);
-    if (!result) {
-      return result;
-    }
-
-    result = ConvertRecordedDouble(data, obj, map_double);
-    if (!result) {
-      return result;
-    }
-
-    return ConvertRecordedTime(data, obj);
-  };
-
   auto convert_recorded_hrm = [](void* data, picojson::object* obj) -> PlatformResult {
     ScopeLogger("Entered into asynchronous function, convert_recorded_hrm");
 
@@ -1491,10 +1523,8 @@ HumanActivityMonitorManager::HumanActivityMonitorManager()
     return ConvertRecordedTime(data, obj);
   };
 
-  monitors_.insert(std::make_pair(
-      kActivityTypePedometer,
-      std::make_shared<Monitor::SensorMonitor>(kActivityTypePedometer, SENSOR_HUMAN_PEDOMETER,
-                                               convert_pedometer, convert_recorded_pedometer)));
+  monitors_.insert(std::make_pair(kActivityTypePedometer,
+                                  std::make_shared<Monitor::PedometerMonitor>()));
   monitors_.insert(std::make_pair(kActivityTypeWristUp,
                                   std::make_shared<Monitor::GestureMonitor>(kActivityTypeWristUp)));
   monitors_.insert(std::make_pair(