Google Git
Sign in
android / platform / hardware / interfaces / 4497a5fe338c4a19dc31312641b2caa8454eb24e / . / sensors / 1.0 / types.hal
blob: 3926e2f4b148fbbbb3c1953ab445235b29c0b7a7 [file] [log] [blame]
/*
* Copyright (C) 2016 The Android Open Source Project
*
* 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.
*/
package android.hardware.sensors@1.0;
/**
* Please see the Sensors section of source.android.com for an
* introduction to and detailed descriptions of Android sensor types:
* http://source.android.com/devices/sensors/index.html
*/
/** Type enumerating various result codes returned from ISensors methods */
enum Result : int32_t {
OK,
PERMISSION_DENIED = -1,
NO_MEMORY = -12,
BAD_VALUE = -22,
INVALID_OPERATION = -38,
};
/**
* Sensor HAL modes used in setOperationMode method
*/
@export(name="", value_prefix="SENSOR_HAL_", value_suffix="_MODE")
enum OperationMode : int32_t {
NORMAL = 0,
DATA_INJECTION = 1,
};
/**
* Sensor type
*
* Each sensor has a type which defines what this sensor measures and how
* measures are reported. See the Base sensors and Composite sensors lists
* for complete descriptions:
* http://source.android.com/devices/sensors/base_triggers.html
* http://source.android.com/devices/sensors/composite_sensors.html
*
* Device manufacturers (OEMs) can define their own sensor types, for
* their private use by applications or services provided by them. Such
* sensor types are specific to an OEM and can't be exposed in the SDK.
* These types must start at SensorType::DEVICE_PRIVATE_BASE.
*
* All sensors defined outside of the device private range must correspond to
* a type defined in this file, and must satisfy the characteristics listed in
* the description of the sensor type.
*
* Each sensor also has a "typeAsString".
* - string type of sensors defined in this file is overridden by Android to
* values defined in Android API with "android.sensor." prefix.
* Example: for an accelerometer,
* type = SensorType::Acclerometer
* typeAsString = "" (will be replace by "android.sensor.accelerometer" by
* Android frameowrk)
* - string type of sensors inside of the device private range MUST be prefixed
* by the sensor provider's or OEM reverse domain name. In particular, they
* cannot use the "android.sensor." prefix.
*
* When android introduces a new sensor type that can replace an OEM-defined
* sensor type, the OEM must use the official sensor type and stringType on
* versions of the HAL that support this new official sensor type.
*
* Example (made up): Suppose Google's Glass team wants to surface a sensor
* detecting that Glass is on a head.
* - Such a sensor is not officially supported in android KitKat
* - Glass devices launching on KitKat can implement a sensor with
* type = 0x10001
* typeAsString = "com.google.glass.onheaddetector"
* - In L android release, if android decides to define
* SensorType::ON_HEAD_DETECTOR and STRING_SensorType::ON_HEAD_DETECTOR,
* those types should replace the Glass-team-specific types in all future
* launches.
* - When launching Glass on the L release, Google should now use the official
* type (SensorType::ON_HEAD_DETECTOR) and stringType.
* - This way, all applications can now use this sensor.
*/
/**
* Wake up sensors.
* Each sensor may have either or both a wake-up and a non-wake variant.
* When registered in batch mode, wake-up sensors will wake up the AP when
* their FIFOs are full or when the batch timeout expires. A separate FIFO has
* to be maintained for wake up sensors and non wake up sensors. The non
* wake-up sensors need to overwrite their FIFOs when they are full till the AP
* wakes up and the wake-up sensors will wake-up the AP when their FIFOs are
* full or when the batch timeout expires without losing events.
* Wake-up and non wake-up variants of each sensor can be activated at
* different rates independently of each other.
*
* Note: Proximity sensor and significant motion sensor which were defined in
* previous releases are also wake-up sensors and must be treated as such.
* Wake-up one-shot sensors like SIGNIFICANT_MOTION cannot be batched, hence
* the text about batch above doesn't apply to them. See the definitions of
* SensorType::PROXIMITY and SensorType::SIGNIFICANT_MOTION for more info.
*
* Set SENSOR_FLAG_WAKE_UP flag for all wake-up sensors.
*
* For example, A device can have two sensors both of SensorType::ACCELEROMETER
* and one of them can be a wake_up sensor (with SENSOR_FLAG_WAKE_UP flag set)
* and the other can be a regular non wake_up sensor. Both of these sensors
* must be activated/deactivated independently of the other.
*/
@export(name="", value_prefix="SENSOR_TYPE_")
enum SensorType : int32_t {
/**
* META_DATA is a special event type used to populate the MetaData
* structure. It doesn't correspond to a physical sensor. Events of this
* type exist only inside the HAL, their primary purpose is to signal the
* completion of a flush request.
*/
META_DATA = 0,
/**
* ACCELEROMETER
* reporting-mode: continuous
*
* All values are in SI units (m/s^2) and measure the acceleration of the
* device minus the acceleration due to gravity.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
ACCELEROMETER = 1,
/**
* MAGNETIC_FIELD
* reporting-mode: continuous
*
* All values are in micro-Tesla (uT) and measure the geomagnetic
* field in the X, Y and Z axis.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
MAGNETIC_FIELD = 2,
/**
* ORIENTATION
* reporting-mode: continuous
*
* All values are angles in degrees.
*
* Orientation sensors return sensor events for all 3 axes at a constant
* rate defined by setDelay().
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
ORIENTATION = 3,
/**
* GYROSCOPE
* reporting-mode: continuous
*
* All values are in radians/second and measure the rate of rotation
* around the X, Y and Z axis.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
GYROSCOPE = 4,
/**
* LIGHT
* reporting-mode: on-change
*
* The light sensor value is returned in SI lux units.
*
* Both wake-up and non wake-up versions are useful.
*/
LIGHT = 5,
/**
* PRESSURE
* reporting-mode: continuous
*
* The pressure sensor return the athmospheric pressure in hectopascal (hPa)
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
PRESSURE = 6,
/** TEMPERATURE is deprecated in the HAL */
TEMPERATURE = 7,
/**
* PROXIMITY
* reporting-mode: on-change
*
* The proximity sensor which turns the screen off and back on during calls
* is the wake-up proximity sensor. Implement wake-up proximity sensor
* before implementing a non wake-up proximity sensor. For the wake-up
* proximity sensor set the flag SENSOR_FLAG_WAKE_UP.
* The value corresponds to the distance to the nearest object in
* centimeters.
*/
PROXIMITY = 8,
/**
* GRAVITY
* reporting-mode: continuous
*
* A gravity output indicates the direction of and magnitude of gravity in
* the devices's coordinates.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
GRAVITY = 9,
/**
* LINEAR_ACCELERATION
* reporting-mode: continuous
*
* Indicates the linear acceleration of the device in device coordinates,
* not including gravity.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
LINEAR_ACCELERATION = 10,
/**
* ROTATION_VECTOR
* reporting-mode: continuous
*
* The rotation vector symbolizes the orientation of the device relative to
* the East-North-Up coordinates frame.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
ROTATION_VECTOR = 11,
/**
* RELATIVE_HUMIDITY
* reporting-mode: on-change
*
* A relative humidity sensor measures relative ambient air humidity and
* returns a value in percent.
*
* Both wake-up and non wake-up versions are useful.
*/
RELATIVE_HUMIDITY = 12,
/**
* AMBIENT_TEMPERATURE
* reporting-mode: on-change
*
* The ambient (room) temperature in degree Celsius.
*
* Both wake-up and non wake-up versions are useful.
*/
AMBIENT_TEMPERATURE = 13,
/**
* MAGNETIC_FIELD_UNCALIBRATED
* reporting-mode: continuous
*
* Similar to MAGNETIC_FIELD, but the hard iron calibration is
* reported separately instead of being included in the measurement.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
MAGNETIC_FIELD_UNCALIBRATED = 14,
/**
* GAME_ROTATION_VECTOR
* reporting-mode: continuous
*
* Similar to ROTATION_VECTOR, but not using the geomagnetic
* field.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
GAME_ROTATION_VECTOR = 15,
/**
* GYROSCOPE_UNCALIBRATED
* reporting-mode: continuous
*
* All values are in radians/second and measure the rate of rotation
* around the X, Y and Z axis.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
GYROSCOPE_UNCALIBRATED = 16,
/**
* SIGNIFICANT_MOTION
* reporting-mode: one-shot
*
* A sensor of this type triggers an event each time significant motion
* is detected and automatically disables itself.
* For Significant Motion sensor to be useful, it must be defined as a
* wake-up sensor. (set SENSOR_FLAG_WAKE_UP). Implement the wake-up
* significant motion sensor. A non wake-up version is not useful.
* The only allowed value to return is 1.0.
*/
SIGNIFICANT_MOTION = 17,
/**
* STEP_DETECTOR
* reporting-mode: special
*
* A sensor of this type triggers an event each time a step is taken
* by the user. The only allowed value to return is 1.0 and an event
* is generated for each step.
*
* Both wake-up and non wake-up versions are useful.
*/
STEP_DETECTOR = 18,
/**
* STEP_COUNTER
* reporting-mode: on-change
*
* A sensor of this type returns the number of steps taken by the user since
* the last reboot while activated. The value is returned as a uint64_t and
* is reset to zero only on a system / android reboot.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
STEP_COUNTER = 19,
/**
* GEOMAGNETIC_ROTATION_VECTOR
* reporting-mode: continuous
*
* Similar to ROTATION_VECTOR, but using a magnetometer instead
* of using a gyroscope.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
GEOMAGNETIC_ROTATION_VECTOR = 20,
/**
* HEART_RATE
* reporting-mode: on-change
*
* A sensor of this type returns the current heart rate.
* The events contain the current heart rate in beats per minute (BPM) and
* the status of the sensor during the measurement. See "HeartRate" below
* for more details.
*
* Because this sensor is on-change, events must be generated when and only
* when heart_rate.bpm or heart_rate.status have changed since the last
* event. In particular, upon the first activation, unless the device is
* known to not be on the body, the status field of the first event must be
* set to SensorStatus::UNRELIABLE. The event should be generated no faster
* than every period_ns passed to setDelay() or to batch().
* See the definition of the on-change reporting mode for more information.
*
* SensorInfo.requiredPermission must be set to
* SENSOR_PERMISSION_BODY_SENSORS.
*
* Both wake-up and non wake-up versions are useful.
*/
HEART_RATE = 21,
/**
* WAKE_UP_TILT_DETECTOR
* reporting-mode: special (setDelay has no impact)
*
* A sensor of this type generates an event each time a tilt event is
* detected. A tilt event must be generated if the direction of the
* 2-seconds window average gravity changed by at least 35 degrees since the
* activation or the last trigger of the sensor.
*
* reference_estimated_gravity = average of accelerometer measurements over
* the first 1 second after activation or the estimated gravity at the last
* trigger.
*
* current_estimated_gravity = average of accelerometer measurements over
* the last 2 seconds.
*
* trigger when
* angle(reference_estimated_gravity, current_estimated_gravity)
* > 35 degrees
*
* Large accelerations without a change in phone orientation must not
* trigger a tilt event.
* For example, a sharp turn or strong acceleration while driving a car
* must not trigger a tilt event, even though the angle of the average
* acceleration might vary by more than 35 degrees.
*
* Typically, this sensor is implemented with the help of only an
* accelerometer. Other sensors can be used as well if they do not increase
* the power consumption significantly. This is a low power sensor that
* must allow the AP to go into suspend mode. Do not emulate this sensor
* in the HAL.
* Like other wake up sensors, the driver is expected to a hold a wake_lock
* with a timeout of 200 ms while reporting this event. The only allowed
* return value is 1.0.
*
* Implement only the wake-up version of this sensor.
*/
TILT_DETECTOR = 22,
/**
* WAKE_GESTURE
* reporting-mode: one-shot
*
* A sensor enabling waking up the device based on a device specific motion.
*
* When this sensor triggers, the device behaves as if the power button was
* pressed, turning the screen on. This behavior (turning on the screen when
* this sensor triggers) might be deactivated by the user in the device
* settings. Changes in settings do not impact the behavior of the sensor:
* only whether the framework turns the screen on when it triggers.
*
* The actual gesture to be detected is not specified, and can be chosen by
* the manufacturer of the device.
* This sensor must be low power, as it is likely to be activated 24/7.
* The only allowed value to return is 1.0.
*
* Implement only the wake-up version of this sensor.
*/
WAKE_GESTURE = 23,
/**
* GLANCE_GESTURE
* reporting-mode: one-shot
*
* A sensor enabling briefly turning the screen on to enable the user to
* glance content on screen based on a specific motion. The device must
* turn the screen off after a few moments.
*
* When this sensor triggers, the device turns the screen on momentarily
* to allow the user to glance notifications or other content while the
* device remains locked in a non-interactive state (dozing). This behavior
* (briefly turning on the screen when this sensor triggers) might be
* deactivated by the user in the device settings.
* Changes in settings do not impact the behavior of the sensor: only
* whether the framework briefly turns the screen on when it triggers.
*
* The actual gesture to be detected is not specified, and can be chosen by
* the manufacturer of the device.
* This sensor must be low power, as it is likely to be activated 24/7.
* The only allowed value to return is 1.0.
*
* Implement only the wake-up version of this sensor.
*/
GLANCE_GESTURE = 24,
/**
* PICK_UP_GESTURE
* reporting-mode: one-shot
*
* A sensor of this type triggers when the device is picked up regardless of
* wherever is was before (desk, pocket, bag). The only allowed return value
* is 1.0. This sensor de-activates itself immediately after it triggers.
*
* Implement only the wake-up version of this sensor.
*/
PICK_UP_GESTURE = 25,
/**
* WRIST_TILT_GESTURE
* trigger-mode: special
* wake-up sensor: yes
*
* A sensor of this type triggers an event each time a tilt of the
* wrist-worn device is detected.
*
* This sensor must be low power, as it is likely to be activated 24/7.
* The only allowed value to return is 1.0.
*
* Implement only the wake-up version of this sensor.
*/
WRIST_TILT_GESTURE = 26,
/**
* DEVICE_ORIENTATION
* reporting-mode: on-change
*
* The current orientation of the device. The value is reported in
* the "scalar" element of the EventPayload in Event. The
* only values that can be reported are (please refer to Android Sensor
* Coordinate System to understand the X and Y axis direction with respect
* to default orientation):
* - 0: device is in default orientation (Y axis is vertical and points up)
* - 1: device is rotated 90 degrees counter-clockwise from default
* orientation (X axis is vertical and points up)
* - 2: device is rotated 180 degrees from default orientation (Y axis is
* vertical and points down)
* - 3: device is rotated 90 degrees clockwise from default orientation
* (X axis is vertical and points down)
*
* Moving the device to an orientation where the Z axis is vertical (either
* up or down) must not cause a new event to be reported.
*
* To improve the user experience of this sensor, it is recommended to
* implement some physical (i.e., rotation angle) and temporal (i.e., delay)
* hysteresis. In other words, minor or transient rotations must not cause
* a new event to be reported.
*
* This is a low power sensor that intended to reduce interrupts of
* application processor and thus allow it to go sleep. Use hardware
* implementation based on low power consumption sensors, such as
* accelerometer. Device must not emulate this sensor in the HAL.
*
* Both wake-up and non wake-up versions are useful.
*/
DEVICE_ORIENTATION = 27,
/**
* POSE_6DOF
* trigger-mode: continuous
*
* A sensor of this type returns the pose of the device.
* Pose of the device is defined as the orientation of the device from a
* Earth Centered Earth Fixed frame and the translation from an arbitrary
* point at subscription.
*
* This sensor can be high power. It can use any and all of the following
* . Accelerometer
* . Gyroscope
* . Camera
* . Depth Camera
*
*/
POSE_6DOF = 28,
/**
* STATIONARY_DETECT
* trigger mode: one shot
*
* A sensor of this type returns an event if the device is still/stationary
* for a while. The period of time to monitor for stationarity must be
* greater than 5 seconds. The latency must be less than 10 seconds.
*
* Stationarity here refers to absolute stationarity. eg: device on desk.
*
* The only allowed value to return is 1.0.
*/
STATIONARY_DETECT = 29,
/**
* MOTION_DETECT
* trigger mode: one shot
*
* A sensor of this type returns an event if the device is not still for
* for a while. The period of time to monitor for stationarity must be
* greater than 5 seconds. The latency must be less than 10 seconds.
*
* Motion here refers to any mechanism in which the device is causes to be
* moved in its inertial frame. eg: Pickin up the device and walking with it
* to a nearby room may trigger motion wherewas keeping the device on a
* table on a smooth train moving at constant velocity may not trigger
* motion.
*
* The only allowed value to return is 1.0.
*/
MOTION_DETECT = 30,
/**
* HEART_BEAT
* trigger mode: continuous
*
* A sensor of this type returns an event everytime a hear beat peak is
* detected.
*
* Peak here ideally corresponds to the positive peak in the QRS complex of
* and ECG signal.
*
* The sensor is not expected to be optimized for latency. As a guide, a
* latency of up to 10 seconds is acceptable. However, the timestamp attached
* to the event must be accuratly correspond to the time the peak occured.
*
* The sensor event contains a parameter for the confidence in the detection
* of the peak where 0.0 represent no information at all, and 1.0 represents
* certainty.
*/
HEART_BEAT = 31,
/**
* DYNAMIC_SENSOR_META
* trigger-mode: special
* wake-up sensor: yes
*
* A sensor event of this type is received when a dynamic sensor is added to
* or removed from the system. At most one sensor of this type can be
* present in one sensor HAL implementation and presence of a sensor of this
* type in sensor HAL implementation indicates that this sensor HAL supports
* dynamic sensor feature. Operations, such as batch, activate and setDelay,
* to this special purpose sensor must be treated as no-op and return
* successful; flush() also has to generate flush complete event as if this
* is a sensor that does not support batching.
*
* A dynamic sensor connection indicates connection of a physical device or
* instantiation of a virtual sensor backed by algorithm; and a dynamic
* sensor disconnection indicates the the opposite. A sensor event of
* DYNAMIC_SENSOR_META type should be delivered regardless of
* the activation status of the sensor in the event of dynamic sensor
* connection and disconnection. In the sensor event, besides the common
* data entries, "dynamic_sensor_meta", which includes fields for connection
* status, handle of the sensor involved, pointer to sensor_t structure and
* a uuid field, must be populated.
*
* At a dynamic sensor connection event, fields of sensor_t structure
* referenced by a pointer in dynamic_sensor_meta must be filled as if it
* was regular sensors. Sensor HAL is responsible for recovery of memory if
* the corresponding data is dynamicially allocated. However, the the
* pointer must be valid until the first activate call to the sensor
* reported in this connection event. At a dynamic sensor disconnection,
* the sensor_t pointer must be NULL.
*
* The sensor handle assigned to dynamic sensors must never be the same as
* that of any regular static sensors, and must be unique until next boot.
* In another word, if a handle h is used for a dynamic sensor A, that same
* number cannot be used for the same dynamic sensor A or another dynamic
* sensor B even after disconnection of A until reboot.
*
* The UUID field will be used for identifying the sensor in addition to
* name, vendor and version and type. For physical sensors of the same
* model, all sensors will have the same values in sensor_t, but the UUID
* must be unique and persistent for each individual unit. An all zero
* UUID indicates it is not possible to differentiate individual sensor
* unit.
*
*/
DYNAMIC_SENSOR_META = 32,
/**
* ADDITIONAL_INFO
* reporting-mode: N/A
*
* This sensor type is for delivering additional sensor information aside
* from sensor event data.
* Additional information may include sensor front-end group delay, internal
* calibration parameters, noise level metrics, device internal temperature,
* etc.
*
* This type will never bind to a sensor. In other words, no sensor in the
* sensor list can have the type SENSOR_TYPE_ADDITIONAL_INFO. If a
* sensor HAL supports sensor additional information feature, it reports
* sensor_event_t with "sensor" field set to handle of the reporting sensor
* and "type" field set to ADDITIONAL_INFO. Delivery of
* additional information events is triggered under two conditions: an
* enable activate() call or a flush() call to the corresponding sensor.
* Besides, time varying parameters can update infrequently without being
* triggered. Device is responsible to control update rate. The recommend
* update rate is less than 1/1000 of sensor event rate or less than once
* per minute in average.
*
* A single additional information report consists of multiple frames.
* Sequences of these frames are ordered using timestamps, which means the
* timestamps of sequential frames have to be at least 1 nanosecond apart
* from each other. Each frame is a sensor_event_t delivered through the HAL
* interface, with related data stored in the "additional_info" field, which
* is of type additional_info_event_t.
* The "type" field of additional_info_event_t denotes the nature of the
* payload data (see additional_info_type_t).
* The "serial" field is used to keep the sequence of payload data that
* spans multiple frames. The first frame of the entire report is always of
* type AINFO_BEGIN, and the last frame is always AINFO_END.
*
* If flush() was triggering the report, all additional information frames
* must be delivered after flush complete event.
*/
ADDITIONAL_INFO = 33,
/**
* LOW_LATENCY_OFFBODY_DETECT
* trigger-mode: on-change
* wake-up sensor: yes
*
* A sensor of this type is defined for devices that are supposed to be worn
* by the user in the normal use case (such as a watch, wristband, etc) and
* is not yet defined for other device.
*
* A sensor of this type triggers an event each time the wearable device
* is removed from the body and each time it's put back onto the body.
* It must be low-latency and be able to detect the on-body to off-body
* transition within one second (event delivery time included),
* and 3-second latency to determine the off-body to on-body transition
* (event delivery time included).
*
* There are only two valid event values for the sensor to return :
* 0.0 for off-body
* 1.0 for on-body
*
*/
LOW_LATENCY_OFFBODY_DETECT = 34,
/**
* ACCELEROMETER_UNCALIBRATED
* reporting-mode: continuous
*
* All values are in SI units (m/s^2) and measure the acceleration of the
* device minus the acceleration due to gravity.
*
* Implement the non-wake-up version of this sensor and implement the
* wake-up version if the system possesses a wake up fifo.
*/
ACCELEROMETER_UNCALIBRATED = 35,
/**
* Base for device manufacturers private sensor types.
* These sensor types can't be exposed in the SDK.
*/
DEVICE_PRIVATE_BASE = 0x10000
};
@export(name="", value_prefix="SENSOR_FLAG_")
enum SensorFlagBits : uint32_t {
/**
* Whether this sensor wakes up the AP from suspend mode when data is
* available. Whenever sensor events are delivered from a wake_up sensor,
* the driver needs to hold a wake_lock till the events are read by the
* SensorService i.e till ISensors::poll() is called the next time.
* Once poll is called again it means events have been read by the
* SensorService, the driver can safely release the wake_lock. SensorService
* will continue to hold a wake_lock till the app actually reads the events.
*/
WAKE_UP = 1,
/**
* Reporting modes for various sensors. Each sensor will have exactly one of
* these modes set.
* The least significant 2nd, 3rd and 4th bits are used to represent four
* possible reporting modes.
*/
CONTINUOUS_MODE = 0,
ON_CHANGE_MODE = 2,
ONE_SHOT_MODE = 4,
SPECIAL_REPORTING_MODE = 6,
/**
* Set this flag if the sensor supports data_injection mode and allows data
* to be injected from the SensorService. When in data_injection ONLY
* sensors with this flag set are injected sensor data and only sensors with
* this flag set are activated. Eg: Accelerometer and Step Counter sensors
* can be set with this flag and SensorService will inject accelerometer
* data and read the corresponding step counts.
*/
DATA_INJECTION = 0x10,
/**
* Set this flag if the sensor is a dynamically connected sensor. See
* DynamicSensorInfo and DYNAMIC_SENSOR_META for details.
*/
DYNAMIC_SENSOR = 0x20,
/**
* Set this flag if sensor additional information is supported.
* See ADDITIONAL_INFO and AdditionalInfo for details.
*/
ADDITIONAL_INFO = 0x40,
/**
* Set this flag if sensor suppor direct channel backed by ashmem.
* See SharedMemType and registerDirectChannel for more details.
*/
DIRECT_CHANNEL_ASHMEM = 0x400,
/**
* Set this flag if sensor suppor direct channel backed by gralloc HAL memory.
* See SharedMemType and registerDirectChannel for more details.
*/
DIRECT_CHANNEL_GRALLOC = 0x800,
/**
* Flags mask for reporting mode of sensor.
*/
MASK_REPORTING_MODE = 0xE,
/**
* Flags mask for direct report maximum rate level support.
* See RateLevel.
*/
MASK_DIRECT_REPORT = 0x380,
/**
* Flags mask for all direct channel support bits.
* See SharedMemType.
*/
MASK_DIRECT_CHANNEL = 0xC00,
};
@export(name="sensor_flag_shift_t", value_prefix="SENSOR_FLAG_SHIFT_")
enum SensorFlagShift : uint8_t {
REPORTING_MODE = 1,
DATA_INJECTION = 4,
DYNAMIC_SENSOR = 5,
ADDITIONAL_INFO = 6,
DIRECT_REPORT = 7,
DIRECT_CHANNEL = 10,
};
struct SensorInfo {
/**
* handle that identifies this sensors. This handle is used to reference
* this sensor throughout the HAL API.
*/
int32_t sensorHandle;
/**
* Name of this sensor.
* All sensors of the same "type" must have a different "name".
*/
string name;
/** vendor of the hardware part */
string vendor;
/**
* version of the hardware part + driver. The value of this field
* must increase when the driver is updated in a way that changes the
* output of this sensor. This is important for fused sensors when the
* fusion algorithm is updated.
*/
int32_t version;
/** this sensor's type. */
SensorType type;
/**
* type of this sensor as a string.
*
* When defining an OEM specific sensor or sensor manufacturer specific
* sensor, use your reserve domain name as a prefix.
* e.g. com.google.glass.onheaddetector
*
* For sensors of known type defined in SensorType (value <
* SensorType::DEVICE_PRIVATE_BASE), this can be an empty string.
*/
string typeAsString;
/** maximum range of this sensor's value in SI units */
float maxRange;
/** smallest difference between two values reported by this sensor */
float resolution;
/** rough estimate of this sensor's power consumption in mA */
float power;
/**
* this value depends on the reporting mode:
*
* continuous: minimum sample period allowed in microseconds
* on-change : 0
* one-shot :-1
* special : 0, unless otherwise noted
*/
int32_t minDelay;
/**
* number of events reserved for this sensor in the batch mode FIFO.
* If there is a dedicated FIFO for this sensor, then this is the
* size of this FIFO. If the FIFO is shared with other sensors,
* this is the size reserved for that sensor and it can be zero.
*/
uint32_t fifoReservedEventCount;
/**
* maximum number of events of this sensor that could be batched.
* This is especially relevant when the FIFO is shared between
* several sensors; this value is then set to the size of that FIFO.
*/
uint32_t fifoMaxEventCount;
/**
* permission required to see this sensor, register to it and receive data.
* Set to "" if no permission is required. Some sensor types like the
* heart rate monitor have a mandatory require_permission.
* For sensors that always require a specific permission, like the heart
* rate monitor, the android framework might overwrite this string
* automatically.
*/
string requiredPermission;
/**
* This value is defined only for continuous mode and on-change sensors.
* It is the delay between two sensor events corresponding to the lowest
* frequency that this sensor supports. When lower frequencies are requested
* through batch()/setDelay() the events will be generated at this frequency
* instead.
* It can be used by the framework or applications to estimate when the
* batch FIFO may be full.
*
* NOTE: periodNs is in nanoseconds where as maxDelay/minDelay are in
* microseconds.
*
* continuous, on-change: maximum sampling period allowed in
* microseconds.
*
* one-shot, special : 0
*/
int32_t maxDelay;
/** Bitmask of SensorFlagBits */
bitfield<SensorFlagBits> flags;
};
@export(name="", value_prefix="SENSOR_STATUS_")
enum SensorStatus : int8_t {
NO_CONTACT = -1,
UNRELIABLE = 0,
ACCURACY_LOW = 1,
ACCURACY_MEDIUM = 2,
ACCURACY_HIGH = 3,
};
struct Vec3 {
float x;
float y;
float z;
SensorStatus status;
};
struct Vec4 {
float x;
float y;
float z;
float w;
};
struct Uncal {
float x;
float y;
float z;
float x_bias;
float y_bias;
float z_bias;
};
struct HeartRate {
/**
* Heart rate in beats per minute.
* Set to 0 when status is SensorStatus::UNRELIABLE or
* SensorStatus::NO_CONTACT
*/
float bpm;
/** Status of the heart rate sensor for this reading. */
SensorStatus status;
};
@export(name="")
enum MetaDataEventType : uint32_t {
META_DATA_FLUSH_COMPLETE = 1,
};
struct MetaData {
MetaDataEventType what;
};
struct DynamicSensorInfo {
bool connected;
int32_t sensorHandle;
/**
* UUID of a dynamic sensor (using RFC 4122 byte order)
* For UUID 12345678-90AB-CDEF-1122-334455667788 the uuid field is
* initialized as:
* {0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0x11, ...}
*/
uint8_t[16] uuid;
};
@export(name="additional_info_type_t")
enum AdditionalInfoType : uint32_t {
/** Marks the beginning of additional information frames */
AINFO_BEGIN = 0,
/** Marks the end of additional information frames */
AINFO_END = 1,
/**
* Estimation of the delay that is not tracked by sensor timestamps. This
* includes delay introduced by sensor front-end filtering, data transport,
* etc.
* float[2]: delay in seconds, standard deviation of estimated value
*/
AINFO_UNTRACKED_DELAY = 0x10000,
/** float: Celsius temperature */
AINFO_INTERNAL_TEMPERATURE,
/**
* First three rows of a homogeneous matrix, which represents calibration to
* a three-element vector raw sensor reading.
* float[12]: 3x4 matrix in row major order
*/
AINFO_VEC3_CALIBRATION,
/**
* Location and orientation of sensor element in the device frame: origin is
* the geometric center of the mobile device screen surface; the axis
* definition corresponds to Android sensor definitions.
* float[12]: 3x4 matrix in row major order
*/
AINFO_SENSOR_PLACEMENT,
/**
* float[2]: raw sample period in seconds,
* standard deviation of sampling period
*/
AINFO_SAMPLING,
// Sampling channel modeling information section
/**
* int32_t: noise type
* float[n]: parameters
*/
AINFO_CHANNEL_NOISE = 0x20000,
/**
* float[3]: sample period, standard deviation of sample period,
* quantization unit
*/
AINFO_CHANNEL_SAMPLER,
/**
* Represents a filter:
* \sum_j a_j y[n-j] == \sum_i b_i x[n-i]
*
* int32_t[3]: number of feedforward coeffients M,
* number of feedback coefficients N (for FIR filter, N = 1).
* bit mask that represents which element the filter is applied
* to. (bit 0==1 means this filter applies to vector element 0).
* float[M+N]: filter coefficients (b0, b1, ..., b_{M-1}), then
* (a0, a1, ..., a_{N-1}), a0 is always 1.
*
* Multiple frames may be needed for higher number of taps.
*/
AINFO_CHANNEL_FILTER,
/**
* int32_t[2]: size in (row, column) ... 1st frame
* float[n]: matrix element values in row major order.
*/
AINFO_CHANNEL_LINEAR_TRANSFORM,
/**
* int32_t[2]: extrapolate method, interpolate method
* float[n]: mapping key points in pairs, (in, out)...
* (may be used to model saturation).
*/
AINFO_CHANNEL_NONLINEAR_MAP,
/**
* int32_t: resample method (0-th order, 1st order...)
* float[1]: resample ratio (upsampling if < 1.0, downsampling if > 1.0).
*/
AINFO_CHANNEL_RESAMPLER,
/**
* Operation environment parameters section
* Types in the following section is sent down (instead of reported from)
* device as additional information to aid sensor operation. Data is sent
* via injectSensorData() function to sensor handle -1 denoting all sensors
* in device.
*/
/**
* Local geomagnetic field information based on device geo location. This
* type is primarily for for magnetic field calibration and rotation vector
* sensor fusion.
* float[3]: strength (uT), declination and inclination angle (rad).
*/
AINFO_LOCAL_GEOMAGNETIC_FIELD = 0x30000,
/**
* Local gravitational acceleration strength at device geo location.
* float: gravitational acceleration norm in m/s^2.
*/
AINFO_LOCAL_GRAVITY,
/**
* Device dock state.
* int32_t: dock state following Android API Intent.EXTRA_DOCK_STATE
* definition, undefined value is ignored.
*/
AINFO_DOCK_STATE,
/**
* High performance mode hint. Device is able to use up more power and take
* more reources to improve throughput and latency in high performance mode.
* One possible use case is virtual reality, when sensor latency need to be
* carefully controlled.
* int32_t: 1 or 0, denote if device is in/out of high performance mode,
* other values is ignored.
*/
AINFO_HIGH_PERFORMANCE_MODE,
/**
* Magnetic field calibration hint. Device is notified when manually
* triggered magnetic field calibration procedure is started or stopped. The
* calibration procedure is assumed timed out after 1 minute from start,
* even if an explicit stop is not received.
*
* int32_t: 1 for start, 0 for stop, other value is ignored.
*/
AINFO_MAGNETIC_FIELD_CALIBRATION,
/** Custom information */
AINFO_CUSTOM_START = 0x10000000,
/** Debugging */
AINFO_DEBUGGING_START = 0x40000000,
};
struct AdditionalInfo {
/** type of payload data, see AdditionalInfoType */
AdditionalInfoType type;
/** sequence number of this frame for this type */
int32_t serial;
union Payload {
int32_t[14] data_int32;
float[14] data_float;
} u;
};
/* acceleration values are in meter per second per second (m/s^2)
* magnetic vector values are in micro-Tesla (uT)
* orientation values are in degrees
* gyroscope values are in rad/s
* temperature is in degrees centigrade (Celsius)
* distance in centimeters
* light in SI lux units
* pressure in hectopascal (hPa)
* relative humidity in percent
*/
union EventPayload {
/**
* SensorType::ACCELEROMETER, SensorType::MAGNETIC_FIELD,
* SensorType::ORIENTATION, SensorType::GYROSCOPE, SensorType::GRAVITY,
* SensorType::LINEAR_ACCELERATION
*/
Vec3 vec3;
/**
* SensorType::ROTATION_VECTOR, SensorType::GAME_ROTATION_VECTOR,
* SensorType::GEOMAGNETIC_ROTATION_VECTOR
*/
Vec4 vec4;
/**
* SensorType::MAGNETIC_FIELD_UNCALIBRATED,
* SensorType::GYROSCOPE_UNCALIBRATED
* SensorType::ACCELEROMETER_UNCALIBRATED
*/
Uncal uncal;
/** SensorType::META_DATA */
MetaData meta;
/**
* SensorType::DEVICE_ORIENTATION, SensorType::LIGHT, SensorType::PRESSURE,
* SensorType::TEMPERATURE, SensorType::PROXIMITY,
* SensorType::RELATIVE_HUMIDITY, SensorType::AMBIENT_TEMPERATURE,
* SensorType::SIGNIFICANT_MOTION, SensorType::STEP_DETECTOR,
* SensorType::TILT_DETECTOR, SensorType::WAKE_GESTURE,
* SensorType::GLANCE_GESTURE, SensorType::PICK_UP_GESTURE,
* SensorType::WRIST_TILT_GESTURE, SensorType::STATIONARY_DETECT,
* SensorType::MOTION_DETECT, SensorType::HEART_BEAT,
* SensorType::LOW_LATENCY_OFFBODY_DETECT
*/
float scalar;
/** SensorType::STEP_COUNTER */
uint64_t stepCount;
/** SensorType::HEART_RATE */
HeartRate heartRate;
/** SensorType::POSE_6DOF */
float[15] pose6DOF;
/** SensorType::DYNAMIC_SENSOR_META */
DynamicSensorInfo dynamic;
/** SensorType::ADDITIONAL_INFO */
AdditionalInfo additional;
/** undefined/custom sensor type >= SensorType::DEVICE_PRIVATE_BASE */
float[16] data;
};
struct Event {
/** Time measured in nanoseconds, in "elapsedRealtimeNano()'s" timebase. */
int64_t timestamp;
/** sensor identifier */
int32_t sensorHandle;
SensorType sensorType;
/** Union discriminated on sensorType */
EventPayload u;
};
/**
* Direct report rate level definition. Except for SENSOR_DIRECT_RATE_STOP, each
* rate level covers the range (55%, 220%] * nominal report rate. For example,
* if config direct report specify a rate level SENSOR_DIRECT_RATE_FAST, it is
* legal for sensor hardware to report event at a rate greater than 110Hz, and
* less or equal to 440Hz. Note that rate has to remain steady without variation
* before new rate level is configured, i.e. if a sensor is configured to
* SENSOR_DIRECT_RATE_FAST and starts to report event at 256Hz, it cannot
* change rate to 128Hz after a few seconds of running even if 128Hz is also in
* the legal range of SENSOR_DIRECT_RATE_FAST. Thus, it is recommended to
* associate report rate with RateLvel statically for single sensor.
*/
@export(name="direct_rate_level_t", value_prefix="SENSOR_DIRECT_RATE_")
enum RateLevel : int32_t {
STOP, // stop
NORMAL, // nominal 50Hz
FAST, // nominal 200Hz
VERY_FAST, // nominal 800Hz
};
/**
* Direct channel shared memory types. See struct SharedMemInfo.
*/
@export(name="direct_mem_type_t", value_prefix="SENSOR_DIRECT_MEM_TYPE_")
enum SharedMemType : int32_t {
// handle contains 1 fd (ashmem handle) and 0 int.
ASHMEM = 1,
// handle definition matches gralloc HAL.
GRALLOC
};
/**
* Direct channel lock-free queue format, this defines how the shared memory is
* interpreted by both sensor hardware and application.
*
* @see SharedMemInfo.
*/
@export(name="direct_format_t", value_prefix="SENSOR_DIRECT_FMT_")
enum SharedMemFormat : int32_t {
SENSORS_EVENT = 1, // shared memory is formated as an array of data
// elements. See SensorsEventFormatOffset for details.
// Upon return of channel registration call, the
// shared memory space must be formated to all 0 by HAL.
};
enum SensorsEventFormatOffset : uint16_t {
// offset type name
//-----------------------------------
// 0x0000 int32_t size (always 104)
// 0x0004 int32_t sensor report token
// 0x0008 int32_t type (see SensorType)
// 0x000C uint32_t atomic counter
// 0x0010 int64_t timestamp (see Event)
// 0x0018 float[16]/ data
// int64_t[8]
// 0x0058 int32_t[4] reserved (set to zero)
SIZE_FIELD = 0x0,
REPORT_TOKEN = 0x4,
SENSOR_TYPE = 0x8,
ATOMIC_COUNTER = 0xC,
TIMESTAMP = 0x10,
DATA = 0x18,
RESERVED = 0x58,
TOTAL_LENGTH = 0x68
};
/**
* Shared memory information for a direct channel
*/
struct SharedMemInfo {
SharedMemType type; // shared memory type
SharedMemFormat format;
uint32_t size; // size of the memory region, in bytes
handle memoryHandle; // shared memory handle, it is interpreted
// depending on type field, see SharedMemType.
};