[Sensor] Modify implementation using new native API (#1367)

* sensor_listener_set_events_cb, sensor_listener_unset_events_cb

Signed-off-by: MuHong Byun <mh.byun@samsung.com>

diff --git a/src/Tizen.Sensor/Interop/Interop.Sensor.cs b/src/Tizen.Sensor/Interop/Interop.Sensor.cs
index daa838d..b4d5862 100644 (file)
--- a/src/Tizen.Sensor/Interop/Interop.Sensor.cs
+++ b/src/Tizen.Sensor/Interop/Interop.Sensor.cs
@@ -54,7 +54,12 @@ internal static partial class Interop
     {
         //Sensor Listener CAPI
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [Obsolete("Deprecated since API level 8. Please use the SensorEventsCallback instead.")]
         internal delegate void SensorEventCallback(IntPtr sensorHandle, IntPtr eventData, IntPtr data);
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void SensorEventsCallback(IntPtr sensorHandle, IntPtr eventsData, uint events_count, IntPtr data);
+
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         internal delegate void SensorAccuracyCallback(IntPtr sensorHandle, ulong timestamp, SensorDataAccuracy accuracy, IntPtr data);
 
@@ -71,11 +76,19 @@ internal static partial class Interop
         internal static extern int StopListener(IntPtr listenerHandle);
 
         [DllImport(Libraries.Sensor, EntryPoint = "sensor_listener_set_event_cb")]
+        [Obsolete("Deprecated since API level 8. Please use the SetEventsCallback instead.")]
         internal static extern int SetEventCallback(IntPtr listenerHandle, uint intervalMs, SensorEventCallback callback, IntPtr data);
 
+        [DllImport(Libraries.Sensor, EntryPoint = "sensor_listener_set_events_cb")]
+        internal static extern int SetEventsCallback(IntPtr listenerHandle, SensorEventsCallback callback, IntPtr data);
+
         [DllImport(Libraries.Sensor, EntryPoint = "sensor_listener_unset_event_cb")]
+        [Obsolete("Deprecated since API level 8. Please use the UnsetEventsCallback instead.")]
         internal static extern int UnsetEventCallback(IntPtr listernerHandle);
 
+        [DllImport(Libraries.Sensor, EntryPoint = "sensor_listener_unset_events_cb")]
+        internal static extern int UnsetEventsCallback(IntPtr listernerHandle);
+
         [DllImport(Libraries.Sensor, EntryPoint = "sensor_listener_set_accuracy_cb")]
         internal static extern int SetAccuracyCallback(IntPtr listenerHandle, SensorAccuracyCallback callback, IntPtr data);
 

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/Accelerometer.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/Accelerometer.cs
index 9f7efc9..d6c053a 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/Accelerometer.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/Accelerometer.cs
@@ -136,22 +136,21 @@ namespace Tizen.Sensor
             Z = sensorData.values[2];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
-
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 X = sensorData.values[0];
                 Y = sensorData.values[1];
                 Z = sensorData.values[2];
-
                 DataUpdated?.Invoke(this, new AccelerometerDataUpdatedEventArgs(sensorData.values));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for accelerometer sensor");
@@ -161,7 +160,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for accelerometer sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/AutoRotationSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/AutoRotationSensor.cs
index d435bee..9de5051 100644 (file)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/AutoRotationSensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/AutoRotationSensor.cs
@@ -147,12 +147,13 @@ namespace Tizen.Sensor
             Accuracy = sensorData.accuracy;
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 if (sensorData.values[0] == 0) {
@@ -165,7 +166,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new AutoRotationSensorDataUpdatedEventArgs(sensorData.values, sensorData.accuracy));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for auto rotation sensor");
@@ -175,7 +176,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for auto rotation sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/FaceDownGestureDetector.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/FaceDownGestureDetector.cs
index 70346b8..c21440f 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/FaceDownGestureDetector.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/FaceDownGestureDetector.cs
@@ -120,12 +120,13 @@ namespace Tizen.Sensor
         /// <since_tizen> 3 </since_tizen>
         public event EventHandler<FaceDownGestureDetectorDataUpdatedEventArgs> DataUpdated;
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 FaceDown = (DetectorState) sensorData.values[0];
@@ -133,7 +134,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new FaceDownGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for face down gesture detector");
@@ -143,7 +144,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for face down gesture detector");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/GravitySensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/GravitySensor.cs
index e71a2a7..3d7fbf6 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/GravitySensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/GravitySensor.cs
@@ -162,12 +162,13 @@ namespace Tizen.Sensor
             Z = sensorData.values[2];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 X = sensorData.values[0];
@@ -177,7 +178,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new GravitySensorDataUpdatedEventArgs(sensorData.values));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for gravity sensor");
@@ -187,7 +188,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for gravity sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/Gyroscope.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/Gyroscope.cs
index 0015d26..167d478 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/Gyroscope.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/Gyroscope.cs
@@ -137,12 +137,13 @@ namespace Tizen.Sensor
             Z = sensorData.values[2];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 X = sensorData.values[0];
@@ -152,7 +153,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new GyroscopeDataUpdatedEventArgs(sensorData.values));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for gyroscope sensor");
@@ -162,7 +163,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for gyroscope sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/GyroscopeRotationVectorSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/GyroscopeRotationVectorSensor.cs
index 699eaec..4412c13 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/GyroscopeRotationVectorSensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/GyroscopeRotationVectorSensor.cs
@@ -153,12 +153,13 @@ namespace Tizen.Sensor
             Accuracy = sensorData.accuracy;
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 X = sensorData.values[0];
@@ -170,7 +171,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new GyroscopeRotationVectorSensorDataUpdatedEventArgs(sensorData.values, sensorData.accuracy));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for gyroscope rotation vector sensor");
@@ -180,7 +181,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for gyroscope rotation vector sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/HeartRateMonitor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/HeartRateMonitor.cs
index d2f7a08..7170ce0 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/HeartRateMonitor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/HeartRateMonitor.cs
@@ -123,12 +123,13 @@ namespace Tizen.Sensor
             HeartRate = (int)sensorData.values[0];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 HeartRate = (int)sensorData.values[0];
@@ -136,7 +137,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new HeartRateMonitorDataUpdatedEventArgs((int)sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for heart rate monitor");
@@ -146,7 +147,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for heart rate monitor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/HumiditySensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/HumiditySensor.cs
index dfb1d2c..24247b2 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/HumiditySensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/HumiditySensor.cs
@@ -121,12 +121,13 @@ namespace Tizen.Sensor
             Humidity = sensorData.values[0];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 Humidity = sensorData.values[0];
@@ -134,7 +135,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new HumiditySensorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for humidity sensor");
@@ -144,7 +145,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for humidity sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/InVehicleActivityDetector.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/InVehicleActivityDetector.cs
index 3b2958a..58955f0 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/InVehicleActivityDetector.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/InVehicleActivityDetector.cs
@@ -117,12 +117,13 @@ namespace Tizen.Sensor
         /// <since_tizen> 3 </since_tizen>
         public event EventHandler<InVehicleActivityDetectorDataUpdatedEventArgs> DataUpdated;
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 InVehicle = (DetectorState)sensorData.values[0];
@@ -131,7 +132,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new InVehicleActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for invehicle activity detector");
@@ -141,7 +142,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for invehicle activity detector");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/LightSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/LightSensor.cs
index af68a5b..9458ace 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/LightSensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/LightSensor.cs
@@ -121,12 +121,13 @@ namespace Tizen.Sensor
             Level = sensorData.values[0];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 Level = sensorData.values[0];
@@ -134,7 +135,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new LightSensorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for light sensor");
@@ -144,7 +145,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for light sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/LinearAccelerationSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/LinearAccelerationSensor.cs
index 4d80669..b41965c 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/LinearAccelerationSensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/LinearAccelerationSensor.cs
@@ -162,12 +162,13 @@ namespace Tizen.Sensor
             Z = sensorData.values[2];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 X = sensorData.values[0];
@@ -177,7 +178,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new LinearAccelerationSensorDataUpdatedEventArgs(sensorData.values));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for linear acceleration sensor");
@@ -187,7 +188,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for linear acceleration sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/Magnetometer.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/Magnetometer.cs
index ac06bc2..8782d57 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/Magnetometer.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/Magnetometer.cs
@@ -162,12 +162,13 @@ namespace Tizen.Sensor
             Z = sensorData.values[2];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 X = sensorData.values[0];
@@ -177,7 +178,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new MagnetometerDataUpdatedEventArgs(sensorData.values));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for magnetometer");
@@ -187,7 +188,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for magnetometer");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/MagnetometerRotationVectorSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/MagnetometerRotationVectorSensor.cs
index fa3480b..97d45f4 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/MagnetometerRotationVectorSensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/MagnetometerRotationVectorSensor.cs
@@ -190,12 +190,13 @@ namespace Tizen.Sensor
             Accuracy = sensorData.accuracy;
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 X = sensorData.values[0];
@@ -207,7 +208,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new MagnetometerRotationVectorSensorDataUpdatedEventArgs(sensorData.values, sensorData.accuracy));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for magnetometer rotation vector sensor");
@@ -217,7 +218,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for magnetometer rotation vector sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/OrientationSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/OrientationSensor.cs
index 674be0c..6293574 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/OrientationSensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/OrientationSensor.cs
@@ -162,12 +162,13 @@ namespace Tizen.Sensor
             Roll = sensorData.values[2];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 Azimuth = sensorData.values[0];
@@ -177,7 +178,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new OrientationSensorDataUpdatedEventArgs(sensorData.values));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for orientation sensor");
@@ -187,7 +188,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for orientation sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/Pedometer.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/Pedometer.cs
index a175477..0481ca0 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/Pedometer.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/Pedometer.cs
@@ -179,12 +179,13 @@ namespace Tizen.Sensor
             LastStepStatus = (PedometerState)pedoSensorData.values[7];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 StepCount = (uint)sensorData.values[0];
@@ -199,7 +200,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new PedometerDataUpdatedEventArgs(sensorData.values));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for pedometer sensor");
@@ -209,7 +210,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for pedometer sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/PickUpGestureDetector.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/PickUpGestureDetector.cs
index fc9ccd6..418bec3 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/PickUpGestureDetector.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/PickUpGestureDetector.cs
@@ -132,12 +132,13 @@ namespace Tizen.Sensor
         /// <since_tizen> 3 </since_tizen>
         public event EventHandler<PickUpGestureDetectorDataUpdatedEventArgs> DataUpdated;
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 PickUp = (DetectorState) sensorData.values[0];
@@ -145,7 +146,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new PickUpGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for pick up gesture detector");
@@ -155,7 +156,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for pick up gesture detector");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/PressureSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/PressureSensor.cs
index 9d5aaa2..295609e 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/PressureSensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/PressureSensor.cs
@@ -122,12 +122,13 @@ namespace Tizen.Sensor
             Pressure = sensorData.values[0];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 Pressure = sensorData.values[0];
@@ -135,7 +136,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new PressureSensorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for pressure sensor");
@@ -145,7 +146,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for pressure sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/ProximitySensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/ProximitySensor.cs
index dec5a49..fd4205a 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/ProximitySensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/ProximitySensor.cs
@@ -121,12 +121,13 @@ namespace Tizen.Sensor
             Proximity = (ProximitySensorState)sensorData.values[0];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 Proximity = (ProximitySensorState) sensorData.values[0];
@@ -134,7 +135,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new ProximitySensorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for proximity sensor");
@@ -144,7 +145,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for proximity sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/RotationVectorSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/RotationVectorSensor.cs
index 8de60c7..cac4716 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/RotationVectorSensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/RotationVectorSensor.cs
@@ -178,12 +178,13 @@ namespace Tizen.Sensor
             Accuracy = sensorData.accuracy;
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 X = sensorData.values[0];
@@ -195,7 +196,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new RotationVectorSensorDataUpdatedEventArgs(sensorData.values, sensorData.accuracy));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for rotation vector sensor");
@@ -205,7 +206,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for rotation vector sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/RunningActivityDetector.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/RunningActivityDetector.cs
index db8c7e7..3778331 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/RunningActivityDetector.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/RunningActivityDetector.cs
@@ -117,12 +117,13 @@ namespace Tizen.Sensor
         /// <since_tizen> 3 </since_tizen>
         public event EventHandler<RunningActivityDetectorDataUpdatedEventArgs> DataUpdated;
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 Running = (DetectorState)sensorData.values[0];
@@ -131,7 +132,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new RunningActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for running activity detector");
@@ -141,7 +142,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for running activity detector");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/SleepMonitor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/SleepMonitor.cs
index edb7ca7..cc15999 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/SleepMonitor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/SleepMonitor.cs
@@ -125,12 +125,13 @@ namespace Tizen.Sensor
             SleepState = (SleepMonitorState)sensorData.values[0];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 SleepState = (SleepMonitorState)sensorData.values[0];
@@ -138,7 +139,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new SleepMonitorDataUpdatedEventArgs((int)sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for sleep monitor");
@@ -148,7 +149,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for sleep monitor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/StationaryActivityDetector.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/StationaryActivityDetector.cs
index c8cfd3a..00ad3ef 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/StationaryActivityDetector.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/StationaryActivityDetector.cs
@@ -117,12 +117,13 @@ namespace Tizen.Sensor
         /// <since_tizen> 3 </since_tizen>
         public event EventHandler<StationaryActivityDetectorDataUpdatedEventArgs> DataUpdated;
 
-        internal static Interop.SensorListener.SensorEventCallback _callback;
+        internal static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 Stationary = (DetectorState)sensorData.values[0];
@@ -131,7 +132,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new StationaryActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for stationary activity detector");
@@ -141,7 +142,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for stationary activity detector");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/TemperatureSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/TemperatureSensor.cs
index ba6df4e..2ced599 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/TemperatureSensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/TemperatureSensor.cs
@@ -122,12 +122,13 @@ namespace Tizen.Sensor
             Temperature = sensorData.values[0];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 Temperature = sensorData.values[0];
@@ -135,7 +136,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new TemperatureSensorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for temperature sensor");
@@ -145,7 +146,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for temperature sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/UltravioletSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/UltravioletSensor.cs
index ec900da..2a86228 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/UltravioletSensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/UltravioletSensor.cs
@@ -122,12 +122,13 @@ namespace Tizen.Sensor
             UltravioletIndex = sensorData.values[0];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 UltravioletIndex = sensorData.values[0];
@@ -135,7 +136,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new UltravioletSensorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for ultraviolet sensor");
@@ -145,7 +146,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for ultraviolet sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedGyroscope.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedGyroscope.cs
index 3c1e20e..f459eac 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedGyroscope.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedGyroscope.cs
@@ -161,12 +161,13 @@ namespace Tizen.Sensor
             BiasZ = sensorData.values[5];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 X = sensorData.values[0];
@@ -179,7 +180,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new UncalibratedGyroscopeDataUpdatedEventArgs(sensorData.values));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for uncalibrated gyroscope sensor");
@@ -189,7 +190,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for uncalibrated gyroscope sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedMagnetometer.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedMagnetometer.cs
index f87b09e..6152992 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedMagnetometer.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedMagnetometer.cs
@@ -186,12 +186,13 @@ namespace Tizen.Sensor
             BiasZ = sensorData.values[5];
         }
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 X = sensorData.values[0];
@@ -204,7 +205,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new UncalibratedMagnetometerDataUpdatedEventArgs(sensorData.values));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for uncalibrated magnetometer sensor");
@@ -214,7 +215,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for uncalibrated magnetometer sensor");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/WalkingActivityDetector.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/WalkingActivityDetector.cs
index 8b9d104..116f712 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/WalkingActivityDetector.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/WalkingActivityDetector.cs
@@ -117,12 +117,13 @@ namespace Tizen.Sensor
         /// <since_tizen> 3 </since_tizen>
         public event EventHandler<WalkingActivityDetectorDataUpdatedEventArgs> DataUpdated;
 
-        internal static Interop.SensorListener.SensorEventCallback _callback;
+        internal static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 Walking = (DetectorState)sensorData.values[0];
@@ -131,7 +132,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new WalkingActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for walking activity detector");
@@ -141,7 +142,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for walking activity detector");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/WristUpGestureDetector.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/WristUpGestureDetector.cs
index 27f488a..6ff7e47 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Plugins/WristUpGestureDetector.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/WristUpGestureDetector.cs
@@ -120,12 +120,13 @@ namespace Tizen.Sensor
         /// <since_tizen> 3 </since_tizen>
         public event EventHandler<WristUpGestureDetectorDataUpdatedEventArgs> DataUpdated;
 
-        private static Interop.SensorListener.SensorEventCallback _callback;
+        private static Interop.SensorListener.SensorEventsCallback _callback;
 
         internal override void EventListenStart()
         {
-            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
-                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+                updateBatchEvents(eventPtr, events_count);
+                Interop.SensorEventStruct sensorData = latestEvent();
 
                 TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
                 WristUp = (DetectorState) sensorData.values[0];
@@ -133,7 +134,7 @@ namespace Tizen.Sensor
                 DataUpdated?.Invoke(this, new WristUpGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
             };
 
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for wrist up gesture detector");
@@ -143,7 +144,7 @@ namespace Tizen.Sensor
 
         internal override void EventListenStop()
         {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error unsetting event callback for wrist up gesture detector");

diff --git a/src/Tizen.Sensor/Tizen.Sensor/Sensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Sensor.cs
index 3ebcfbb..83fa534 100755 (executable)
--- a/src/Tizen.Sensor/Tizen.Sensor/Sensor.cs
+++ b/src/Tizen.Sensor/Tizen.Sensor/Sensor.cs
@@ -16,6 +16,8 @@
 
 using System;
 using Tizen.System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
 
 namespace Tizen.Sensor
 {
@@ -46,6 +48,8 @@ namespace Tizen.Sensor
         private SensorPausePolicy _pausePolicy = SensorPausePolicy.None;
         private IntPtr _sensorHandle = IntPtr.Zero;
         private IntPtr _listenerHandle = IntPtr.Zero;
+        private List<Interop.SensorEventStruct> batchedEvents { get; set; } = new List<Interop.SensorEventStruct>();
+
 
         /// <summary>
         /// Read a sensor data synchronously.
@@ -55,6 +59,29 @@ namespace Tizen.Sensor
         internal abstract void EventListenStart();
         internal abstract void EventListenStop();
 
+        internal void updateBatchEvents(IntPtr eventsPtr, uint events_count)
+        {
+            if (events_count >= 1)
+            {
+                batchedEvents.Clear();
+                IntPtr currentPtr = eventsPtr;
+                for (int i = 0; i < events_count; i++)
+                {
+                    batchedEvents.Add(Interop.IntPtrToEventStruct(currentPtr));
+                    currentPtr += Marshal.SizeOf<Interop.SensorEventStruct>();
+                }
+            }
+        }
+
+        internal Interop.SensorEventStruct latestEvent()
+        {
+            if (batchedEvents.Count > 0)
+            {
+                return batchedEvents[batchedEvents.Count-1];
+            }
+            return default(Interop.SensorEventStruct);
+        }
+
         internal Sensor(uint index)
         {
             SensorType type = GetSensorType();