auto import from //depot/cupcake/@135843
diff --git a/include/hardware/copybit.h b/include/hardware/copybit.h
new file mode 100644
index 0000000..7774cd2
--- /dev/null
+++ b/include/hardware/copybit.h
@@ -0,0 +1,216 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+#ifndef ANDROID_COPYBIT_INTERFACE_H
+#define ANDROID_COPYBIT_INTERFACE_H
+
+#include <hardware/hardware.h>
+
+#include <stdint.h>
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+__BEGIN_DECLS
+
+/**
+ * The id of this module
+ */
+#define COPYBIT_HARDWARE_MODULE_ID "copybit"
+
+/**
+ * Name of the graphics device to open
+ */
+#define COPYBIT_HARDWARE_COPYBIT0 "copybit0"
+
+/* supported pixel-formats. these must be compatible with
+ * graphics/PixelFormat.java, ui/PixelFormat.h, pixelflinger/format.h
+ */
+enum {
+ COPYBIT_FORMAT_RGBA_8888 = HAL_PIXEL_FORMAT_RGBA_8888,
+ COPYBIT_FORMAT_RGB_565 = HAL_PIXEL_FORMAT_RGB_565,
+ COPYBIT_FORMAT_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888,
+ COPYBIT_FORMAT_RGBA_5551 = HAL_PIXEL_FORMAT_RGBA_5551,
+ COPYBIT_FORMAT_RGBA_4444 = HAL_PIXEL_FORMAT_RGBA_4444,
+ COPYBIT_FORMAT_YCbCr_422_SP = HAL_PIXEL_FORMAT_YCbCr_422_SP,
+ COPYBIT_FORMAT_YCbCr_420_SP = HAL_PIXEL_FORMAT_YCbCr_420_SP,
+};
+
+/* name for copybit_set_parameter */
+enum {
+ /* rotation of the source image in degrees (0 to 359) */
+ COPYBIT_ROTATION_DEG = 1,
+ /* plane alpha value */
+ COPYBIT_PLANE_ALPHA = 2,
+ /* enable or disable dithering */
+ COPYBIT_DITHER = 3,
+ /* transformation applied (this is a superset of COPYBIT_ROTATION_DEG) */
+ COPYBIT_TRANSFORM = 4,
+};
+
+/* values for copybit_set_parameter(COPYBIT_TRANSFORM) */
+enum {
+ /* flip source image horizontally */
+ COPYBIT_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H,
+ /* flip source image vertically */
+ COPYBIT_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V,
+ /* rotate source image 90 degres */
+ COPYBIT_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90,
+ /* rotate source image 180 degres */
+ COPYBIT_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180,
+ /* rotate source image 270 degres */
+ COPYBIT_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270,
+};
+
+/* enable/disable value copybit_set_parameter */
+enum {
+ COPYBIT_DISABLE = 0,
+ COPYBIT_ENABLE = 1
+};
+
+/* use get_static_info() to query static informations about the hardware */
+enum {
+ /* Maximum amount of minification supported by the hardware*/
+ COPYBIT_MINIFICATION_LIMIT = 1,
+ /* Maximum amount of magnification supported by the hardware */
+ COPYBIT_MAGNIFICATION_LIMIT = 2,
+ /* Number of fractional bits support by the scaling engine */
+ COPYBIT_SCALING_FRAC_BITS = 3,
+ /* Supported rotation step in degres. */
+ COPYBIT_ROTATION_STEP_DEG = 4,
+};
+
+/* Image structure */
+struct copybit_image_t {
+ /* width */
+ uint32_t w;
+ /* height */
+ uint32_t h;
+ /* format COPYBIT_FORMAT_xxx */
+ int32_t format;
+ /* offset from base to first pixel */
+ uint32_t offset;
+ /* base of buffer with image */
+ void *base;
+ /* file descriptor for image */
+ int fd;
+};
+
+/* Rectangle */
+struct copybit_rect_t {
+ /* left */
+ int l;
+ /* top */
+ int t;
+ /* right */
+ int r;
+ /* bottom */
+ int b;
+};
+
+/* Region */
+struct copybit_region_t {
+ int (*next)(struct copybit_region_t const *region, struct copybit_rect_t *rect);
+};
+
+/**
+ * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
+ * and the fields of this data structure must begin with hw_module_t
+ * followed by module specific information.
+ */
+struct copybit_module_t {
+ struct hw_module_t common;
+};
+
+/**
+ * Every device data structure must begin with hw_device_t
+ * followed by module specific public methods and attributes.
+ */
+struct copybit_device_t {
+ struct hw_device_t common;
+
+ /**
+ * Set a copybit parameter.
+ *
+ * @param dev from open
+ * @param name one for the COPYBIT_NAME_xxx
+ * @param value one of the COPYBIT_VALUE_xxx
+ *
+ * @return 0 if successful
+ */
+ int (*set_parameter)(struct copybit_device_t *dev, int name, int value);
+
+ /**
+ * Get a static copybit information.
+ *
+ * @param dev from open
+ * @param name one of the COPYBIT_STATIC_xxx
+ *
+ * @return value or -EINVAL if error
+ */
+ int (*get)(struct copybit_device_t *dev, int name);
+
+ /**
+ * Execute the bit blit copy operation
+ *
+ * @param dev from open
+ * @param dst is the destination image
+ * @param src is the source image
+ * @param region the clip region
+ *
+ * @return 0 if successful
+ */
+ int (*blit)(struct copybit_device_t *dev,
+ struct copybit_image_t const *dst,
+ struct copybit_image_t const *src,
+ struct copybit_region_t const *region);
+
+ /**
+ * Execute the stretch bit blit copy operation
+ *
+ * @param dev from open
+ * @param dst is the destination image
+ * @param src is the source image
+ * @param dst_rect is the destination rectangle
+ * @param src_rect is the source rectangle
+ * @param region the clip region
+ *
+ * @return 0 if successful
+ */
+ int (*stretch)(struct copybit_device_t *dev,
+ struct copybit_image_t const *dst,
+ struct copybit_image_t const *src,
+ struct copybit_rect_t const *dst_rect,
+ struct copybit_rect_t const *src_rect,
+ struct copybit_region_t const *region);
+};
+
+
+/** convenience API for opening and closing a device */
+
+static inline int copybit_open(const struct hw_module_t* module,
+ struct copybit_device_t** device) {
+ return module->methods->open(module,
+ COPYBIT_HARDWARE_COPYBIT0, (struct hw_device_t**)device);
+}
+
+static inline int copybit_close(struct copybit_device_t* device) {
+ return device->common.close(&device->common);
+}
+
+
+__END_DECLS
+
+#endif // ANDROID_COPYBIT_INTERFACE_H
diff --git a/include/hardware/hardware.h b/include/hardware/hardware.h
new file mode 100644
index 0000000..5325744
--- /dev/null
+++ b/include/hardware/hardware.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+#ifndef ANDROID_INCLUDE_HARDWARE_HARDWARE_H
+#define ANDROID_INCLUDE_HARDWARE_HARDWARE_H
+
+#include <stdint.h>
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
+
+/*
+ * Value for the hw_module_t.tag field
+ */
+#define HARDWARE_MODULE_TAG 'HWMT'
+#define HARDWARE_DEVICE_TAG 'HWDT'
+
+struct hw_module_t;
+struct hw_module_methods_t;
+struct hw_device_t;
+
+/**
+ * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
+ * and the fields of this data structure must begin with hw_module_t
+ * followed by module specific information.
+ */
+struct hw_module_t {
+ /** tag must be initialized to HARDWARE_MODULE_TAG */
+ uint32_t tag;
+
+ /** major version number for the module */
+ uint16_t version_major;
+
+ /** minor version number of the module */
+ uint16_t version_minor;
+
+ /** Identifier of module */
+ const char *id;
+
+ /** Name of this module */
+ const char *name;
+
+ /** Author/owner/implementor of the module */
+ const char *author;
+
+ /** Modules methods */
+ struct hw_module_methods_t* methods;
+
+ /** padding to 128 bytes, reserved for future use */
+ uint32_t reserved[32-6];
+};
+
+struct hw_module_methods_t {
+ /** Open a specific device */
+ int (*open)(const struct hw_module_t* module, const char* id,
+ struct hw_device_t** device);
+};
+
+/**
+ * Every device data structure must begin with hw_device_t
+ * followed by module specific public methods and attributes.
+ */
+struct hw_device_t {
+ /** tag must be initialized to HARDWARE_DEVICE_TAG */
+ uint32_t tag;
+
+ /** version number for hw_device_t */
+ uint32_t version;
+
+ /** reference to the module this device belongs to */
+ struct hw_module_t* module;
+
+ /** padding reserved for future use */
+ uint32_t reserved[12];
+
+ /** Close this device */
+ int (*close)(struct hw_device_t* device);
+};
+
+/**
+ * Name of the hal_module_info
+ */
+#define HAL_MODULE_INFO_SYM HMI
+
+/**
+ * Name of the hal_module_info as a string
+ */
+#define HAL_MODULE_INFO_SYM_AS_STR "HMI"
+
+/**
+ * Get the module info associated with a module by id.
+ * @return: 0 == success, <0 == error and *pHmi == NULL
+ */
+int hw_get_module(const char *id, const struct hw_module_t **module);
+
+
+/**
+ * pixel format definitions
+ */
+
+enum {
+ HAL_PIXEL_FORMAT_RGBA_8888 = 1,
+ HAL_PIXEL_FORMAT_RGB_565 = 4,
+ HAL_PIXEL_FORMAT_BGRA_8888 = 5,
+ HAL_PIXEL_FORMAT_RGBA_5551 = 6,
+ HAL_PIXEL_FORMAT_RGBA_4444 = 7,
+ HAL_PIXEL_FORMAT_YCbCr_422_SP = 0x10,
+ HAL_PIXEL_FORMAT_YCbCr_420_SP = 0x11,
+ HAL_PIXEL_FORMAT_YCbCr_422_P = 0x12,
+ HAL_PIXEL_FORMAT_YCbCr_420_P = 0x13,
+ HAL_PIXEL_FORMAT_YCbCr_422_I = 0x14,
+ HAL_PIXEL_FORMAT_YCbCr_420_I = 0x15
+};
+
+
+/**
+ * Transformation definitions
+ */
+
+enum {
+ /* flip source image horizontally */
+ HAL_TRANSFORM_FLIP_H = 0x01,
+ /* flip source image vertically */
+ HAL_TRANSFORM_FLIP_V = 0x02,
+ /* rotate source image 90 degres */
+ HAL_TRANSFORM_ROT_90 = 0x04,
+ /* rotate source image 180 degres */
+ HAL_TRANSFORM_ROT_180 = 0x03,
+ /* rotate source image 270 degres */
+ HAL_TRANSFORM_ROT_270 = 0x07,
+};
+
+__END_DECLS
+
+#endif /* ANDROID_INCLUDE_HARDWARE_HARDWARE_H */
diff --git a/include/hardware/overlay.h b/include/hardware/overlay.h
new file mode 100644
index 0000000..92992d1
--- /dev/null
+++ b/include/hardware/overlay.h
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+#ifndef ANDROID_OVERLAY_INTERFACE_H
+#define ANDROID_OVERLAY_INTERFACE_H
+
+#include <cutils/native_handle.h>
+
+#include <hardware/hardware.h>
+
+#include <stdint.h>
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+__BEGIN_DECLS
+
+/**
+ * The id of this module
+ */
+#define OVERLAY_HARDWARE_MODULE_ID "overlay"
+
+/**
+ * Name of the overlay device to open
+ */
+#define OVERLAY_HARDWARE_CONTROL "control"
+#define OVERLAY_HARDWARE_DATA "data"
+
+/*****************************************************************************/
+
+/* possible overlay formats */
+enum {
+ OVERLAY_FORMAT_RGBA_8888 = HAL_PIXEL_FORMAT_RGBA_8888,
+ OVERLAY_FORMAT_RGB_565 = HAL_PIXEL_FORMAT_RGB_565,
+ OVERLAY_FORMAT_BGRA_8888 = HAL_PIXEL_FORMAT_BGRA_8888,
+ OVERLAY_FORMAT_YCbCr_422_I = HAL_PIXEL_FORMAT_YCbCr_422_I,
+ OVERLAY_FORMAT_YCbCr_420_I = HAL_PIXEL_FORMAT_YCbCr_420_I
+};
+
+/* values for copybit_set_parameter(OVERLAY_TRANSFORM) */
+enum {
+ /* flip source image horizontally */
+ OVERLAY_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_V,
+ /* flip source image vertically */
+ OVERLAY_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_H,
+ /* rotate source image 90 degrees */
+ OVERLAY_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90,
+ /* rotate source image 180 degrees */
+ OVERLAY_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180,
+ /* rotate source image 270 degrees */
+ OVERLAY_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270
+};
+
+/* names for setParameter() */
+enum {
+ /* rotation of the source image in degrees (0 to 359) */
+ OVERLAY_ROTATION_DEG = 1,
+ /* enable or disable dithering */
+ OVERLAY_DITHER = 3,
+ /* transformation applied (this is a superset of COPYBIT_ROTATION_DEG) */
+ OVERLAY_TRANSFORM = 4,
+};
+
+/* enable/disable value setParameter() */
+enum {
+ OVERLAY_DISABLE = 0,
+ OVERLAY_ENABLE = 1
+};
+
+/* names for get() */
+enum {
+ /* Maximum amount of minification supported by the hardware*/
+ OVERLAY_MINIFICATION_LIMIT = 1,
+ /* Maximum amount of magnification supported by the hardware */
+ OVERLAY_MAGNIFICATION_LIMIT = 2,
+ /* Number of fractional bits support by the overlay scaling engine */
+ OVERLAY_SCALING_FRAC_BITS = 3,
+ /* Supported rotation step in degrees. */
+ OVERLAY_ROTATION_STEP_DEG = 4,
+ /* horizontal alignment in pixels */
+ OVERLAY_HORIZONTAL_ALIGNMENT = 5,
+ /* vertical alignment in pixels */
+ OVERLAY_VERTICAL_ALIGNMENT = 6,
+ /* width alignment restrictions. negative number for max. power-of-two */
+ OVERLAY_WIDTH_ALIGNMENT = 7,
+ /* height alignment restrictions. negative number for max. power-of-two */
+ OVERLAY_HEIGHT_ALIGNMENT = 8,
+};
+
+/*****************************************************************************/
+
+/* opaque reference to an Overlay kernel object */
+typedef const native_handle* overlay_handle_t;
+
+typedef struct overlay_t {
+ uint32_t w;
+ uint32_t h;
+ int32_t format;
+ uint32_t w_stride;
+ uint32_t h_stride;
+ uint32_t reserved[3];
+ /* returns a reference to this overlay's handle (the caller doesn't
+ * take ownership) */
+ overlay_handle_t (*getHandleRef)(struct overlay_t* overlay);
+ uint32_t reserved_procs[7];
+} overlay_t;
+
+typedef void* overlay_buffer_t;
+
+/*****************************************************************************/
+
+/**
+ * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
+ * and the fields of this data structure must begin with hw_module_t
+ * followed by module specific information.
+ */
+struct overlay_module_t {
+ struct hw_module_t common;
+};
+
+/*****************************************************************************/
+
+/**
+ * Every device data structure must begin with hw_device_t
+ * followed by module specific public methods and attributes.
+ */
+
+struct overlay_control_device_t {
+ struct hw_device_t common;
+
+ /* get static informations about the capabilities of the overlay engine */
+ int (*get)(struct overlay_control_device_t *dev, int name);
+
+ /* creates an overlay matching the given parameters as closely as possible.
+ * returns an error if no more overlays are available. The actual
+ * size and format is returned in overlay_t. */
+ overlay_t* (*createOverlay)(struct overlay_control_device_t *dev,
+ uint32_t w, uint32_t h, int32_t format);
+
+ /* destroys an overlay. This call releases all
+ * resources associated with overlay_t and make it invalid */
+ void (*destroyOverlay)(struct overlay_control_device_t *dev,
+ overlay_t* overlay);
+
+ /* set position and scaling of the given overlay as closely as possible.
+ * if scaling cannot be performed, overlay must be centered. */
+ int (*setPosition)(struct overlay_control_device_t *dev,
+ overlay_t* overlay,
+ int x, int y, uint32_t w, uint32_t h);
+
+ /* returns the actual position and size of the overlay */
+ int (*getPosition)(struct overlay_control_device_t *dev,
+ overlay_t* overlay,
+ int* x, int* y, uint32_t* w, uint32_t* h);
+
+ /* sets configurable parameters for this overlay. returns an error if not
+ * supported. */
+ int (*setParameter)(struct overlay_control_device_t *dev,
+ overlay_t* overlay, int param, int value);
+};
+
+
+struct overlay_data_device_t {
+ struct hw_device_t common;
+
+ /* initialize the overlay from the given handle. this associates this
+ * overlay data module to its control module */
+ int (*initialize)(struct overlay_data_device_t *dev,
+ overlay_handle_t handle);
+
+ /* blocks until an overlay buffer is available and return that buffer. */
+ int (*dequeueBuffer)(struct overlay_data_device_t *dev,
+ overlay_buffer_t *buf);
+
+ /* release the overlay buffer and post it */
+ int (*queueBuffer)(struct overlay_data_device_t *dev,
+ overlay_buffer_t buffer);
+
+ /* returns the address of a given buffer if supported, NULL otherwise. */
+ void* (*getBufferAddress)(struct overlay_data_device_t *dev,
+ overlay_buffer_t buffer);
+
+ int (*getBufferCount)(struct overlay_data_device_t *dev);
+};
+
+
+/*****************************************************************************/
+
+/** convenience API for opening and closing a device */
+
+static inline int overlay_control_open(const struct hw_module_t* module,
+ struct overlay_control_device_t** device) {
+ return module->methods->open(module,
+ OVERLAY_HARDWARE_CONTROL, (struct hw_device_t**)device);
+}
+
+static inline int overlay_control_close(struct overlay_control_device_t* device) {
+ return device->common.close(&device->common);
+}
+
+static inline int overlay_data_open(const struct hw_module_t* module,
+ struct overlay_data_device_t** device) {
+ return module->methods->open(module,
+ OVERLAY_HARDWARE_DATA, (struct hw_device_t**)device);
+}
+
+static inline int overlay_data_close(struct overlay_data_device_t* device) {
+ return device->common.close(&device->common);
+}
+
+__END_DECLS
+
+#endif // ANDROID_OVERLAY_INTERFACE_H
diff --git a/include/hardware/sensors.h b/include/hardware/sensors.h
new file mode 100644
index 0000000..094b3ee
--- /dev/null
+++ b/include/hardware/sensors.h
@@ -0,0 +1,375 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+#ifndef ANDROID_SENSORS_INTERFACE_H
+#define ANDROID_SENSORS_INTERFACE_H
+
+#include <stdint.h>
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+#include <hardware/hardware.h>
+
+__BEGIN_DECLS
+
+/**
+ * The id of this module
+ */
+#define SENSORS_HARDWARE_MODULE_ID "sensors"
+
+/**
+ * Name of the sensors device to open
+ */
+#define SENSORS_HARDWARE_CONTROL "control"
+#define SENSORS_HARDWARE_DATA "data"
+
+/**
+ * Handles must be higher than SENSORS_HANDLE_BASE and must be unique.
+ * A Handle identifies a given sensors. The handle is used to activate
+ * and/or deactivate sensors.
+ * In this version of the API there can only be 256 handles.
+ */
+#define SENSORS_HANDLE_BASE 0
+#define SENSORS_HANDLE_BITS 8
+#define SENSORS_HANDLE_COUNT (1<<SENSORS_HANDLE_BITS)
+
+
+/**
+ * Sensor types
+ */
+#define SENSOR_TYPE_ACCELEROMETER 1
+#define SENSOR_TYPE_MAGNETIC_FIELD 2
+#define SENSOR_TYPE_ORIENTATION 3
+#define SENSOR_TYPE_GYROSCOPE 4
+#define SENSOR_TYPE_LIGHT 5
+#define SENSOR_TYPE_PRESSURE 6
+#define SENSOR_TYPE_TEMPERATURE 7
+#define SENSOR_TYPE_PROXIMITY 8
+
+/**
+ * Values returned by the accelerometer in various locations in the universe.
+ * all values are in SI units (m/s^2)
+ */
+
+#define GRAVITY_SUN (275.0f)
+#define GRAVITY_MERCURY (3.70f)
+#define GRAVITY_VENUS (8.87f)
+#define GRAVITY_EARTH (9.80665f)
+#define GRAVITY_MOON (1.6f)
+#define GRAVITY_MARS (3.71f)
+#define GRAVITY_JUPITER (23.12f)
+#define GRAVITY_SATURN (8.96f)
+#define GRAVITY_URANUS (8.69f)
+#define GRAVITY_NEPTUNE (11.0f)
+#define GRAVITY_PLUTO (0.6f)
+#define GRAVITY_DEATH_STAR_I (0.000000353036145f)
+#define GRAVITY_THE_ISLAND (4.815162342f)
+
+/** Maximum magnetic field on Earth's surface */
+#define MAGNETIC_FIELD_EARTH_MAX (60.0f)
+
+/** Minimum magnetic field on Earth's surface */
+#define MAGNETIC_FIELD_EARTH_MIN (30.0f)
+
+
+/**
+ * status of each sensor
+ */
+
+#define SENSOR_STATUS_UNRELIABLE 0
+#define SENSOR_STATUS_ACCURACY_LOW 1
+#define SENSOR_STATUS_ACCURACY_MEDIUM 2
+#define SENSOR_STATUS_ACCURACY_HIGH 3
+
+/**
+ * Definition of the axis
+ * ----------------------
+ *
+ * This API is relative to the screen of the device in its default orientation,
+ * that is, if the device can be used in portrait or landscape, this API
+ * is only relative to the NATURAL orientation of the screen. In other words,
+ * the axis are not swapped when the device's screen orientation changes.
+ * Higher level services /may/ perform this transformation.
+ *
+ * x<0 x>0
+ * ^
+ * |
+ * +-----------+--> y>0
+ * | |
+ * | |
+ * | |
+ * | | / z<0
+ * | | /
+ * | | /
+ * O-----------+/
+ * |[] [ ] []/
+ * +----------/+ y<0
+ * /
+ * /
+ * |/ z>0 (toward the sky)
+ *
+ * O: Origin (x=0,y=0,z=0)
+ *
+ *
+ * Orientation
+ * -----------
+ *
+ * All values are angles in degrees.
+ *
+ * azimuth: angle between the magnetic north direction and the Y axis, around
+ * the Z axis (0<=azimuth<360).
+ * 0=North, 90=East, 180=South, 270=West
+ *
+ * pitch: Rotation around X axis (-180<=pitch<=180), with positive values when
+ * the z-axis moves toward the y-axis.
+ *
+ * roll: Rotation around Y axis (-90<=roll<=90), with positive values when
+ * the z-axis moves AWAY from the x-axis.
+ *
+ * Note: This definition is different from yaw, pitch and roll used in aviation
+ * where the X axis is along the long side of the plane (tail to nose).
+ *
+ *
+ * Acceleration
+ * ------------
+ *
+ * All values are in SI units (m/s^2) and measure the acceleration of the
+ * device minus the force of gravity.
+ *
+ * x: Acceleration minus Gx on the x-axis
+ * y: Acceleration minus Gy on the y-axis
+ * z: Acceleration minus Gz on the z-axis
+ *
+ * Examples:
+ * When the device lies flat on a table and is pushed on its left side
+ * toward the right, the x acceleration value is positive.
+ *
+ * When the device lies flat on a table, the acceleration value is +9.81,
+ * which correspond to the acceleration of the device (0 m/s^2) minus the
+ * force of gravity (-9.81 m/s^2).
+ *
+ * When the device lies flat on a table and is pushed toward the sky, the
+ * acceleration value is greater than +9.81, which correspond to the
+ * acceleration of the device (+A m/s^2) minus the force of
+ * gravity (-9.81 m/s^2).
+ *
+ *
+ * Magnetic Field
+ * --------------
+ *
+ * All values are in micro-Tesla (uT) and measure the ambient magnetic
+ * field in the X, Y and Z axis.
+ *
+ */
+typedef struct {
+ union {
+ float v[3];
+ struct {
+ float x;
+ float y;
+ float z;
+ };
+ struct {
+ float azimuth;
+ float pitch;
+ float roll;
+ };
+ };
+ int8_t status;
+ uint8_t reserved[3];
+} sensors_vec_t;
+
+/**
+ * Union of the various types of sensor data
+ * that can be returned.
+ */
+typedef struct {
+ /* sensor identifier */
+ int sensor;
+
+ union {
+ /* x,y,z values of the given sensor */
+ sensors_vec_t vector;
+
+ /* orientation values are in degrees */
+ sensors_vec_t orientation;
+
+ /* acceleration values are in meter per second per second (m/s^2) */
+ sensors_vec_t acceleration;
+
+ /* magnetic vector values are in micro-Tesla (uT) */
+ sensors_vec_t magnetic;
+
+ /* temperature is in degrees centigrade (Celsius) */
+ float temperature;
+ };
+
+ /* time is in nanosecond */
+ int64_t time;
+
+ uint32_t reserved;
+} sensors_data_t;
+
+
+struct sensor_t;
+
+/**
+ * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
+ * and the fields of this data structure must begin with hw_module_t
+ * followed by module specific information.
+ */
+struct sensors_module_t {
+ struct hw_module_t common;
+
+ /**
+ * Enumerate all available sensors. The list is returned in "list".
+ * @return number of sensors in the list
+ */
+ int (*get_sensors_list)(struct sensors_module_t* module,
+ struct sensor_t const** list);
+};
+
+struct sensor_t {
+ /* name of this sensors */
+ const char* name;
+ /* vendor of the hardware part */
+ const char* vendor;
+ /* version of the hardware part + driver. The value of this field is
+ * left to the implementation and doesn't have to be monotonicaly
+ * increasing.
+ */
+ int version;
+ /* handle that identifies this sensors. This handle is used to activate
+ * and deactivate this sensor. The value of the handle must be 8 bits
+ * in this version of the API.
+ */
+ int handle;
+ /* this sensor's type. */
+ int type;
+ /* maximaum 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;
+ /* reserved fields, must be zero */
+ void* reserved[9];
+};
+
+
+/**
+ * Every device data structure must begin with hw_device_t
+ * followed by module specific public methods and attributes.
+ */
+struct sensors_control_device_t {
+ struct hw_device_t common;
+
+ /**
+ * Returns the fd which will be the parameter to
+ * sensors_data_device_t::open_data().
+ * The caller takes ownership of this fd. This is intended to be
+ * passed cross processes.
+ *
+ * @return a fd if successful, < 0 on error
+ */
+ int (*open_data_source)(struct sensors_control_device_t *dev);
+
+ /** Activate/deactivate one sensor.
+ *
+ * @param handle is the handle of the sensor to change.
+ * @param enabled set to 1 to enable, or 0 to disable the sensor.
+ *
+ * @return 0 on success, negative errno code otherwise
+ */
+ int (*activate)(struct sensors_control_device_t *dev,
+ int handle, int enabled);
+
+ /**
+ * Set the delay between sensor events in ms
+ *
+ * @return 0 if successful, < 0 on error
+ */
+ int (*set_delay)(struct sensors_control_device_t *dev, int32_t ms);
+
+ /**
+ * Causes sensors_data_device_t.poll() to return -EWOULDBLOCK immediately.
+ */
+ int (*wake)(struct sensors_control_device_t *dev);
+};
+
+struct sensors_data_device_t {
+ struct hw_device_t common;
+
+ /**
+ * Prepare to read sensor data.
+ *
+ * This routine does NOT take ownership of the fd
+ * and must not close it. Typically this routine would
+ * use a duplicate of the fd parameter.
+ *
+ * @param fd from sensors_control_open.
+ *
+ * @return 0 if successful, < 0 on error
+ */
+ int (*data_open)(struct sensors_data_device_t *dev, int fd);
+
+ /**
+ * Caller has completed using the sensor data.
+ * The caller will not be blocked in sensors_data_poll
+ * when this routine is called.
+ *
+ * @return 0 if successful, < 0 on error
+ */
+ int (*data_close)(struct sensors_data_device_t *dev);
+
+ /**
+ * Return sensor data for one of the enabled sensors.
+ *
+ * @return sensor handle for the returned data, 0x7FFFFFFF when
+ * sensors_control_device_t.wake() is called and -errno on error
+ *
+ */
+ int (*poll)(struct sensors_data_device_t *dev,
+ sensors_data_t* data);
+};
+
+
+/** convenience API for opening and closing a device */
+
+static inline int sensors_control_open(const struct hw_module_t* module,
+ struct sensors_control_device_t** device) {
+ return module->methods->open(module,
+ SENSORS_HARDWARE_CONTROL, (struct hw_device_t**)device);
+}
+
+static inline int sensors_control_close(struct sensors_control_device_t* device) {
+ return device->common.close(&device->common);
+}
+
+static inline int sensors_data_open(const struct hw_module_t* module,
+ struct sensors_data_device_t** device) {
+ return module->methods->open(module,
+ SENSORS_HARDWARE_DATA, (struct hw_device_t**)device);
+}
+
+static inline int sensors_data_close(struct sensors_data_device_t* device) {
+ return device->common.close(&device->common);
+}
+
+
+__END_DECLS
+
+#endif // ANDROID_SENSORS_INTERFACE_H