From: MuHong Byun Date: Mon, 13 Jan 2020 05:11:59 +0000 (+0900) Subject: [Sensor] Add auto rotation sensor (#1193) X-Git-Tag: submit/tizen/20200114.005334~1^2~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=e25149e7c5d3fd727f8e334fc442aa3303fda43a;p=platform%2Fcore%2Fcsapi%2Ftizenfx.git [Sensor] Add auto rotation sensor (#1193) Signed-off-by: MuHong Byun --- diff --git a/src/Tizen.Sensor/Tizen.Sensor/EventArgs/AutoRotationSensorDataUpdatedEventArgs.cs b/src/Tizen.Sensor/Tizen.Sensor/EventArgs/AutoRotationSensorDataUpdatedEventArgs.cs new file mode 100644 index 0000000..bd4cc10 --- /dev/null +++ b/src/Tizen.Sensor/Tizen.Sensor/EventArgs/AutoRotationSensorDataUpdatedEventArgs.cs @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2019 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.ComponentModel; + +namespace Tizen.Sensor +{ + /// + /// The AutoRotationSensor changed event arguments class is used for storing the data returned by the auto rotation sensor. + /// + /// 7 + public class AutoRotationSensorDataUpdatedEventArgs : EventArgs + { + internal AutoRotationSensorDataUpdatedEventArgs(float[] values, SensorDataAccuracy accuracy) + { + Rotation = (AutoRotationState)values[0]; + Accuracy = accuracy; + } + + /// + /// Gets the value of the rotation state. + /// + /// 7 + /// The rotation state. + public AutoRotationState Rotation { get; private set; } = AutoRotationState.Degree_0; + + /// + /// Gets the accuracy of the auto rotation data. + /// + /// 7 + /// Accuracy + public SensorDataAccuracy Accuracy { get; private set; } + } +} \ No newline at end of file diff --git a/src/Tizen.Sensor/Tizen.Sensor/Plugins/AutoRotationSensor.cs b/src/Tizen.Sensor/Tizen.Sensor/Plugins/AutoRotationSensor.cs new file mode 100644 index 0000000..d435bee --- /dev/null +++ b/src/Tizen.Sensor/Tizen.Sensor/Plugins/AutoRotationSensor.cs @@ -0,0 +1,214 @@ +/* + * Copyright (c) 2019 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.ComponentModel; + +namespace Tizen.Sensor +{ + /// + /// The AutoRotationSensor class is used for registering callbacks for the auto rotation sensor and getting the auto rotation data. + /// + /// 7 + public sealed class AutoRotationSensor : Sensor + { + private static string AccelerometerKey = "http://tizen.org/feature/sensor.accelerometer"; + + private event EventHandler _accuracyChanged; + + /// + /// Gets the value of the rotation state. + /// + /// 7 + /// The rotation state. + public AutoRotationState Rotation { get; private set; } = AutoRotationState.Degree_0; + + + /// + /// Gets the accuracy of the auto rotation data. + /// + /// 7 + /// Accuracy + public SensorDataAccuracy Accuracy { get; private set; } = SensorDataAccuracy.Undefined; + + /// + /// Returns true or false based on whether the auto rotation sensor is supported by the device. + /// + /// 7 + /// true if supported; otherwise false. + public static bool IsSupported + { + get + { + Log.Info(Globals.LogTag, "Checking if the AutoRotationSensor is supported"); + return CheckIfSupported(SensorType.AutoRotation, AccelerometerKey); + } + } + + /// + /// Initializes a new instance of the class. + /// + /// 7 + /// http://tizen.org/feature/sensor.accelerometer + /// Thrown when an invalid argument is used. + /// Thrown when the sensor is not supported. + /// Thrown when the operation is invalid for the current state. + /// + /// Index. Default value for this is 0. Index refers to a particular auto rotation sensor in case of multiple sensors. + /// + public AutoRotationSensor(uint index = 0) : base(index) + { + Log.Info(Globals.LogTag, "Creating AutoRotationSensor object"); + } + + internal override SensorType GetSensorType() + { + return SensorType.AutoRotation; + } + + /// + /// An event handler for storing the callback functions for the event corresponding to the change in the auto rotation sensor data. + /// + /// 7 + + public event EventHandler DataUpdated; + + /// + /// An event handler for accuracy changed events. + /// + /// 7 + public event EventHandler 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.AutoRotation, out list, out count); + if (error != (int)SensorError.None) + { + Log.Error(Globals.LogTag, "Error getting sensor list for auto rotation"); + count = 0; + } + else + Interop.Libc.Free(list); + return count; + } + + /// + /// Read auto rotation data synchronously. + /// + internal override void ReadData() + { + Interop.SensorEventStruct sensorData; + int error = Interop.SensorListener.ReadData(ListenerHandle, out sensorData); + if (error != (int)SensorError.None) + { + Log.Error(Globals.LogTag, "Error reading auto rotation data"); + throw SensorErrorFactory.CheckAndThrowException(error, "Reading auto rotation data failed"); + } + + TimeSpan = new TimeSpan((Int64)sensorData.timestamp); + if (sensorData.values[0] == 0) { + Rotation = AutoRotationState.Degree_0; + } else { + Rotation = (AutoRotationState)sensorData.values[0]; + } + Accuracy = sensorData.accuracy; + } + + private static Interop.SensorListener.SensorEventCallback _callback; + + internal override void EventListenStart() + { + _callback = (IntPtr sensorHandle, IntPtr eventPtr, IntPtr data) => { + Interop.SensorEventStruct sensorData = Interop.IntPtrToEventStruct(eventPtr); + + TimeSpan = new TimeSpan((Int64)sensorData.timestamp); + if (sensorData.values[0] == 0) { + Rotation = AutoRotationState.Degree_0; + } else { + Rotation = (AutoRotationState)sensorData.values[0]; + } + Accuracy = sensorData.accuracy; + + DataUpdated?.Invoke(this, new AutoRotationSensorDataUpdatedEventArgs(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 auto rotation sensor"); + throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set event callback for auto rotation"); + } + } + + internal override void EventListenStop() + { + int error = Interop.SensorListener.UnsetEventCallback(ListenerHandle); + if (error != (int)SensorError.None) + { + Log.Error(Globals.LogTag, "Error unsetting event callback for auto rotation sensor"); + throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset event callback for auto rotation"); + } + } + + private static Interop.SensorListener.SensorAccuracyCallback _accuracyCallback; + + private void AccuracyListenStart() + { + _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 auto rotation sensor"); + throw SensorErrorFactory.CheckAndThrowException(error, "Unable to set accuracy event callback for auto rotation"); + } + } + + private void AccuracyListenStop() + { + int error = Interop.SensorListener.UnsetAccuracyCallback(ListenerHandle); + if (error != (int)SensorError.None) + { + Log.Error(Globals.LogTag, "Error unsetting accuracy event callback for auto rotation sensor"); + throw SensorErrorFactory.CheckAndThrowException(error, "Unable to unset accuracy event callback for auto rotation"); + } + } + } +} diff --git a/src/Tizen.Sensor/Tizen.Sensor/SensorEnumerations.cs b/src/Tizen.Sensor/Tizen.Sensor/SensorEnumerations.cs index 37e0b24..fe7020a 100755 --- a/src/Tizen.Sensor/Tizen.Sensor/SensorEnumerations.cs +++ b/src/Tizen.Sensor/Tizen.Sensor/SensorEnumerations.cs @@ -110,6 +110,10 @@ namespace Tizen.Sensor /// /// Stationary activity detector. /// + /// Auto Rotation sensor. + /// + AutoRotation = 0x901, + /// StationaryActivityDetector = 0x1A00, /// /// Walking activity detector. @@ -319,4 +323,35 @@ namespace Tizen.Sensor /// 3 Detected = 1 } + + /// + /// The auto rotation state. + /// + /// 7 + public enum AutoRotationState + { + /// + /// Degree_0 sate. + /// + /// 7 + Degree_0 = 1, + + /// + /// Degree_90 state. + /// + /// 7 + Degree_90 = 2, + + /// + /// Degree_180 state. + /// + /// 7 + Degree_180 = 3, + + /// + /// Degree_270 state. + /// + /// 7 + Degree_270 = 4 + } }