Add Sensors HAL 2.1 (d8cafdbd) · Commits · e / os / android_hardware_interfaces

current.txt

+3 −0

Original line number	Diff line number	Diff line
		@@ -693,6 +693,9 @@ dcc8872337f0135e81970e1d8d5fd7139160dc80e9be76f0ae05290fa7e472b8 android.hardwar
		a2977755bc5f1ef47f04b7f2400632efda6218e1515dba847da487145cfabc4f android.hardware.radio.config@1.3::IRadioConfig
		742360c775313438b0f82256eac62fb5bbc76a6ae6f388573f3aa142fb2c1eea android.hardware.radio.config@1.3::IRadioConfigIndication
		0006ab8e8b0910cbd3bbb08d5f17d5fac7d65a2bdad5f2334e4851db9d1e6fa8 android.hardware.radio.config@1.3::IRadioConfigResponse
		3ca6616381080bdd6c08141ad12775a94ae868c58b02b1274ae3326f7de724ab android.hardware.sensors@2.1::ISensors
		3d4141c6373cd9ca02fe221a7d12343840de2255d032c38248fe8e35816b58b2 android.hardware.sensors@2.1::ISensorsCallback
		8051cc50fc90ed447f058a8b15d81f35a65f1bd9004b1de4f127edeb89b47978 android.hardware.sensors@2.1::types
		4a6517ea4ad807855428b0101d8e1a486497bd88ab4300ba3b2be43d46d32580 android.hardware.soundtrigger@2.3::types
		12d7533ff0754f45bf59ab300799074570a99a676545652c2c23abc73cb4515d android.hardware.soundtrigger@2.3::ISoundTriggerHw
		7746fda1fbf9c7c132bae701cc5a161309e4f5e7f3e8065811045975ee86196d android.hardware.usb.gadget@1.1::IUsbGadget

sensors/2.1/Android.bp

0 → 100644

+21 −0

Original line number	Diff line number	Diff line
		// This file is autogenerated by hidl-gen -Landroidbp.

		hidl_interface {
		name: "android.hardware.sensors@2.1",
		root: "android.hardware",
		vndk: {
		enabled: true,
		},
		srcs: [
		"types.hal",
		"ISensors.hal",
		"ISensorsCallback.hal",
		],
		interfaces: [
		"android.hardware.sensors@1.0",
		"android.hardware.sensors@2.0",
		"android.hidl.base@1.0",
		],
		gen_java: false,
		gen_java_constants: true,
		}

sensors/2.1/ISensors.hal

0 → 100644

+148 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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@2.1;

		import @1.0::Result;
		import @2.0::ISensors;
		import @2.1::ISensorsCallback;

		interface ISensors extends @2.0::ISensors {
		/**
		* Enumerate all available (static) sensors.
		*
		* The SensorInfo for each sensor returned by getSensorsList must be stable
		* from the initial call to getSensorsList after a device boot until the
		* entire system restarts. The SensorInfo for each sensor must not change
		* between subsequent calls to getSensorsList, even across restarts of the
		* HAL and its dependencies (for example, the sensor handle for a given
		* sensor must not change across HAL restarts).
		*/
		getSensorsList_2_1() generates (vec<SensorInfo> list);

		/**
		* Initialize the Sensors HAL's Fast Message Queues (FMQ) and callback.
		*
		* The Fast Message Queues (FMQ) that are used to send data between the
		* framework and the HAL. The callback is used by the HAL to notify the
		* framework of asynchronous events, such as a dynamic sensor connection.
		*
		* The Event FMQ is used to transport sensor events from the HAL to the
		* framework. The Event FMQ is created using the eventQueueDescriptor.
		* Data may only be written to the Event FMQ. Data must not be read from
		* the Event FMQ since the framework is the only reader. Upon receiving
		* sensor events, the HAL writes the sensor events to the Event FMQ.
		*
		* Once the HAL is finished writing sensor events to the Event FMQ, the HAL
		* must notify the framework that sensor events are available to be read and
		* processed. This is accomplished by either:
		* 1) Calling the Event FMQ’s EventFlag::wake() function with
		EventQueueFlagBits::READ_AND_PROCESS
		* 2) Setting the write notification in the Event FMQ’s writeBlocking()
		* function to EventQueueFlagBits::READ_AND_PROCESS.
		*
		* If the Event FMQ’s writeBlocking() function is used, the read
		* notification must be set to EventQueueFlagBits::EVENTS_READ in order to
		* be notified and unblocked when the framework has successfully read events
		* from the Event FMQ.
		*
		* The Wake Lock FMQ is used by the framework to notify the HAL when it is
		* safe to release its wake_lock. When the framework receives WAKE_UP events
		* from the Event FMQ and the framework has acquired a wake_lock, the
		* framework must write the number of WAKE_UP events processed to the Wake
		* Lock FMQ. When the HAL reads the data from the Wake Lock FMQ, the HAL
		* decrements its current count of unprocessed WAKE_UP events and releases
		* its wake_lock if the current count of unprocessed WAKE_UP events is
		* zero. It is important to note that the HAL must acquire the wake lock and
		* update its internal state regarding the number of outstanding WAKE_UP
		* events _before_ posting the event to the Wake Lock FMQ, in order to avoid
		* a race condition that can lead to loss of wake lock synchronization with
		* the framework.
		*
		* The framework must use the WakeLockQueueFlagBits::DATA_WRITTEN value to
		* notify the HAL that data has been written to the Wake Lock FMQ and must
		* be read by HAL.
		*
		* The ISensorsCallback is used by the HAL to notify the framework of
		* asynchronous events, such as a dynamic sensor connection.
		*
		* The name of any wake_lock acquired by the Sensors HAL for WAKE_UP events
		* must begin with "SensorsHAL_WAKEUP".
		*
		* If WAKE_LOCK_TIMEOUT_SECONDS has elapsed since the most recent WAKE_UP
		* event was written to the Event FMQ without receiving a message on the
		* Wake Lock FMQ, then any held wake_lock for WAKE_UP events must be
		* released.
		*
		* If either the Event FMQ or the Wake Lock FMQ is already initialized when
		* initialize is invoked, then both existing FMQs must be discarded and the
		* new descriptors must be used to create new FMQs within the HAL. The
		* number of outstanding WAKE_UP events should also be reset to zero, and
		* any outstanding wake_locks held as a result of WAKE_UP events should be
		* released.
		*
		* All active sensor requests and direct channels must be closed and
		* properly cleaned up when initialize is called in order to ensure that the
		* HAL and framework's state is consistent (e.g. after a runtime restart).
		*
		* initialize must be thread safe and prevent concurrent calls
		* to initialize from simultaneously modifying state.
		*
		* @param eventQueueDescriptor Fast Message Queue descriptor that is used to
		* create the Event FMQ which is where sensor events are written. The
		* descriptor is obtained from the framework's FMQ that is used to read
		* sensor events.
		* @param wakeLockDescriptor Fast Message Queue descriptor that is used to
		* create the Wake Lock FMQ which is where wake_lock events are read
		* from. The descriptor is obtained from the framework's FMQ that is
		* used to write wake_lock events.
		* @param sensorsCallback sensors callback that receives asynchronous data
		* from the Sensors HAL.
		* @return result OK on success; BAD_VALUE if descriptor is invalid (such
		* as null)
		*/
		@entry
		@callflow(next = {"getSensorsList"})
		initialize_2_1(fmq_sync<Event> eventQueueDescriptor,
		fmq_sync<uint32_t> wakeLockDescriptor,
		ISensorsCallback sensorsCallback)
		generates
		(Result result);

		/**
		* Inject a single sensor event or push operation environment parameters to
		* device.
		*
		* When device is in NORMAL mode, this function is called to push operation
		* environment data to device. In this operation, Event is always of
		* SensorType::AdditionalInfo type. See operation evironment parameters
		* section in AdditionalInfoType.
		*
		* When device is in DATA_INJECTION mode, this function is also used for
		* injecting sensor events.
		*
		* Regardless of OperationMode, injected SensorType::ADDITIONAL_INFO
		* type events should not be routed back to the sensor event queue.
		*
		* @see AdditionalInfoType
		* @see OperationMode
		* @param event sensor event to be injected
		* @return result OK on success; PERMISSION_DENIED if operation is not
		* allowed; INVALID_OPERATION, if this functionality is unsupported;
		* BAD_VALUE if sensor event cannot be injected.
		*/
		injectSensorData_2_1(Event event) generates (Result result);
		};

sensors/2.1/ISensorsCallback.hal

0 → 100644

+33 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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@2.1;

		import @2.0::ISensorsCallback;
		import @2.1::SensorInfo;

		interface ISensorsCallback extends @2.0::ISensorsCallback {
		/**
		* Notify the framework that new dynamic sensors have been connected.
		*
		* If a dynamic sensor was previously connected and has not been
		* disconnected, then that sensor must not be included in sensorInfos.
		*
		* @param sensorInfos vector of SensorInfo for each dynamic sensor that
		* was connected.
		*/
		oneway onDynamicSensorsConnected_2_1(vec<SensorInfo> sensorInfos);
		};

sensors/2.1/types.hal

0 → 100644

+160 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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@2.1;

		import @1.0::EventPayload;
		import @1.0::SensorType;
		import @1.0::SensorFlagBits;

		@export(name="", value_prefix="SENSOR_TYPE_")
		enum SensorType : @1.0::SensorType {
		/**
		* HINGE_ANGLE
		* reporting-mode: on-change
		* wake-up sensor: yes
		*
		* A sensor of this type measures the angle, in degrees, between two
		* integral parts of the device. Movement of a hinge measured by this sensor
		* type is expected to alter the ways in which the user may interact with
		* the device, for example by unfolding or revealing a display.
		*
		* Sensor data is output using @1.0::EventPayload.scalar.
		*
		* Implement wake-up proximity sensor before implementing a non wake-up
		* proximity sensor.
		*/
		HINGE_ANGLE = 36,
		};

		struct Event {
		/** Time measured in nanoseconds, in "elapsedRealtimeNano()'s" timebase. */
		int64_t timestamp;

		/** sensor identifier */
		int32_t sensorHandle;

		@2.1::SensorType sensorType;

		/** Union discriminated on sensorType */
		EventPayload u;
		};

		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. */
		@2.1::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;
		};
		No newline at end of file