csapi-sensor: fix bug about the lifetime of delegate

When the callback is passed to the native layer using PInvoke,
the lifetime of delegate has to be considered.
if the member function is passed to the interop directly, the memory
allocated within this function is not managed by the GC.

Change-Id: I06ab30b0e62c1f4baba5bcb38dd75f9764a3b0d5
Signed-off-by: kibak.yoon <kibak.yoon@samsung.com>

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/Accelerometer.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/Accelerometer.cs
index 7b842936a4da26f21aa0ef67ca5e08014ca7d56d..3e18ad8b0797fea826286c1c7bda1a0af2d1317f 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/Accelerometer.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/Accelerometer.cs
@@ -103,9 +103,22 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                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);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for accelerometer sensor");
@@ -122,16 +135,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for accelerometer");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            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));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/ActivityDetector.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/ActivityDetector.cs
index d62d9d3d20b53eafbce3152ade667155cfcc40dc..8e3397217ea439d3ef6858c734a6aca95d9432d6 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/ActivityDetector.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/ActivityDetector.cs
@@ -37,30 +37,8 @@ namespace Tizen.Sensor
         /// </summary>
         public SensorDataAccuracy ActivityAccuracy { get; protected set; }
 
-        internal abstract void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data);
-
         internal ActivityDetector(uint index) : base(index)
         {
         }
-
-        internal override void EventListenStart()
-        {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
-            if (error != (int)SensorError.None)
-            {
-                Log.Error(Globals.LogTag, "Error setting event callback for activity detector");
-                throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set event callback for activity detector");
-            }
-        }
-
-        internal override void EventListenStop()
-        {
-            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
-            if (error != (int)SensorError.None)
-            {
-                Log.Error(Globals.LogTag, "Error unsetting event callback for activity detector");
-                throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for activity detector");
-            }
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/FaceDownGestureDetector.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/FaceDownGestureDetector.cs
index 842516e386648fb6f45ee33d1e6562b7295a8743..19028557c9fc99b4d4597c0a67be190f8130e9d9 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/FaceDownGestureDetector.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/FaceDownGestureDetector.cs
@@ -93,9 +93,20 @@ namespace Tizen.Sensor
         /// </summary>
         public event EventHandler<FaceDownGestureDetectorDataUpdatedEventArgs> DataUpdated;
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                FaceDown = (DetectorState) sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new FaceDownGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for face down gesture detector");
@@ -112,14 +123,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for face down gesture detector");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            FaceDown = (DetectorState) sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new FaceDownGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/GravitySensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/GravitySensor.cs
index dd1f4b7b338f46d74729214a8c4a4df66d9bb10f..41d90e372ca9868362cbd9a8c3bc3708b318f613 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/GravitySensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/GravitySensor.cs
@@ -128,9 +128,22 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                X = sensorData.values[0];
+                Y = sensorData.values[1];
+                Z = sensorData.values[2];
+
+                DataUpdated?.Invoke(this, new GravitySensorDataUpdatedEventArgs(sensorData.values));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for gravity sensor");
@@ -148,9 +161,16 @@ namespace Tizen.Sensor
             }
         }
 
+        private static Interop.SensorListener.SensorAccuracyCallback _accuracyCallback;
+
         private void AccuracyListenStart()
         {
-            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, AccuracyEventCallback, IntPtr.Zero);
+            _accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
+                TimeSpan = new TimeSpan((Int64)timestamp);
+                _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+            };
+
+            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting accuracy event callback for gravity sensor");
@@ -167,22 +187,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset accuracy event callback for gravity");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            X = sensorData.values[0];
-            Y = sensorData.values[1];
-            Z = sensorData.values[2];
-
-            DataUpdated?.Invoke(this, new GravitySensorDataUpdatedEventArgs(sensorData.values));
-        }
-
-        private void AccuracyEventCallback(IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data)
-        {
-            TimeSpan = new TimeSpan((Int64)timestamp);
-            _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/Gyroscope.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/Gyroscope.cs
index b1b701d1d76aeef86f9ec1d72a62908e9f9555ae..09be0a1632bb5a53333dcffb4bd1973e4f87ff39 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/Gyroscope.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/Gyroscope.cs
@@ -104,9 +104,22 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                X = sensorData.values[0];
+                Y = sensorData.values[1];
+                Z = sensorData.values[2];
+
+                DataUpdated?.Invoke(this, new GyroscopeDataUpdatedEventArgs(sensorData.values));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for gyroscope sensor");
@@ -123,16 +136,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for gyroscope");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            X = sensorData.values[0];
-            Y = sensorData.values[1];
-            Z = sensorData.values[2];
-
-            DataUpdated?.Invoke(this, new GyroscopeDataUpdatedEventArgs(sensorData.values));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/GyroscopeRotationVectorSensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/GyroscopeRotationVectorSensor.cs
index 278bc0ed8c69777524a71c83a2e49d77560e258a..dfecaab9793f07419514f31d095b59c27a181941 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/GyroscopeRotationVectorSensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/GyroscopeRotationVectorSensor.cs
@@ -114,9 +114,24 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                X = sensorData.values[0];
+                Y = sensorData.values[1];
+                Z = sensorData.values[2];
+                W = sensorData.values[3];
+                Accuracy = sensorData.accuracy;
+
+                DataUpdated?.Invoke(this, new GyroscopeRotationVectorSensorDataUpdatedEventArgs(sensorData.values, sensorData.accuracy));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for gyroscope rotation vector sensor");
@@ -133,18 +148,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for gyroscope rotation vector");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            X = sensorData.values[0];
-            Y = sensorData.values[1];
-            Z = sensorData.values[2];
-            Accuracy = sensorData.accuracy;
-
-            DataUpdated?.Invoke(this, new GyroscopeRotationVectorSensorDataUpdatedEventArgs(sensorData.values, sensorData.accuracy));
-        }
-
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/HeartRateMonitor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/HeartRateMonitor.cs
index d3f26b7ef07cb3c79e1ae20fa0eb06c4faa6431e..154abc277545046e9e0493934f5db5c149e8ff77 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/HeartRateMonitor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/HeartRateMonitor.cs
@@ -98,9 +98,20 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                HeartRate = (int)sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new HeartRateMonitorDataUpdatedEventArgs((int)sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for heart rate monitor");
@@ -117,14 +128,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for heart rate");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            HeartRate = (int)sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new HeartRateMonitorDataUpdatedEventArgs((int)sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/HumiditySensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/HumiditySensor.cs
index 60bf89f70c14f4b47c456dde95086a0f925cdce8..0c992e63e333ff8c7ec1e286c9d09bb039180a19 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/HumiditySensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/HumiditySensor.cs
@@ -94,9 +94,20 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                Humidity = sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new HumiditySensorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for humidity sensor");
@@ -113,14 +124,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for humidity");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            Humidity = sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new HumiditySensorDataUpdatedEventArgs(sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/InVehicleActivityDetector.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/InVehicleActivityDetector.cs
index 3e0dcaacf9d348bba0d7033144d3a59a65ada0f9..5c35a18ee2bddc78c1012268d8c56a6dee1375f9 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/InVehicleActivityDetector.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/InVehicleActivityDetector.cs
@@ -89,14 +89,36 @@ namespace Tizen.Sensor
         /// </summary>
         public event EventHandler<InVehicleActivityDetectorDataUpdatedEventArgs> DataUpdated;
 
-        internal override void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
+        internal override void EventListenStart()
         {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            InVehicle = (DetectorState)sensorData.values[0];
-            ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                InVehicle = (DetectorState)sensorData.values[0];
+                ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
+
+                DataUpdated?.Invoke(this, new InVehicleActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            if (error != (int)SensorError.None)
+            {
+                Log.Error(Globals.LogTag, "Error setting event callback for invehicle activity detector");
+                throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set event callback for invehicle activity detector");
+            }
+        }
 
-            DataUpdated?.Invoke(this, new InVehicleActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
+        internal override void EventListenStop()
+        {
+            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            if (error != (int)SensorError.None)
+            {
+                Log.Error(Globals.LogTag, "Error unsetting event callback for invehicle activity detector");
+                throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for invehicle activity detector");
+            }
         }
 
         internal override SensorType GetSensorType()

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/LightSensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/LightSensor.cs
index c27c7e375316cf16e1f297217a1d7d2608361200..fffdfc9b496261e21ddf4f074197eff739f9fd38 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/LightSensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/LightSensor.cs
@@ -94,9 +94,20 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                Level = sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new LightSensorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for light sensor");
@@ -113,14 +124,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for light");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            Level = sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new LightSensorDataUpdatedEventArgs(sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/LinearAccelerationSensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/LinearAccelerationSensor.cs
index d82906df81331b693829fffc4d0d7060ef9ddb40..101750613be6be809d1921c0dffc7da568f88cc8 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/LinearAccelerationSensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/LinearAccelerationSensor.cs
@@ -128,9 +128,22 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                X = sensorData.values[0];
+                Y = sensorData.values[1];
+                Z = sensorData.values[2];
+
+                DataUpdated?.Invoke(this, new LinearAccelerationSensorDataUpdatedEventArgs(sensorData.values));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for linear acceleration sensor");
@@ -148,9 +161,16 @@ namespace Tizen.Sensor
             }
         }
 
+        private static Interop.SensorListener.SensorAccuracyCallback _accuracyCallback;
+
         private void AccuracyListenStart()
         {
-            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, AccuracyEventCallback, IntPtr.Zero);
+            _accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
+                TimeSpan = new TimeSpan((Int64)timestamp);
+                _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+            };
+
+            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting accuracy event callback for linear acceleration sensor");
@@ -167,22 +187,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset accuracy event callback for linear acceleration sensor");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            X = sensorData.values[0];
-            Y = sensorData.values[1];
-            Z = sensorData.values[2];
-
-            DataUpdated?.Invoke(this, new LinearAccelerationSensorDataUpdatedEventArgs(sensorData.values));
-        }
-
-        private void AccuracyEventCallback(IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data)
-        {
-            TimeSpan = new TimeSpan((Int64)timestamp);
-            _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/Magnetometer.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/Magnetometer.cs
index df9f04b9e6b093c6fe06be5b4514a72c59fbabd0..a695cf17520f81c34609449fcb66581eec21544e 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/Magnetometer.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/Magnetometer.cs
@@ -128,9 +128,22 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                X = sensorData.values[0];
+                Y = sensorData.values[1];
+                Z = sensorData.values[2];
+
+                DataUpdated?.Invoke(this, new MagnetometerDataUpdatedEventArgs(sensorData.values));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for magnetometer");
@@ -148,9 +161,16 @@ namespace Tizen.Sensor
             }
         }
 
+        private static Interop.SensorListener.SensorAccuracyCallback _accuracyCallback;
+
         private void AccuracyListenStart()
         {
-            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, AccuracyEventCallback, IntPtr.Zero);
+            _accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
+                TimeSpan = new TimeSpan((Int64)timestamp);
+                _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+            };
+
+            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting accuracy event callback for magnetometer");
@@ -167,22 +187,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset accuracy event callback for magnetometer");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            X = sensorData.values[0];
-            Y = sensorData.values[1];
-            Z = sensorData.values[2];
-
-            DataUpdated?.Invoke(this, new MagnetometerDataUpdatedEventArgs(sensorData.values));
-        }
-
-        private void AccuracyEventCallback(IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data)
-        {
-            TimeSpan = new TimeSpan((Int64)timestamp);
-            _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/MagnetometerRotationVectorSensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/MagnetometerRotationVectorSensor.cs
index c92fc7868411bf69e93c7fb65afa7c12a2032b4e..e0330430fbea5bb884102c602ce1e9f7f3f6a807 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/MagnetometerRotationVectorSensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/MagnetometerRotationVectorSensor.cs
@@ -150,9 +150,24 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                X = sensorData.values[0];
+                Y = sensorData.values[1];
+                Z = sensorData.values[2];
+                W = sensorData.values[3];
+                Accuracy = sensorData.accuracy;
+
+                DataUpdated?.Invoke(this, new MagnetometerRotationVectorSensorDataUpdatedEventArgs(sensorData.values, sensorData.accuracy));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for magnetometer rotation vector sensor");
@@ -170,9 +185,17 @@ namespace Tizen.Sensor
             }
         }
 
+        private static Interop.SensorListener.SensorAccuracyCallback _accuracyCallback;
+
         private void AccuracyListenStart()
         {
-            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, AccuracyEventCallback, IntPtr.Zero);
+            _accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
+                TimeSpan = new TimeSpan((Int64)timestamp);
+                Accuracy = accuracy;
+                _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+            };
+
+            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting accuracy event callback for magnetometer rotation vector sensor");
@@ -189,24 +212,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset accuracy event callback for magnetometer rotation vector");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            X = sensorData.values[0];
-            Y = sensorData.values[1];
-            Z = sensorData.values[2];
-            Accuracy = sensorData.accuracy;
-
-            DataUpdated?.Invoke(this, new MagnetometerRotationVectorSensorDataUpdatedEventArgs(sensorData.values, sensorData.accuracy));
-        }
-
-        private void AccuracyEventCallback(IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data)
-        {
-            TimeSpan = new TimeSpan((Int64)timestamp);
-            Accuracy = accuracy;
-            _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/OrientationSensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/OrientationSensor.cs
index c619811c4cd33d4f5434ac7eae2f14a48aef6af8..348852309683910c419408f94407e1ff6150c6fa 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/OrientationSensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/OrientationSensor.cs
@@ -128,9 +128,22 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                Azimuth = sensorData.values[0];
+                Pitch = sensorData.values[1];
+                Roll = sensorData.values[2];
+
+                DataUpdated?.Invoke(this, new OrientationSensorDataUpdatedEventArgs(sensorData.values));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for orientation sensor");
@@ -148,9 +161,16 @@ namespace Tizen.Sensor
             }
         }
 
+        private static Interop.SensorListener.SensorAccuracyCallback _accuracyCallback;
+
         private void AccuracyListenStart()
         {
-            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, AccuracyEventCallback, IntPtr.Zero);
+            _accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
+                TimeSpan = new TimeSpan((Int64)timestamp);
+                _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+            };
+
+            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting accuracy event callback for orientation sensor");
@@ -167,22 +187,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset accuracy event callback for orientation");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            Azimuth = sensorData.values[0];
-            Pitch = sensorData.values[1];
-            Roll = sensorData.values[2];
-
-            DataUpdated?.Invoke(this, new OrientationSensorDataUpdatedEventArgs(sensorData.values));
-        }
-
-        private void AccuracyEventCallback(IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data)
-        {
-            TimeSpan = new TimeSpan((Int64)timestamp);
-            _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/Pedometer.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/Pedometer.cs
index 63ccd2a855835d330511a6884b393dc921743144..48bb1b08e2f8b9ed6031a24a7c8c67ad6d98e003 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/Pedometer.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/Pedometer.cs
@@ -133,9 +133,27 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                StepCount = (uint)sensorData.values[0];
+                WalkStepCount = (uint)sensorData.values[1];
+                RunStepCount = (uint)sensorData.values[2];
+                MovingDistance = sensorData.values[3];
+                CalorieBurned = sensorData.values[4];
+                LastSpeed = sensorData.values[5];
+                LastSteppingFrequency = sensorData.values[6];
+                LastStepStatus = (PedometerState)sensorData.values[7];
+
+                DataUpdated?.Invoke(this, new PedometerDataUpdatedEventArgs(sensorData.values));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for pedometer sensor");
@@ -152,21 +170,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for pedometer");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            StepCount = (uint)sensorData.values[0];
-            WalkStepCount = (uint)sensorData.values[1];
-            RunStepCount = (uint)sensorData.values[2];
-            MovingDistance = sensorData.values[3];
-            CalorieBurned = sensorData.values[4];
-            LastSpeed = sensorData.values[5];
-            LastSteppingFrequency = sensorData.values[6];
-            LastStepStatus = (PedometerState)sensorData.values[7];
-
-            DataUpdated?.Invoke(this, new PedometerDataUpdatedEventArgs(sensorData.values));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/PickUpGestureDetector.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/PickUpGestureDetector.cs
index ef8661c8665cbc74d90734802d201ef9f1174229..486d941c0a888a5c54208ae0a3b405c5beebbd7a 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/PickUpGestureDetector.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/PickUpGestureDetector.cs
@@ -105,9 +105,20 @@ namespace Tizen.Sensor
         /// </summary>
         public event EventHandler<PickUpGestureDetectorDataUpdatedEventArgs> DataUpdated;
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                PickUp = (DetectorState) sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new PickUpGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for pick up gesture detector");
@@ -124,14 +135,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for pick up gesture detector");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            PickUp = (DetectorState) sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new PickUpGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/PressureSensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/PressureSensor.cs
index ab4e4a74aad24e62de247d8f4f838d60b967a98f..58ebdb41dcbe0355c43c210ed4f4ad55b50601f3 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/PressureSensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/PressureSensor.cs
@@ -95,9 +95,20 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                Pressure = sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new PressureSensorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for pressure sensor");
@@ -114,14 +125,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for pressure");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            Pressure = sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new PressureSensorDataUpdatedEventArgs(sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/ProximitySensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/ProximitySensor.cs
index 413992e2757e03e2201a0af6ce64af05c8b72ee7..a91645b6f99ab662fd3c786ef0e0ea71e3ac4f89 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/ProximitySensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/ProximitySensor.cs
@@ -94,9 +94,20 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                Proximity = (ProximitySensorState) sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new ProximitySensorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for proximity sensor");
@@ -113,14 +124,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for proximity");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            Proximity = (ProximitySensorState) sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new ProximitySensorDataUpdatedEventArgs(sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/RotationVectorSensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/RotationVectorSensor.cs
index 797bbd0f31454e6ce84e5d92c5b98f442f882997..8d0f0f7e0e72d7aaf9d03e2dfa3e24812bed91b4 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/RotationVectorSensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/RotationVectorSensor.cs
@@ -138,9 +138,24 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                X = sensorData.values[0];
+                Y = sensorData.values[1];
+                Z = sensorData.values[2];
+                W = sensorData.values[3];
+                Accuracy = sensorData.accuracy;
+
+                DataUpdated?.Invoke(this, new RotationVectorSensorDataUpdatedEventArgs(sensorData.values, sensorData.accuracy));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for rotation vector sensor");
@@ -158,9 +173,17 @@ namespace Tizen.Sensor
             }
         }
 
+        private static Interop.SensorListener.SensorAccuracyCallback _accuracyCallback;
+
         private void AccuracyListenStart()
         {
-            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, AccuracyEventCallback, IntPtr.Zero);
+            _accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
+                TimeSpan = new TimeSpan((Int64)timestamp);
+                Accuracy = accuracy;
+                _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+            };
+
+            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting accuracy event callback for rotation vector sensor");
@@ -177,24 +200,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset accuracy event callback for rotation vector");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            X = sensorData.values[0];
-            Y = sensorData.values[1];
-            Z = sensorData.values[2];
-            Accuracy = sensorData.accuracy;
-
-            DataUpdated?.Invoke(this, new RotationVectorSensorDataUpdatedEventArgs(sensorData.values, sensorData.accuracy));
-        }
-
-        private void AccuracyEventCallback(IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data)
-        {
-            TimeSpan = new TimeSpan((Int64)timestamp);
-            Accuracy = accuracy;
-            _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/RunningActivityDetector.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/RunningActivityDetector.cs
index d23f1905b8d237a319610c97102d2d6329c2ba90..fc08d4180a4ded3b22082d569c4157902c1b35c5 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/RunningActivityDetector.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/RunningActivityDetector.cs
@@ -89,14 +89,36 @@ namespace Tizen.Sensor
         /// </summary>
         public event EventHandler<RunningActivityDetectorDataUpdatedEventArgs> DataUpdated;
 
-        internal override void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
+        internal override void EventListenStart()
         {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            Running = (DetectorState)sensorData.values[0];
-            ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                Running = (DetectorState)sensorData.values[0];
+                ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
+
+                DataUpdated?.Invoke(this, new RunningActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            if (error != (int)SensorError.None)
+            {
+                Log.Error(Globals.LogTag, "Error setting event callback for running activity detector");
+                throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set event callback for running activity detector");
+            }
+        }
 
-            DataUpdated?.Invoke(this, new RunningActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
+        internal override void EventListenStop()
+        {
+            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            if (error != (int)SensorError.None)
+            {
+                Log.Error(Globals.LogTag, "Error unsetting event callback for running activity detector");
+                throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for running activity detector");
+            }
         }
 
         internal override SensorType GetSensorType()

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/SleepMonitor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/SleepMonitor.cs
index 79ea10d2f39af2facba8013d92ad7698c6dabf7e..ed4b12c231848fa65cc01a10c59c3ea2627219e6 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/SleepMonitor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/SleepMonitor.cs
@@ -99,9 +99,20 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                SleepState = (SleepMonitorState)sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new SleepMonitorDataUpdatedEventArgs((int)sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for sleep monitor");
@@ -118,14 +129,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for sleep");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            SleepState = (SleepMonitorState)sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new SleepMonitorDataUpdatedEventArgs((int)sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/StationaryActivityDetector.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/StationaryActivityDetector.cs
index d2193d03aa7fc16311eb4ce25c295b817cb07037..2c42f136c6283e15976c42984070ae3ace01a07b 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/StationaryActivityDetector.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/StationaryActivityDetector.cs
@@ -89,14 +89,36 @@ namespace Tizen.Sensor
         /// </summary>
         public event EventHandler<StationaryActivityDetectorDataUpdatedEventArgs> DataUpdated;
 
-        internal override void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
+        internal static Interop.SensorListener.SensorEventCallback _callback;
+
+        internal override void EventListenStart()
         {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            Stationary = (DetectorState)sensorData.values[0];
-            ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                Stationary = (DetectorState)sensorData.values[0];
+                ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
+
+                DataUpdated?.Invoke(this, new StationaryActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            if (error != (int)SensorError.None)
+            {
+                Log.Error(Globals.LogTag, "Error setting event callback for stationary activity detector");
+                throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set event callback for stationary activity detector");
+            }
+        }
 
-            DataUpdated?.Invoke(this, new StationaryActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
+        internal override void EventListenStop()
+        {
+            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            if (error != (int)SensorError.None)
+            {
+                Log.Error(Globals.LogTag, "Error unsetting event callback for stationary activity detector");
+                throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for stationary activity detector");
+            }
         }
 
         internal override SensorType GetSensorType()

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/TemperatureSensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/TemperatureSensor.cs
index db54a9cb3c73d314bb4ec92c432bb942dc31dc44..6d3e8486112649f68027405bef2e6237a0534162 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/TemperatureSensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/TemperatureSensor.cs
@@ -95,9 +95,20 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                Temperature = sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new TemperatureSensorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for temperature sensor");
@@ -114,14 +125,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for temperature");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            Temperature = sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new TemperatureSensorDataUpdatedEventArgs(sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/UltravioletSensor.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/UltravioletSensor.cs
index ca66280a5c8dc5aeda29992f5e7bac31a35eac69..5ab32e4b74eca69c5554a3c36e0f91418e84b903 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/UltravioletSensor.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/UltravioletSensor.cs
@@ -95,9 +95,20 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                UltravioletIndex = sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new UltravioletSensorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for ultraviolet sensor");
@@ -114,14 +125,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for ultraviolet");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            UltravioletIndex = sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new UltravioletSensorDataUpdatedEventArgs(sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedGyroscope.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedGyroscope.cs
index c3f157e44e3772e1d65c78cdc2adbfd61cff88ea..ef10c794366337e3dbb28cdb43823f1b51e8da6a 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedGyroscope.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedGyroscope.cs
@@ -119,9 +119,25 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                X = sensorData.values[0];
+                Y = sensorData.values[1];
+                Z = sensorData.values[2];
+                BiasX = sensorData.values[3];
+                BiasY = sensorData.values[4];
+                BiasZ = sensorData.values[5];
+
+                DataUpdated?.Invoke(this, new UncalibratedGyroscopeDataUpdatedEventArgs(sensorData.values));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for uncalibrated gyroscope sensor");
@@ -138,19 +154,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for uncalibrated gyroscope");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            X = sensorData.values[0];
-            Y = sensorData.values[1];
-            Z = sensorData.values[2];
-            BiasX = sensorData.values[3];
-            BiasY = sensorData.values[4];
-            BiasZ = sensorData.values[5];
-
-            DataUpdated?.Invoke(this, new UncalibratedGyroscopeDataUpdatedEventArgs(sensorData.values));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedMagnetometer.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedMagnetometer.cs
index b17dbe81d9f000e07a37b49dff8709ed118ff6b8..350acaa7b860c167a32b245f5a333d2b50971e93 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedMagnetometer.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/UncalibratedMagnetometer.cs
@@ -143,9 +143,25 @@ namespace Tizen.Sensor
             return count;
         }
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                X = sensorData.values[0];
+                Y = sensorData.values[1];
+                Z = sensorData.values[2];
+                BiasX = sensorData.values[3];
+                BiasY = sensorData.values[4];
+                BiasZ = sensorData.values[5];
+
+                DataUpdated?.Invoke(this, new UncalibratedMagnetometerDataUpdatedEventArgs(sensorData.values));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for uncalibrated magnetometer sensor");
@@ -163,9 +179,16 @@ namespace Tizen.Sensor
             }
         }
 
+        private static Interop.SensorListener.SensorAccuracyCallback _accuracyCallback;
+
         private void AccuracyListenStart()
         {
-            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, AccuracyEventCallback, IntPtr.Zero);
+            _accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
+                TimeSpan = new TimeSpan((Int64)timestamp);
+                _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+            };
+
+            int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting accuracy event callback for uncalibrated magnetometer");
@@ -182,25 +205,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset accuracy event callback for uncalibrated magnetometer");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            X = sensorData.values[0];
-            Y = sensorData.values[1];
-            Z = sensorData.values[2];
-            BiasX = sensorData.values[3];
-            BiasY = sensorData.values[4];
-            BiasZ = sensorData.values[5];
-
-            DataUpdated?.Invoke(this, new UncalibratedMagnetometerDataUpdatedEventArgs(sensorData.values));
-        }
-
-        private void AccuracyEventCallback(IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data)
-        {
-            TimeSpan = new TimeSpan((Int64)timestamp);
-            _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/WalkingActivityDetector.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/WalkingActivityDetector.cs
index 8afd9b3c89d20c9ac13dc00199e1771c7f43dea5..391f3ae2a865ef64a3f6e062b388023a554549b0 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/WalkingActivityDetector.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/WalkingActivityDetector.cs
@@ -89,14 +89,36 @@ namespace Tizen.Sensor
         /// </summary>
         public event EventHandler<WalkingActivityDetectorDataUpdatedEventArgs> DataUpdated;
 
-        internal override void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
+        internal static Interop.SensorListener.SensorEventCallback _callback;
+
+        internal override void EventListenStart()
         {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            Walking = (DetectorState)sensorData.values[0];
-            ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                Walking = (DetectorState)sensorData.values[0];
+                ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
+
+                DataUpdated?.Invoke(this, new WalkingActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
+            if (error != (int)SensorError.None)
+            {
+                Log.Error(Globals.LogTag, "Error setting event callback for walking activity detector");
+                throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set event callback for walking activity detector");
+            }
+        }
 
-            DataUpdated?.Invoke(this, new WalkingActivityDetectorDataUpdatedEventArgs(sensorData.values[0]));
+        internal override void EventListenStop()
+        {
+            int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle);
+            if (error != (int)SensorError.None)
+            {
+                Log.Error(Globals.LogTag, "Error unsetting event callback for walking activity detector");
+                throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for walking activity detector");
+            }
         }
 
         internal override SensorType GetSensorType()

diff --git a/Tizen.Sensor/Tizen.Sensor/Plugins/WristUpGestureDetector.cs b/Tizen.Sensor/Tizen.Sensor/Plugins/WristUpGestureDetector.cs
index bcc7cfc20c4476d2b53a52314d4555ee06a98291..f182c81e6f20354ac852b0a8422a8daad000dc3f 100644 (file)
--- a/Tizen.Sensor/Tizen.Sensor/Plugins/WristUpGestureDetector.cs
+++ b/Tizen.Sensor/Tizen.Sensor/Plugins/WristUpGestureDetector.cs
@@ -93,9 +93,20 @@ namespace Tizen.Sensor
         /// </summary>
         public event EventHandler<WristUpGestureDetectorDataUpdatedEventArgs> DataUpdated;
 
+        private static Interop.SensorListener.SensorEventCallback _callback;
+
         internal override void EventListenStart()
         {
-            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, SensorEventCallback, IntPtr.Zero);
+            _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => {
+                Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr);
+
+                TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+                WristUp = (DetectorState) sensorData.values[0];
+
+                DataUpdated?.Invoke(this, new WristUpGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
+            };
+
+            int error = Interop.SensorListener.SetEventCallback(ListenerHandle, Interval, _callback, IntPtr.Zero);
             if (error != (int)SensorError.None)
             {
                 Log.Error(Globals.LogTag, "Error setting event callback for wrist up gesture detector");
@@ -112,14 +123,5 @@ namespace Tizen.Sensor
                 throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for wrist up gesture detector");
             }
         }
-
-        private void SensorEventCallback(IntPtr sensorHandle, IntPtr sensorPtr, IntPtr data)
-        {
-            Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(sensorPtr);
-            TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
-            WristUp = (DetectorState) sensorData.values[0];
-
-            DataUpdated?.Invoke(this, new WristUpGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
-        }
     }
 }

diff --git a/Tizen.Sensor/Tizen.Sensor/Sensor.cs b/Tizen.Sensor/Tizen.Sensor/Sensor.cs
old mode 100755 (executable)
new mode 100644 (file)