[DllImport(Libraries.Sensor, EntryPoint = "sensor_listener_read_data")]
internal static extern int ReadData(IntPtr listenerHandle, out SensorEventStruct data);
+
+ [DllImport(Libraries.Sensor, EntryPoint = "sensor_listener_read_data_list")]
+ internal static extern int ReadDataList(IntPtr listenerHandle, out IntPtr eventsData, out uint events_count);
}
internal static class SensorManager
--- /dev/null
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tizen.Sensor
+{
+ /// <summary>
+ /// The BatchData class is used for storing value of particular batch type sensor.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public abstract class BatchData
+ {
+ /// <summary>
+ /// Initializes a new instance of the BatchData class.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <param name="timestamp">Timestamp of sensor event.</param>
+ /// <param name="accuracy">Sensor accuracy of sensor event.</param>
+ public BatchData(ulong timestamp, SensorDataAccuracy accuracy)
+ {
+ Timestamp = timestamp;
+ Accuracy = accuracy;
+ }
+
+ /// <summary>
+ /// Timestamp as ticks that data was created
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> Timestamp </value>
+ public ulong Timestamp
+ {
+ get; private set;
+ }
+
+ /// <summary>
+ /// Accuracy of the HeartRateMonitorBatch data.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> Accuracy </value>
+ public SensorDataAccuracy Accuracy { get; private set; } = SensorDataAccuracy.Undefined;
+ }
+}
--- /dev/null
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tizen.Sensor
+{
+ /// <summary>
+ /// The HeartRateMonitorBatchData class is used for storing value of HeartRateMonitorBatch sensor.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public class HeartRateMonitorBatchData : BatchData
+ {
+ /// <summary>
+ /// Initializes a new instance of the HeartRateMonitorBatchData class.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <param name="timestamp">Timestamp of HeartRateMonitorBatch sensor event.</param>
+ /// <param name="accuracy">Sensor accuracy of HeartRateMonitorBatch sensor event.</param>
+ /// <param name="state">Value indicating the status of the HeartRateMonitorBatch sensor.</param>
+ /// <param name="heartRate">heartRate of HeartRateMonitorBatch sensor event.</param>
+ /// <param name="rri">rri of HeartRateMonitorBatch sensor event.</param>
+ public HeartRateMonitorBatchData(ulong timestamp, SensorDataAccuracy accuracy, HeartRateMonitorBatchState state, int heartRate, int rri) : base(timestamp, accuracy)
+ {
+ State = state;
+ HeartRate = heartRate;
+ RRInterval = rri;
+ }
+
+ /// <summary>
+ /// Gets the value of the HeartRateMonitorBatch state.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> State </value>
+ public HeartRateMonitorBatchState State { get; }
+
+ /// <summary>
+ /// Heart rate in beats per minute
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> HeartRate </value>
+ public int HeartRate { get; }
+
+ /// <summary>
+ /// Gets the value R wave-to-R wave interval(RRI) from ECG sensor(Unit is millisecond).
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> RRInterval </value>
+ public int RRInterval { get; }
+
+ }
+}
--- /dev/null
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tizen.Sensor
+{
+ /// <summary>
+ /// The HeartRateMonitorLEDGreenBatchData class is used for storing value of HeartRateMonitorLEDGreenBatch sensor.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public class HeartRateMonitorLEDGreenBatchData : BatchData
+ {
+ /// <summary>
+ /// Initializes a new instance of the HeartRateMonitorLEDGreenBatchData class.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <param name="timestamp">Timestamp of sensor event.</param>
+ /// <param name="accuracy">Sensor accuracy of sensor event.</param>
+ /// <param name="green">Green LED ADC value of sensor event</param>
+ /// <param name="accelerationX">X axis's value of gravitational acceleration of sensor event.</param>
+ /// <param name="accelerationY">Y axis's value of gravitational acceleration of sensor event.</param>
+ /// <param name="accelerationZ">Z axis's value of gravitational acceleration of sensor event.</param>
+ /// <param name="index">Sequential index of sensor event.</param>
+ public HeartRateMonitorLEDGreenBatchData(ulong timestamp, SensorDataAccuracy accuracy, uint green, int accelerationX, int accelerationY, int accelerationZ, uint index) : base(timestamp, accuracy)
+ {
+ Green = green;
+ AccelerationX = accelerationX;
+ AccelerationY = accelerationY;
+ AccelerationY = accelerationZ;
+ Index = index;
+ }
+
+ /// <summary>
+ /// Gets the value of the Green LED ADC Value. (0 ~ 4194304)
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> Green </value>
+ public uint Green { get; }
+
+ /// <summary>
+ /// Gets the X axis's uncalibrated value of the gravitational acceleration. (-4096 ~ 4096)
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> AccelerationX </value>
+ public int AccelerationX { get; }
+
+ /// <summary>
+ /// Gets the Y axis's uncalibrated value of the gravitational acceleration. (-4096 ~ 4096)
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> AccelerationY </value>
+ public int AccelerationY { get; }
+
+
+ /// <summary>
+ /// Gets the Z axis's uncalibrated value of the gravitational acceleration. (-4096 ~ 4096)
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> AccelerationZ </value>
+ public int AccelerationZ { get; }
+
+
+ /// <summary>
+ /// Gets the index value between 0 and 299 used for deburring purposes
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> Index </value>
+ public uint Index { get; }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace Tizen.Sensor
+{
+ public abstract class BatchSensor<TData> : Sensor where TData : Tizen.Sensor.BatchData
+ {
+ public BatchSensor(uint index = 0) : base(index) { }
+ public IReadOnlyList<TData> Data { get; protected set; }
+
+ /// <summary>
+ /// Convert general batch data to specific batch data
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <returns> List of converted specific batch data </returns>
+ protected abstract IReadOnlyList<TData> ConvertBatchData();
+
+ /// <summary>
+ /// Update the internal batch data using the latest events
+ /// </summary>
+ /// <param name="eventsPtr">
+ /// General batch data's raw pointer
+ /// </param>
+ /// <param name="eventsCount">
+ /// Number of general batch events
+ /// </param>
+ protected void UpdateBatchData(IntPtr eventsPtr, uint eventsCount)
+ {
+ updateBatchEvents(eventsPtr, eventsCount);
+ Data = ConvertBatchData();
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace Tizen.Sensor
+{
+ /// <summary>
+ /// The HeartRateMonitorBatch changed event arguments class is used for storing the data returned by the HeartRateMonitorBatch sensor.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public class HeartRateMonitorBatchDataUpdatedEventArgs : EventArgs
+ {
+ internal HeartRateMonitorBatchDataUpdatedEventArgs(IReadOnlyList<HeartRateMonitorBatchData> batchedData)
+ {
+ Data = batchedData;
+ }
+ /// <summary>
+ /// Gets the series value of the HeartRateMonitorBatch.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> HeartRateMonitorBatchData. </value>
+ public IReadOnlyList<HeartRateMonitorBatchData> Data { get; }
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace Tizen.Sensor
+{
+ /// <summary>
+ /// The HeartRateMonitorLEDGreenBatch changed event arguments class is used for storing the data returned by the HeartRateMonitorLEDGreenBatch sensor
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public class HeartRateMonitorLEDGreenBatchDataUpdatedEventArgs : EventArgs
+ {
+ internal HeartRateMonitorLEDGreenBatchDataUpdatedEventArgs(IReadOnlyList<HeartRateMonitorLEDGreenBatchData> batchedDataList)
+ {
+ Data = batchedDataList;
+ }
+ /// <summary>
+ /// Gets the series value of the HeartRateMonitorLEDGreenBatch.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> HeartRateMonitorLEDGreenBatchData. </value>
+ public IReadOnlyList<HeartRateMonitorLEDGreenBatchData> Data { get; }
+ }
+}
\ No newline at end of file
{
internal SensorAccuracyChangedEventArgs(TimeSpan timespan, SensorDataAccuracy accuracy)
{
- TimeSpan = timespan;
+ Accuracy = accuracy;
+ Timestamp = (ulong)timespan.Ticks;
+ }
+
+ internal SensorAccuracyChangedEventArgs(ulong timestamp, SensorDataAccuracy accuracy)
+ {
+ Timestamp = timestamp;
Accuracy = accuracy;
}
/// </summary>
/// <since_tizen> 3 </since_tizen>
/// <value> The time span. </value>
- public TimeSpan TimeSpan { get; private set; }
+ public TimeSpan TimeSpan
+ {
+ get
+ {
+ return new TimeSpan((Int64)Timestamp);
+ }
+ }
+
+ /// <summary>
+ /// Gets the time stamp.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> Timestamp </value>
+ public ulong Timestamp { get; private set; }
/// <summary>
/// Gets the accuracy.
throw SensorErrorFactory.CheckAndThrowException(error, "Reading accelerometer data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
_callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
throw SensorErrorFactory.CheckAndThrowException(error, "Reading auto rotation data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
if (sensorData.values[0] == 0) {
Rotation = AutoRotationState.Degree_0;
} else {
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
if (sensorData.values[0] == 0) {
Rotation = AutoRotationState.Degree_0;
} else {
private void AccuracyListenStart()
{
_accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
- TimeSpan = new TimeSpan((Int64)timestamp);
+ Timestamp = timestamp;
Accuracy = accuracy;
- _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+ _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(timestamp, accuracy));
};
int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
throw SensorErrorFactory.CheckAndThrowException(error, "Reading face down gesture detector data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
FaceDown = (DetectorState)sensorData.values[0];
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
FaceDown = (DetectorState) sensorData.values[0];
DataUpdated?.Invoke(this, new FaceDownGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
throw SensorErrorFactory.CheckAndThrowException(error, "Reading gravity sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
private void AccuracyListenStart()
{
_accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
- TimeSpan = new TimeSpan((Int64)timestamp);
- _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+ Timestamp = timestamp;
+ _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(timestamp, accuracy));
};
int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
throw SensorErrorFactory.CheckAndThrowException(error, "Reading gyroscope data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
throw SensorErrorFactory.CheckAndThrowException(error, "Reading gyroscope rotation vector sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
throw SensorErrorFactory.CheckAndThrowException(error, "Reading heart rate monitor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
HeartRate = (int)sensorData.values[0];
}
internal override void EventListenStart()
{
- _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+ _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) =>
+ {
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
HeartRate = (int)sensorData.values[0];
DataUpdated?.Invoke(this, new HeartRateMonitorDataUpdatedEventArgs((int)sensorData.values[0]));
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+namespace Tizen.Sensor
+{
+ /// <summary>
+ /// The HeartRateMonitorBatch class is used for registering callbacks for the heart rate monitor batch and getting the heart rate batch data.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public sealed class HeartRateMonitorBatch : BatchSensor<HeartRateMonitorBatchData>
+ {
+ private static string HRMBatchKey = "http://tizen.org/feature/sensor.heart_rate_monitor.batch";
+
+ private event EventHandler<SensorAccuracyChangedEventArgs> _accuracyChanged;
+
+ protected override IReadOnlyList<HeartRateMonitorBatchData> ConvertBatchData()
+ {
+ List<HeartRateMonitorBatchData> list = new List<HeartRateMonitorBatchData>();
+ Interop.SensorEventStruct sensorData;
+ for (int i = 0; i < BatchedEvents.Count; i++)
+ {
+ sensorData = BatchedEvents[i];
+ list.Add(new HeartRateMonitorBatchData(sensorData.timestamp, sensorData.accuracy, (HeartRateMonitorBatchState)sensorData.values[0], (int)sensorData.values[1], (int)sensorData.values[2]));
+ }
+ return list.AsReadOnly();
+ }
+
+ /// <summary>
+ /// Gets the accuracy of the HeartRateMonitorBatch data.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> Accuracy </value>
+ public SensorDataAccuracy Accuracy { get; private set; } = SensorDataAccuracy.Undefined;
+
+ /// <summary>
+ /// Returns true or false based on whether the HeartRateMonitorBatch sensor is supported by the device.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value><c>true</c> if supported; otherwise <c>false</c>.</value>
+ public static bool IsSupported
+ {
+ get
+ {
+ Log.Info(Globals.LogTag, "Checking if the HeartRateMonitorBatch is supported");
+ return CheckIfSupported(SensorType.HRMBatch, HRMBatchKey);
+ }
+ }
+
+ /// <summary>
+ /// Returns the number of HeartRateMonitorBatch sensors available on the device.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> The count of HeartRateMonitorBatch sensors. </value>
+ /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
+ public static int Count
+ {
+ get
+ {
+ Log.Info(Globals.LogTag, "Getting the count of accelerometer sensors");
+ return GetCount();
+ }
+ }
+
+ /// <summary>
+ /// Initializes a new instance of the <see cref="Tizen.Sensor.HeartRateMonitorBatch"/> class.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <privilege>http://tizen.org/privilege/healthinfo</privilege>
+ /// <privlevel>public</privlevel>
+ /// <feature>http://tizen.org/feature/sensor.heart_rate_monitor.batch</feature>
+ /// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
+ /// <exception cref="NotSupportedException">Thrown when the sensor is not supported.</exception>
+ /// <exception cref="UnauthorizedAccessException">Thrown when the application has no privilege to use the sensor.</exception>
+ /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
+ /// <param name='index'>
+ /// Index. Default value for this is 0. Index refers to a particular HeartRateMonitorBatch in case of multiple sensors.
+ /// </param>
+ public HeartRateMonitorBatch(uint index = 0) : base(index)
+ {
+ Log.Info(Globals.LogTag, "Creating HeartRateMonitorBatch object");
+ }
+
+ internal override SensorType GetSensorType()
+ {
+ return SensorType.HRMBatch;
+ }
+
+ /// <summary>
+ /// An event handler for storing the callback functions for the event corresponding to the change in the HeartRateMonitorBatch data.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+
+ public event EventHandler<HeartRateMonitorBatchDataUpdatedEventArgs> DataUpdated;
+
+ /// <summary>
+ /// An event handler for accuracy changed events.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public event EventHandler<SensorAccuracyChangedEventArgs> AccuracyChanged
+ {
+ add
+ {
+ if (_accuracyChanged == null)
+ {
+ AccuracyListenStart();
+ }
+ _accuracyChanged += value;
+ }
+ remove
+ {
+ _accuracyChanged -= value;
+ if (_accuracyChanged == null)
+ {
+ AccuracyListenStop();
+ }
+ }
+ }
+
+ private static int GetCount()
+ {
+ IntPtr list;
+ int count;
+ int error = Interop.SensorManager.GetSensorList(SensorType.HRMBatch, out list, out count);
+ if (error != (int)SensorError.None)
+ {
+ Log.Error(Globals.LogTag, "Error getting sensor list for HeartRateMonitorBatch");
+ count = 0;
+ }
+ else
+ Interop.Libc.Free(list);
+ return count;
+ }
+
+ /// <summary>
+ /// Read HeartRateMonitorBatch data synchronously.
+ /// </summary>
+ internal override void ReadData()
+ {
+ int error = Interop.SensorListener.ReadDataList(ListenerHandle, out IntPtr eventsPtr, out uint events_count);
+ if (error != (int)SensorError.None)
+ {
+ Log.Error(Globals.LogTag, "Error reading HeartRateMonitorBatch data");
+ throw SensorErrorFactory.CheckAndThrowException(error, "Reading HeartRateMonitorBatch data failed");
+ }
+ UpdateBatchData(eventsPtr, events_count);
+ Interop.SensorEventStruct sensorData = latestEvent();
+ Timestamp = (ulong)DateTimeOffset.Now.ToUnixTimeMilliseconds();
+ Accuracy = sensorData.accuracy;
+ Interop.Libc.Free(eventsPtr);
+ }
+
+ private static Interop.SensorListener.SensorEventsCallback _callback;
+
+ internal override void EventListenStart()
+ {
+ _callback = (IntPtr sensorHandle, IntPtr eventsPtr, uint events_count, IntPtr data) =>
+ {
+ UpdateBatchData(eventsPtr, events_count);
+ Interop.SensorEventStruct sensorData = latestEvent();
+ Timestamp = (ulong)DateTimeOffset.Now.ToUnixTimeMilliseconds();
+ Accuracy = sensorData.accuracy;
+ DataUpdated?.Invoke(this, new HeartRateMonitorBatchDataUpdatedEventArgs((IReadOnlyList<HeartRateMonitorBatchData>)Data));
+ };
+ int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
+ if (error != (int)SensorError.None)
+ {
+ Log.Error(Globals.LogTag, "Error setting event callback for HeartRateMonitorBatch sensor");
+ throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set event callback for HeartRateMonitorBatch");
+ }
+ }
+
+ internal override void EventListenStop()
+ {
+ int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
+ if (error != (int)SensorError.None)
+ {
+ Log.Error(Globals.LogTag, "Error unsetting event callback for HeartRateMonitorBatch sensor");
+ throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for HeartRateMonitorBatch");
+ }
+ }
+
+ private static Interop.SensorListener.SensorAccuracyCallback _accuracyCallback;
+
+ private void AccuracyListenStart()
+ {
+ _accuracyCallback = (IntPtr sensorHandle, ulong timestamp, SensorDataAccuracy accuracy, IntPtr data) =>
+ {
+ Timestamp = timestamp;
+ Accuracy = accuracy;
+ _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(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 HeartRateMonitorBatch sensor");
+ throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set accuracy event callback for HeartRateMonitorBatch");
+ }
+ }
+
+ private void AccuracyListenStop()
+ {
+ int error = Interop.SensorListener.UnsetAccuracyCallback(ListenerHandle);
+ if (error != (int)SensorError.None)
+ {
+ Log.Error(Globals.LogTag, "Error unsetting accuracy event callback for HeartRateMonitorBatch sensor");
+ throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset accuracy event callback for auto rotation");
+ }
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+namespace Tizen.Sensor
+{
+ /// <summary>
+ /// The HeartRateMonitorLEDGreenBatch class is used for registering callbacks for the HRMLEDGreen batch and getting the HRMLEDGreen batch data.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public sealed class HeartRateMonitorLEDGreenBatch : BatchSensor<HeartRateMonitorLEDGreenBatchData>
+ {
+ private static string HRMLEDGreenBatchKey = "http://tizen.org/feature/sensor.heart_rate_monitor.led_green.batch";
+
+ private event EventHandler<SensorAccuracyChangedEventArgs> _accuracyChanged;
+
+ protected override IReadOnlyList<HeartRateMonitorLEDGreenBatchData> ConvertBatchData()
+ {
+ List<HeartRateMonitorLEDGreenBatchData> list = new List<HeartRateMonitorLEDGreenBatchData>();
+ Interop.SensorEventStruct sensorData;
+ for (int i = 0; i < BatchedEvents.Count; i++)
+ {
+ sensorData = BatchedEvents[i];
+ list.Add(new HeartRateMonitorLEDGreenBatchData(sensorData.timestamp, sensorData.accuracy, (uint)sensorData.values[0], (int)sensorData.values[1], (int)sensorData.values[2], (int)sensorData.values[3], (uint)sensorData.values[4]));
+ }
+ return list.AsReadOnly(); ;
+ }
+
+ /// <summary>
+ /// Gets the accuracy of the auto HeartRateMonitorLEDGreenBatch data.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> Accuracy </value>
+ public SensorDataAccuracy Accuracy { get; private set; } = SensorDataAccuracy.Undefined;
+
+ /// <summary>
+ /// Returns true or false based on whether the HeartRateMonitorLEDGreenBatch sensor is supported by the device.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value><c>true</c> if supported; otherwise <c>false</c>.</value>
+ public static bool IsSupported
+ {
+ get
+ {
+ Log.Info(Globals.LogTag, "Checking if the HeartRateMonitorLEDGreenBatch is supported");
+ return CheckIfSupported(SensorType.HRMLEDGreenBatch, HRMLEDGreenBatchKey);
+ }
+ }
+
+ /// <summary>
+ /// Returns the number of HeartRateMonitorLEDGreenBatch sensors available on the device.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> The count of HeartRateMonitorLEDGreenBatch sensors. </value>
+ /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
+ public static int Count
+ {
+ get
+ {
+ Log.Info(Globals.LogTag, "Getting the count of accelerometer sensors");
+ return GetCount();
+ }
+ }
+
+ /// <summary>
+ /// Initializes a new instance of the <see cref="Tizen.Sensor.HeartRateMonitorLEDGreenBatch"/> class.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <privilege>http://tizen.org/privilege/healthinfo</privilege>
+ /// <privlevel>public</privlevel>
+ /// <feature>http://tizen.org/feature/sensor.heart_rate_monitor.led_green.batch</feature>
+ /// <exception cref="ArgumentException">Thrown when an invalid argument is used.</exception>
+ /// <exception cref="NotSupportedException">Thrown when the sensor is not supported.</exception>
+ /// <exception cref="UnauthorizedAccessException">Thrown when the application has no privilege to use the sensor.</exception>
+ /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state.</exception>
+ /// <param name='index'>
+ /// Index. Default value for this is 0. Index refers to a particular HeartRateMonitorLEDGreenBatch sensor in case of multiple sensors.
+ /// </param>
+ public HeartRateMonitorLEDGreenBatch(uint index = 0) : base(index)
+ {
+ Log.Info(Globals.LogTag, "Creating HeartRateMonitorLEDGreenBatch object");
+ }
+
+ internal override SensorType GetSensorType()
+ {
+ return SensorType.HRMLEDGreenBatch;
+ }
+
+ /// <summary>
+ /// An event handler for storing the callback functions for the event corresponding to the change in the HeartRateMonitorLEDGreenBatch sensor data.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+
+ public event EventHandler<HeartRateMonitorLEDGreenBatchDataUpdatedEventArgs> DataUpdated;
+
+ /// <summary>
+ /// An event handler for accuracy changed events.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public event EventHandler<SensorAccuracyChangedEventArgs> AccuracyChanged
+ {
+ add
+ {
+ if (_accuracyChanged == null)
+ {
+ AccuracyListenStart();
+ }
+ _accuracyChanged += value;
+ }
+ remove
+ {
+ _accuracyChanged -= value;
+ if (_accuracyChanged == null)
+ {
+ AccuracyListenStop();
+ }
+ }
+ }
+
+ private static int GetCount()
+ {
+ IntPtr list;
+ int count;
+ int error = Interop.SensorManager.GetSensorList(SensorType.HRMLEDGreenBatch, out list, out count);
+ if (error != (int)SensorError.None)
+ {
+ Log.Error(Globals.LogTag, "Error getting sensor list for HeartRateMonitorLEDGreenBatch");
+ count = 0;
+ }
+ else
+ Interop.Libc.Free(list);
+ return count;
+ }
+
+ /// <summary>
+ /// Read HeartRateMonitorLEDGreenBatch data synchronously.
+ /// </summary>
+ internal override void ReadData()
+ {
+ int error = Interop.SensorListener.ReadDataList(ListenerHandle, out IntPtr eventsPtr, out uint events_count);
+ if (error != (int)SensorError.None)
+ {
+ Log.Error(Globals.LogTag, "Error reading HeartRateMonitorLEDGreenBatch data");
+ throw SensorErrorFactory.CheckAndThrowException(error, "Reading HeartRateMonitorBatch data failed");
+ }
+ UpdateBatchData(eventsPtr, events_count);
+ Interop.SensorEventStruct sensorData = latestEvent();
+ Timestamp = sensorData.timestamp;
+ Accuracy = sensorData.accuracy;
+ Interop.Libc.Free(eventsPtr);
+ }
+
+ private static Interop.SensorListener.SensorEventsCallback _callback;
+
+ internal override void EventListenStart()
+ {
+ _callback = (IntPtr sensorHandle, IntPtr eventsPtr, uint events_count, IntPtr data) =>
+ {
+ UpdateBatchData(eventsPtr, events_count);
+ Interop.SensorEventStruct sensorData = latestEvent();
+ Timestamp = (ulong)DateTimeOffset.Now.ToUnixTimeMilliseconds();
+ Accuracy = sensorData.accuracy;
+ DataUpdated?.Invoke(this, new HeartRateMonitorLEDGreenBatchDataUpdatedEventArgs((IReadOnlyList<HeartRateMonitorLEDGreenBatchData>)Data));
+
+ };
+
+ int error = Interop.SensorListener.SetEventsCallback(ListenerHandle, _callback, IntPtr.Zero);
+ if (error != (int)SensorError.None)
+ {
+ Log.Error(Globals.LogTag, "Error setting event callback for HeartRateMonitorLEDGreenBatch sensor");
+ throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set event callback for HeartRateMonitorLEDGreenBatch");
+ }
+ }
+
+ internal override void EventListenStop()
+ {
+ int error = Interop.SensorListener.UnsetEventsCallback(ListenerHandle);
+ if (error != (int)SensorError.None)
+ {
+ Log.Error(Globals.LogTag, "Error unsetting event callback for HeartRateMonitorLEDGreenBatch sensor");
+ throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for HeartRateMonitorLEDGreenBatch");
+ }
+ }
+
+ private static Interop.SensorListener.SensorAccuracyCallback _accuracyCallback;
+
+ private void AccuracyListenStart()
+ {
+ _accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) =>
+ {
+ Timestamp = timestamp;
+ Accuracy = accuracy;
+ _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(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 HeartRateMonitorLEDGreenBatch sensor");
+ throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set accuracy event callback for HeartRateMonitorLEDGreenBatch");
+ }
+ }
+
+ private void AccuracyListenStop()
+ {
+ int error = Interop.SensorListener.UnsetAccuracyCallback(ListenerHandle);
+ if (error != (int)SensorError.None)
+ {
+ Log.Error(Globals.LogTag, "Error unsetting accuracy event callback for HeartRateMonitorLEDGreenBatch sensor");
+ throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset accuracy event callback for HeartRateMonitorLEDGreenBatch");
+ }
+ }
+ }
+}
throw SensorErrorFactory.CheckAndThrowException(error, "Reading humidity sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Humidity = sensorData.values[0];
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Humidity = sensorData.values[0];
DataUpdated?.Invoke(this, new HumiditySensorDataUpdatedEventArgs(sensorData.values[0]));
throw SensorErrorFactory.CheckAndThrowException(error, "Reading in-vehicle activity detector data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
InVehicle = (DetectorState)sensorData.values[0];
ActivityAccuracy = (SensorDataAccuracy)sensorData.accuracy;
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
InVehicle = (DetectorState)sensorData.values[0];
ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
throw SensorErrorFactory.CheckAndThrowException(error, "Reading light sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Level = sensorData.values[0];
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Level = sensorData.values[0];
DataUpdated?.Invoke(this, new LightSensorDataUpdatedEventArgs(sensorData.values[0]));
throw SensorErrorFactory.CheckAndThrowException(error, "Reading linear acceleration sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
internal override void EventListenStart()
{
- _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) => {
+ _callback = (IntPtr sensorHandle, IntPtr eventPtr, uint events_count, IntPtr data) =>
+ {
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
private void AccuracyListenStart()
{
- _accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
- TimeSpan = new TimeSpan((Int64)timestamp);
- _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+ _accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) =>
+ {
+ Timestamp = timestamp;
+ _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(timestamp, accuracy));
};
int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
throw SensorErrorFactory.CheckAndThrowException(error, "Reading magnetometer data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
private void AccuracyListenStart()
{
_accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
- TimeSpan = new TimeSpan((Int64)timestamp);
- _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+ Timestamp = timestamp;
+ _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(timestamp, accuracy));
};
int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
throw SensorErrorFactory.CheckAndThrowException(error, "Reading magnetometer rotation vector sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
private void AccuracyListenStart()
{
_accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
- TimeSpan = new TimeSpan((Int64)timestamp);
+ Timestamp = timestamp;
Accuracy = accuracy;
- _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+ _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(timestamp, accuracy));
};
int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
throw SensorErrorFactory.CheckAndThrowException(error, "Reading orientation sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Azimuth = sensorData.values[0];
Pitch = sensorData.values[1];
Roll = sensorData.values[2];
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Azimuth = sensorData.values[0];
Pitch = sensorData.values[1];
Roll = sensorData.values[2];
private void AccuracyListenStart()
{
_accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
- TimeSpan = new TimeSpan((Int64)timestamp);
- _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+ Timestamp = timestamp;
+ _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(timestamp, accuracy));
};
int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
StepCount = (uint)sensorData.values[0];
WalkStepCount = (uint)sensorData.values[1];
RunStepCount = (uint)sensorData.values[2];
throw SensorErrorFactory.CheckAndThrowException(error, "Reading pick up gesture detector data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
PickUp = (DetectorState)sensorData.values[0];
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
PickUp = (DetectorState) sensorData.values[0];
DataUpdated?.Invoke(this, new PickUpGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
throw SensorErrorFactory.CheckAndThrowException(error, "Reading pressure sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Pressure = sensorData.values[0];
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Pressure = sensorData.values[0];
DataUpdated?.Invoke(this, new PressureSensorDataUpdatedEventArgs(sensorData.values[0]));
throw SensorErrorFactory.CheckAndThrowException(error, "Reading proximity sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Proximity = (ProximitySensorState)sensorData.values[0];
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Proximity = (ProximitySensorState) sensorData.values[0];
DataUpdated?.Invoke(this, new ProximitySensorDataUpdatedEventArgs(sensorData.values[0]));
throw SensorErrorFactory.CheckAndThrowException(error, "Reading rotation vector sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
private void AccuracyListenStart()
{
_accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
- TimeSpan = new TimeSpan((Int64)timestamp);
+ Timestamp = timestamp;
Accuracy = accuracy;
- _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+ _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(timestamp, accuracy));
};
int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
throw SensorErrorFactory.CheckAndThrowException(error, "Reading running activity detector data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Running = (DetectorState)sensorData.values[0];
ActivityAccuracy = (SensorDataAccuracy)sensorData.accuracy;
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Running = (DetectorState)sensorData.values[0];
ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
throw SensorErrorFactory.CheckAndThrowException(error, "Reading sleep monitor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
SleepState = (SleepMonitorState)sensorData.values[0];
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
SleepState = (SleepMonitorState)sensorData.values[0];
DataUpdated?.Invoke(this, new SleepMonitorDataUpdatedEventArgs((int)sensorData.values[0]));
throw SensorErrorFactory.CheckAndThrowException(error, "Reading stationary activity detector data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Stationary = (DetectorState)sensorData.values[0];
ActivityAccuracy = (SensorDataAccuracy)sensorData.accuracy;
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Stationary = (DetectorState)sensorData.values[0];
ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
throw SensorErrorFactory.CheckAndThrowException(error, "Reading temperature sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Temperature = sensorData.values[0];
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Temperature = sensorData.values[0];
DataUpdated?.Invoke(this, new TemperatureSensorDataUpdatedEventArgs(sensorData.values[0]));
throw SensorErrorFactory.CheckAndThrowException(error, "Reading ultraviolet sensor data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
UltravioletIndex = sensorData.values[0];
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
UltravioletIndex = sensorData.values[0];
DataUpdated?.Invoke(this, new UltravioletSensorDataUpdatedEventArgs(sensorData.values[0]));
throw SensorErrorFactory.CheckAndThrowException(error, "Reading uncalibrated gyroscope data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
throw SensorErrorFactory.CheckAndThrowException(error, "Reading uncalibrated magnetometer data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
X = sensorData.values[0];
Y = sensorData.values[1];
Z = sensorData.values[2];
private void AccuracyListenStart()
{
_accuracyCallback = (IntPtr sensorHandle, UInt64 timestamp, SensorDataAccuracy accuracy, IntPtr data) => {
- TimeSpan = new TimeSpan((Int64)timestamp);
- _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(new TimeSpan((Int64)timestamp), accuracy));
+ Timestamp = timestamp;
+ _accuracyChanged?.Invoke(this, new SensorAccuracyChangedEventArgs(timestamp, accuracy));
};
int error = Interop.SensorListener.SetAccuracyCallback(ListenerHandle, _accuracyCallback, IntPtr.Zero);
throw SensorErrorFactory.CheckAndThrowException(error, "Reading walking activity detector data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Walking = (DetectorState)sensorData.values[0];
ActivityAccuracy = (SensorDataAccuracy)sensorData.accuracy;
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
Walking = (DetectorState)sensorData.values[0];
ActivityAccuracy = (SensorDataAccuracy) sensorData.accuracy;
throw SensorErrorFactory.CheckAndThrowException(error, "Reading wrist up gesture detector data failed");
}
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
WristUp = (DetectorState)sensorData.values[0];
}
updateBatchEvents(eventPtr, events_count);
Interop.SensorEventStruct sensorData = latestEvent();
- TimeSpan = new TimeSpan((Int64)sensorData.timestamp);
+ Timestamp = sensorData.timestamp;
WristUp = (DetectorState) sensorData.values[0];
DataUpdated?.Invoke(this, new WristUpGestureDetectorDataUpdatedEventArgs(sensorData.values[0]));
private int _maxBatchCount;
private bool _isSensing = false;
private bool _disposed = false;
- private TimeSpan _timeSpan;
+ private ulong _timestamp;
private uint _interval = 0;
private uint _maxBatchLatency = 0;
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>();
+ internal IList<Interop.SensorEventStruct> BatchedEvents { get; set; } = new List<Interop.SensorEventStruct>();
/// <summary>
{
if (events_count >= 1)
{
- batchedEvents.Clear();
+ BatchedEvents.Clear();
IntPtr currentPtr = eventsPtr;
for (int i = 0; i < events_count; i++)
{
- batchedEvents.Add(Interop.IntPtrToEventStruct(currentPtr));
+ BatchedEvents.Add(Interop.IntPtrToEventStruct(currentPtr));
currentPtr += Marshal.SizeOf<Interop.SensorEventStruct>();
}
}
internal Interop.SensorEventStruct latestEvent()
{
- if (batchedEvents.Count > 0)
+ if (BatchedEvents.Count > 0)
{
- return batchedEvents[batchedEvents.Count-1];
+ return BatchedEvents[BatchedEvents.Count - 1];
}
return default(Interop.SensorEventStruct);
}
set
{
Log.Info(Globals.LogTag, "Setting the timespan of the sensor values");
- _timeSpan = value;
+ _timestamp = (ulong)value.Ticks;
}
get
{
Log.Info(Globals.LogTag, "Getting the timespan of the sensor values");
- return _timeSpan;
+ return new TimeSpan((Int64)_timestamp);
+ }
+ }
+
+ /// <summary>
+ /// Gets or sets the timestamp.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ /// <value> Timestamp. </value>
+ public ulong Timestamp
+ {
+ set
+ {
+ Log.Info(Globals.LogTag, "Setting the timestamp of the sensor values");
+ _timestamp = value;
+ }
+ get
+ {
+ Log.Info(Globals.LogTag, "Getting the timestamp of the sensor values");
+ return _timestamp;
}
}
Log.Error(Globals.LogTag, "Error starting sensor");
throw SensorErrorFactory.CheckAndThrowException(error, "Unable to Start Sensor Listener");
}
- ReadData();
+ try
+ {
+ ReadData();
+ }
+ catch (InvalidOperationException e)
+ {
+ Log.Error(Globals.LogTag, "Sensor has no data.");
+ }
EventListenStart();
_isSensing = true;
Log.Info(Globals.LogTag, "Sensor started");
/// <summary>
/// Pedometer sensor.
/// </summary>
+ HRMBatch = 0x200,
+ /// <summary>
+ /// Pedometer sensor.
+ /// </summary>
+ HRMLEDGreenBatch = 0x201,
+ /// <summary>
+ /// Pedometer sensor.
+ /// </summary>
Pedometer = 0x300,
/// <summary>
/// Sleep monitor sensor.
/// </summary>
SleepMonitor = 0x301,
/// <summary>
- /// Stationary activity detector.
- /// </summary>
/// Auto Rotation sensor.
/// </summary>
AutoRotation = 0x901,
/// <summary>
+ /// Stationary activity detector.
+ /// </summary>
StationaryActivityDetector = 0x1A00,
/// <summary>
/// Walking activity detector.
/// <since_tizen> 7 </since_tizen>
Degree_270 = 4
}
+
+
+ /// <summary>
+ /// HeartRateMonitorBatchState types.
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public enum HeartRateMonitorBatchState
+ {
+ /// <summary>
+ /// Flush but there was no batched data
+ /// </summary>
+ SENSOR_HRM_BATCH_STATE_NODATA_FLUSH = -99,
+
+ /// <summary>
+ /// Very low measurement reliability
+ /// </summary>
+ SENSOR_HRM_BATCH_STATE_VERYLOW_RELIABILITY = -10,
+
+ /// <summary>
+ /// Low measurement reliability
+ /// </summary>
+ SENSOR_HRM_BATCH_STATE_LOW_RELIABILITY = -8,
+
+ /// <summary>
+ /// Device detachment was detected during auto measurement
+ /// </summary>
+ SENSOR_HRM_BATCH_STATE_DETACHED_AUTO = -5,
+
+ /// <summary>
+ /// Device detachment was detected
+ /// </summary>
+ SENSOR_HRM_BATCH_STATE_DETACHED = -3,
+
+ /// <summary>
+ /// The Movement was detected during on-demand measurement
+ /// </summary>
+ SENSOR_HRM_BATCH_STATE_DETECT_MOVE = -2,
+
+ /// <summary>
+ /// Device attachment was detected
+ /// </summary>
+ SENSOR_HRM_BATCH_STATE_ATTACHED = -1,
+
+ /// <summary>
+ /// Initial state before measurement
+ /// </summary>
+ SENSOR_HRM_BATCH_STATE_NONE = 0,
+
+ /// <summary>
+ /// SENSOR_HRM_BATCH_STATE_OK
+ /// </summary>
+ SENSOR_HRM_BATCH_STATE_OK = 1
+ }
}
projects / platform / core / csapi / tizenfx.git / commitdiff