1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_SENSORS_INTERFACE_H 18 #define ANDROID_SENSORS_INTERFACE_H 19 20 #include <stdint.h> 21 #include <sys/cdefs.h> 22 #include <sys/types.h> 23 24 #include <hardware/hardware.h> 25 #include <cutils/native_handle.h> 26 27 #include "sensors-base.h" 28 29 __BEGIN_DECLS 30 31 /*****************************************************************************/ 32 33 #define SENSORS_HEADER_VERSION 1 34 #define SENSORS_MODULE_API_VERSION_0_1 HARDWARE_MODULE_API_VERSION(0, 1) 35 #define SENSORS_DEVICE_API_VERSION_0_1 HARDWARE_DEVICE_API_VERSION_2(0, 1, SENSORS_HEADER_VERSION) 36 #define SENSORS_DEVICE_API_VERSION_1_0 HARDWARE_DEVICE_API_VERSION_2(1, 0, SENSORS_HEADER_VERSION) 37 #define SENSORS_DEVICE_API_VERSION_1_1 HARDWARE_DEVICE_API_VERSION_2(1, 1, SENSORS_HEADER_VERSION) 38 #define SENSORS_DEVICE_API_VERSION_1_2 HARDWARE_DEVICE_API_VERSION_2(1, 2, SENSORS_HEADER_VERSION) 39 #define SENSORS_DEVICE_API_VERSION_1_3 HARDWARE_DEVICE_API_VERSION_2(1, 3, SENSORS_HEADER_VERSION) 40 #define SENSORS_DEVICE_API_VERSION_1_4 HARDWARE_DEVICE_API_VERSION_2(1, 4, SENSORS_HEADER_VERSION) 41 42 /** 43 * Please see the Sensors section of source.android.com for an 44 * introduction to and detailed descriptions of Android sensor types: 45 * http://source.android.com/devices/sensors/index.html 46 */ 47 48 /** 49 * The id of this module 50 */ 51 #define SENSORS_HARDWARE_MODULE_ID "sensors" 52 53 /** 54 * Name of the sensors device to open 55 */ 56 #define SENSORS_HARDWARE_POLL "poll" 57 58 /** 59 * Sensor handle is greater than 0 and less than INT32_MAX. 60 * 61 * **** Deprecated **** 62 * Defined values below are kept for code compatibility. Note sensor handle can be as large as 63 * INT32_MAX. 64 */ 65 #define SENSORS_HANDLE_BASE 0 66 #define SENSORS_HANDLE_BITS 31 67 #define SENSORS_HANDLE_COUNT (1ull<<SENSORS_HANDLE_BITS) 68 69 70 /* 71 * **** Deprecated ***** 72 * flags for (*batch)() 73 * Availability: SENSORS_DEVICE_API_VERSION_1_0 74 * see (*batch)() documentation for details. 75 * Deprecated as of SENSORS_DEVICE_API_VERSION_1_3. 76 * WAKE_UP_* sensors replace WAKE_UPON_FIFO_FULL concept. 77 */ 78 enum { 79 SENSORS_BATCH_DRY_RUN = 0x00000001, 80 SENSORS_BATCH_WAKE_UPON_FIFO_FULL = 0x00000002 81 }; 82 83 /* 84 * what field for meta_data_event_t 85 */ 86 enum { 87 /* a previous flush operation has completed */ 88 // META_DATA_FLUSH_COMPLETE = 1, 89 META_DATA_VERSION /* always last, leave auto-assigned */ 90 }; 91 92 /* 93 * The permission to use for body sensors (like heart rate monitors). 94 * See sensor types for more details on what sensors should require this 95 * permission. 96 */ 97 #define SENSOR_PERMISSION_BODY_SENSORS "android.permission.BODY_SENSORS" 98 99 /* 100 * sensor flags legacy names 101 * 102 * please use SENSOR_FLAG_* directly for new implementation. 103 * @see sensor_t 104 */ 105 106 #define SENSOR_FLAG_MASK(nbit, shift) (((1<<(nbit))-1)<<(shift)) 107 #define SENSOR_FLAG_MASK_1(shift) SENSOR_FLAG_MASK(1, shift) 108 109 /* 110 * Mask and shift for reporting mode sensor flags defined above. 111 */ 112 #define REPORTING_MODE_SHIFT SENSOR_FLAG_SHIFT_REPORTING_MODE 113 #define REPORTING_MODE_NBIT (3) 114 #define REPORTING_MODE_MASK SENSOR_FLAG_MASK_REPORTING_MODE 115 116 /* 117 * Mask and shift for data_injection mode sensor flags defined above. 118 */ 119 #define DATA_INJECTION_SHIFT SENSOR_FLAG_SHIFT_DATA_INJECTION 120 #define DATA_INJECTION_MASK SENSOR_FLAG_DATA_INJECTION 121 122 /* 123 * Mask and shift for dynamic sensor flag. 124 */ 125 #define DYNAMIC_SENSOR_SHIFT SENSOR_FLAG_SHIFT_DYNAMIC_SENSOR 126 #define DYNAMIC_SENSOR_MASK SENSOR_FLAG_DYNAMIC_SENSOR 127 128 /* 129 * Mask and shift for sensor additional information support. 130 */ 131 #define ADDITIONAL_INFO_SHIFT SENSOR_FLAG_SHIFT_ADDITIONAL_INFO 132 #define ADDITIONAL_INFO_MASK SENSOR_FLAG_ADDITIONAL_INFO 133 134 /* 135 * Legacy alias of SENSOR_TYPE_MAGNETIC_FIELD. 136 * 137 * Previously, the type of a sensor measuring local magnetic field is named 138 * SENSOR_TYPE_GEOMAGNETIC_FIELD and SENSOR_TYPE_MAGNETIC_FIELD is its alias. 139 * SENSOR_TYPE_MAGNETIC_FIELD is redefined as primary name to avoid confusion. 140 * SENSOR_TYPE_GEOMAGNETIC_FIELD is the alias and is deprecating. New implementation must not use 141 * SENSOR_TYPE_GEOMAGNETIC_FIELD. 142 */ 143 #define SENSOR_TYPE_GEOMAGNETIC_FIELD SENSOR_TYPE_MAGNETIC_FIELD 144 145 /* 146 * Sensor string types for Android defined sensor types. 147 * 148 * For Android defined sensor types, string type will be override in sensor service and thus no 149 * longer needed to be added to sensor_t data structure. 150 * 151 * These definitions are going to be removed soon. 152 */ 153 #define SENSOR_STRING_TYPE_ACCELEROMETER "android.sensor.accelerometer" 154 #define SENSOR_STRING_TYPE_MAGNETIC_FIELD "android.sensor.magnetic_field" 155 #define SENSOR_STRING_TYPE_ORIENTATION "android.sensor.orientation" 156 #define SENSOR_STRING_TYPE_GYROSCOPE "android.sensor.gyroscope" 157 #define SENSOR_STRING_TYPE_LIGHT "android.sensor.light" 158 #define SENSOR_STRING_TYPE_PRESSURE "android.sensor.pressure" 159 #define SENSOR_STRING_TYPE_TEMPERATURE "android.sensor.temperature" 160 #define SENSOR_STRING_TYPE_PROXIMITY "android.sensor.proximity" 161 #define SENSOR_STRING_TYPE_GRAVITY "android.sensor.gravity" 162 #define SENSOR_STRING_TYPE_LINEAR_ACCELERATION "android.sensor.linear_acceleration" 163 #define SENSOR_STRING_TYPE_ROTATION_VECTOR "android.sensor.rotation_vector" 164 #define SENSOR_STRING_TYPE_RELATIVE_HUMIDITY "android.sensor.relative_humidity" 165 #define SENSOR_STRING_TYPE_AMBIENT_TEMPERATURE "android.sensor.ambient_temperature" 166 #define SENSOR_STRING_TYPE_MAGNETIC_FIELD_UNCALIBRATED "android.sensor.magnetic_field_uncalibrated" 167 #define SENSOR_STRING_TYPE_GAME_ROTATION_VECTOR "android.sensor.game_rotation_vector" 168 #define SENSOR_STRING_TYPE_GYROSCOPE_UNCALIBRATED "android.sensor.gyroscope_uncalibrated" 169 #define SENSOR_STRING_TYPE_SIGNIFICANT_MOTION "android.sensor.significant_motion" 170 #define SENSOR_STRING_TYPE_STEP_DETECTOR "android.sensor.step_detector" 171 #define SENSOR_STRING_TYPE_STEP_COUNTER "android.sensor.step_counter" 172 #define SENSOR_STRING_TYPE_GEOMAGNETIC_ROTATION_VECTOR "android.sensor.geomagnetic_rotation_vector" 173 #define SENSOR_STRING_TYPE_HEART_RATE "android.sensor.heart_rate" 174 #define SENSOR_STRING_TYPE_TILT_DETECTOR "android.sensor.tilt_detector" 175 #define SENSOR_STRING_TYPE_WAKE_GESTURE "android.sensor.wake_gesture" 176 #define SENSOR_STRING_TYPE_GLANCE_GESTURE "android.sensor.glance_gesture" 177 #define SENSOR_STRING_TYPE_PICK_UP_GESTURE "android.sensor.pick_up_gesture" 178 #define SENSOR_STRING_TYPE_WRIST_TILT_GESTURE "android.sensor.wrist_tilt_gesture" 179 #define SENSOR_STRING_TYPE_DEVICE_ORIENTATION "android.sensor.device_orientation" 180 #define SENSOR_STRING_TYPE_POSE_6DOF "android.sensor.pose_6dof" 181 #define SENSOR_STRING_TYPE_STATIONARY_DETECT "android.sensor.stationary_detect" 182 #define SENSOR_STRING_TYPE_MOTION_DETECT "android.sensor.motion_detect" 183 #define SENSOR_STRING_TYPE_HEART_BEAT "android.sensor.heart_beat" 184 #define SENSOR_STRING_TYPE_DYNAMIC_SENSOR_META "android.sensor.dynamic_sensor_meta" 185 #define SENSOR_STRING_TYPE_ADDITIONAL_INFO "android.sensor.additional_info" 186 #define SENSOR_STRING_TYPE_LOW_LATENCY_OFFBODY_DETECT "android.sensor.low_latency_offbody_detect" 187 #define SENSOR_STRING_TYPE_ACCELEROMETER_UNCALIBRATED "android.sensor.accelerometer_uncalibrated" 188 189 /** 190 * Values returned by the accelerometer in various locations in the universe. 191 * all values are in SI units (m/s^2) 192 */ 193 #define GRAVITY_SUN (275.0f) 194 #define GRAVITY_EARTH (9.80665f) 195 196 /** Maximum magnetic field on Earth's surface */ 197 #define MAGNETIC_FIELD_EARTH_MAX (60.0f) 198 199 /** Minimum magnetic field on Earth's surface */ 200 #define MAGNETIC_FIELD_EARTH_MIN (30.0f) 201 202 struct sensor_t; 203 204 /** 205 * sensor event data 206 */ 207 typedef struct { 208 union { 209 float v[3]; 210 struct { 211 float x; 212 float y; 213 float z; 214 }; 215 struct { 216 float azimuth; 217 float pitch; 218 float roll; 219 }; 220 }; 221 int8_t status; 222 uint8_t reserved[3]; 223 } sensors_vec_t; 224 225 /** 226 * uncalibrated accelerometer, gyroscope and magnetometer event data 227 */ 228 typedef struct { 229 union { 230 float uncalib[3]; 231 struct { 232 float x_uncalib; 233 float y_uncalib; 234 float z_uncalib; 235 }; 236 }; 237 union { 238 float bias[3]; 239 struct { 240 float x_bias; 241 float y_bias; 242 float z_bias; 243 }; 244 }; 245 } uncalibrated_event_t; 246 247 /** 248 * Meta data event data 249 */ 250 typedef struct meta_data_event { 251 int32_t what; 252 int32_t sensor; 253 } meta_data_event_t; 254 255 /** 256 * Dynamic sensor meta event. See the description of SENSOR_TYPE_DYNAMIC_SENSOR_META type for 257 * details. 258 */ 259 typedef struct dynamic_sensor_meta_event { 260 int32_t connected; 261 int32_t handle; 262 const struct sensor_t * sensor; // should be NULL if connected == false 263 uint8_t uuid[16]; // UUID of a dynamic sensor (using RFC 4122 byte order) 264 // For UUID 12345678-90AB-CDEF-1122-334455667788 the uuid field 265 // should be initialized as: 266 // {0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0x11, ...} 267 } dynamic_sensor_meta_event_t; 268 269 /** 270 * Heart rate event data 271 */ 272 typedef struct { 273 // Heart rate in beats per minute. 274 // Set to 0 when status is SENSOR_STATUS_UNRELIABLE or ..._NO_CONTACT 275 float bpm; 276 // Status of the sensor for this reading. Set to one SENSOR_STATUS_... 277 // Note that this value should only be set for sensors that explicitly define 278 // the meaning of this field. This field is not piped through the framework 279 // for other sensors. 280 int8_t status; 281 } heart_rate_event_t; 282 283 typedef struct { 284 int32_t type; // type of payload data, see additional_info_type_t 285 int32_t serial; // sequence number of this frame for this type 286 union { 287 // for each frame, a single data type, either int32_t or float, should be used. 288 int32_t data_int32[14]; 289 float data_float[14]; 290 }; 291 } additional_info_event_t; 292 293 /** 294 * Union of the various types of sensor data 295 * that can be returned. 296 */ 297 typedef struct sensors_event_t { 298 /* must be sizeof(struct sensors_event_t) */ 299 int32_t version; 300 301 /* sensor identifier */ 302 int32_t sensor; 303 304 /* sensor type */ 305 int32_t type; 306 307 /* reserved */ 308 int32_t reserved0; 309 310 /* time is in nanosecond */ 311 int64_t timestamp; 312 313 union { 314 union { 315 float data[16]; 316 317 /* acceleration values are in meter per second per second (m/s^2) */ 318 sensors_vec_t acceleration; 319 320 /* magnetic vector values are in micro-Tesla (uT) */ 321 sensors_vec_t magnetic; 322 323 /* orientation values are in degrees */ 324 sensors_vec_t orientation; 325 326 /* gyroscope values are in rad/s */ 327 sensors_vec_t gyro; 328 329 /* temperature is in degrees centigrade (Celsius) */ 330 float temperature; 331 332 /* distance in centimeters */ 333 float distance; 334 335 /* light in SI lux units */ 336 float light; 337 338 /* pressure in hectopascal (hPa) */ 339 float pressure; 340 341 /* relative humidity in percent */ 342 float relative_humidity; 343 344 /* uncalibrated gyroscope values are in rad/s */ 345 uncalibrated_event_t uncalibrated_gyro; 346 347 /* uncalibrated magnetometer values are in micro-Teslas */ 348 uncalibrated_event_t uncalibrated_magnetic; 349 350 /* uncalibrated accelerometer values are in meter per second per second (m/s^2) */ 351 uncalibrated_event_t uncalibrated_accelerometer; 352 353 /* heart rate data containing value in bpm and status */ 354 heart_rate_event_t heart_rate; 355 356 /* this is a special event. see SENSOR_TYPE_META_DATA above. 357 * sensors_meta_data_event_t events are all reported with a type of 358 * SENSOR_TYPE_META_DATA. The handle is ignored and must be zero. 359 */ 360 meta_data_event_t meta_data; 361 362 /* dynamic sensor meta event. See SENSOR_TYPE_DYNAMIC_SENSOR_META type for details */ 363 dynamic_sensor_meta_event_t dynamic_sensor_meta; 364 365 /* 366 * special additional sensor information frame, see 367 * SENSOR_TYPE_ADDITIONAL_INFO for details. 368 */ 369 additional_info_event_t additional_info; 370 }; 371 372 union { 373 uint64_t data[8]; 374 375 /* step-counter */ 376 uint64_t step_counter; 377 } u64; 378 }; 379 380 /* Reserved flags for internal use. Set to zero. */ 381 uint32_t flags; 382 383 uint32_t reserved1[3]; 384 } sensors_event_t; 385 386 387 /* see SENSOR_TYPE_META_DATA */ 388 typedef sensors_event_t sensors_meta_data_event_t; 389 390 391 /** 392 * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM 393 * and the fields of this data structure must begin with hw_module_t 394 * followed by module specific information. 395 */ 396 struct sensors_module_t { 397 struct hw_module_t common; 398 399 /** 400 * Enumerate all available sensors. The list is returned in "list". 401 * return number of sensors in the list 402 */ 403 int (*get_sensors_list)(struct sensors_module_t* module, 404 struct sensor_t const** list); 405 406 /** 407 * Place the module in a specific mode. The following modes are defined 408 * 409 * 0 - Normal operation. Default state of the module. 410 * 1 - Loopback mode. Data is injected for the supported 411 * sensors by the sensor service in this mode. 412 * return 0 on success 413 * -EINVAL if requested mode is not supported 414 * -EPERM if operation is not allowed 415 */ 416 int (*set_operation_mode)(unsigned int mode); 417 }; 418 419 struct sensor_t { 420 421 /* Name of this sensor. 422 * All sensors of the same "type" must have a different "name". 423 */ 424 const char* name; 425 426 /* vendor of the hardware part */ 427 const char* vendor; 428 429 /* version of the hardware part + driver. The value of this field 430 * must increase when the driver is updated in a way that changes the 431 * output of this sensor. This is important for fused sensors when the 432 * fusion algorithm is updated. 433 */ 434 int version; 435 436 /* handle that identifies this sensors. This handle is used to reference 437 * this sensor throughout the HAL API. 438 */ 439 int handle; 440 441 /* this sensor's type. */ 442 int type; 443 444 /* maximum range of this sensor's value in SI units */ 445 float maxRange; 446 447 /* smallest difference between two values reported by this sensor */ 448 float resolution; 449 450 /* rough estimate of this sensor's power consumption in mA */ 451 float power; 452 453 /* this value depends on the reporting mode: 454 * 455 * continuous: minimum sample period allowed in microseconds 456 * on-change : 0 457 * one-shot :-1 458 * special : 0, unless otherwise noted 459 */ 460 int32_t minDelay; 461 462 /* number of events reserved for this sensor in the batch mode FIFO. 463 * If there is a dedicated FIFO for this sensor, then this is the 464 * size of this FIFO. If the FIFO is shared with other sensors, 465 * this is the size reserved for that sensor and it can be zero. 466 */ 467 uint32_t fifoReservedEventCount; 468 469 /* maximum number of events of this sensor that could be batched. 470 * This is especially relevant when the FIFO is shared between 471 * several sensors; this value is then set to the size of that FIFO. 472 */ 473 uint32_t fifoMaxEventCount; 474 475 /* type of this sensor as a string. 476 * 477 * If type is OEM specific or sensor manufacturer specific type 478 * (>=SENSOR_TYPE_DEVICE_PRIVATE_BASE), this string must be defined with reserved domain of 479 * vendor/OEM as a prefix, e.g. com.google.glass.onheaddetector 480 * 481 * For sensors of Android defined types, Android framework will override this value. It is ok to 482 * leave it pointing to an empty string. 483 */ 484 const char* stringType; 485 486 /* permission required to see this sensor, register to it and receive data. 487 * Set to "" if no permission is required. Some sensor types like the 488 * heart rate monitor have a mandatory require_permission. 489 * For sensors that always require a specific permission, like the heart 490 * rate monitor, the android framework might overwrite this string 491 * automatically. 492 */ 493 const char* requiredPermission; 494 495 /* This value is defined only for continuous mode and on-change sensors. It is the delay between 496 * two sensor events corresponding to the lowest frequency that this sensor supports. When lower 497 * frequencies are requested through batch()/setDelay() the events will be generated at this 498 * frequency instead. It can be used by the framework or applications to estimate when the batch 499 * FIFO may be full. 500 * 501 * NOTE: 1) period_ns is in nanoseconds where as maxDelay/minDelay are in microseconds. 502 * continuous, on-change: maximum sampling period allowed in microseconds. 503 * one-shot, special : 0 504 * 2) maxDelay should always fit within a 32 bit signed integer. It is declared as 64 bit 505 * on 64 bit architectures only for binary compatibility reasons. 506 * Availability: SENSORS_DEVICE_API_VERSION_1_3 507 */ 508 #ifdef __LP64__ 509 int64_t maxDelay; 510 #else 511 int32_t maxDelay; 512 #endif 513 514 /* Flags for sensor. See SENSOR_FLAG_* above. Only the least significant 32 bits are used here. 515 * It is declared as 64 bit on 64 bit architectures only for binary compatibility reasons. 516 * Availability: SENSORS_DEVICE_API_VERSION_1_3 517 */ 518 #ifdef __LP64__ 519 uint64_t flags; 520 #else 521 uint32_t flags; 522 #endif 523 524 /* reserved fields, must be zero */ 525 void* reserved[2]; 526 }; 527 528 /** 529 * Shared memory information for a direct channel 530 */ 531 struct sensors_direct_mem_t { 532 int type; // enum SENSOR_DIRECT_MEM_... 533 int format; // enum SENSOR_DIRECT_FMT_... 534 size_t size; // size of the memory region, in bytes 535 const struct native_handle *handle; // shared memory handle, which is interpreted differently 536 // depending on type 537 }; 538 539 /** 540 * Direct channel report configuration 541 */ 542 struct sensors_direct_cfg_t { 543 int rate_level; // enum SENSOR_DIRECT_RATE_... 544 }; 545 546 /* 547 * sensors_poll_device_t is used with SENSORS_DEVICE_API_VERSION_0_1 548 * and is present for backward binary and source compatibility. 549 * See the Sensors HAL interface section for complete descriptions of the 550 * following functions: 551 * http://source.android.com/devices/sensors/index.html#hal 552 */ 553 struct sensors_poll_device_t { 554 struct hw_device_t common; 555 int (*activate)(struct sensors_poll_device_t *dev, 556 int sensor_handle, int enabled); 557 int (*setDelay)(struct sensors_poll_device_t *dev, 558 int sensor_handle, int64_t sampling_period_ns); 559 int (*poll)(struct sensors_poll_device_t *dev, 560 sensors_event_t* data, int count); 561 }; 562 563 /* 564 * struct sensors_poll_device_1 is used in HAL versions >= SENSORS_DEVICE_API_VERSION_1_0 565 */ 566 typedef struct sensors_poll_device_1 { 567 union { 568 /* sensors_poll_device_1 is compatible with sensors_poll_device_t, 569 * and can be down-cast to it 570 */ 571 struct sensors_poll_device_t v0; 572 573 struct { 574 struct hw_device_t common; 575 576 /* Activate/de-activate one sensor. 577 * 578 * sensor_handle is the handle of the sensor to change. 579 * enabled set to 1 to enable, or 0 to disable the sensor. 580 * 581 * Before sensor activation, existing sensor events that have not 582 * been picked up by poll() should be abandoned so that application 583 * upon new activation request will not get stale events. 584 * (events that are generated during latter activation or during 585 * data injection mode after sensor deactivation) 586 * 587 * Return 0 on success, negative errno code otherwise. 588 */ 589 int (*activate)(struct sensors_poll_device_t *dev, 590 int sensor_handle, int enabled); 591 592 /** 593 * Set the events's period in nanoseconds for a given sensor. 594 * If sampling_period_ns > max_delay it will be truncated to 595 * max_delay and if sampling_period_ns < min_delay it will be 596 * replaced by min_delay. 597 */ 598 int (*setDelay)(struct sensors_poll_device_t *dev, 599 int sensor_handle, int64_t sampling_period_ns); 600 601 /** 602 * Write an array of sensor_event_t to data. The size of the 603 * available buffer is specified by count. Returns number of 604 * valid sensor_event_t. 605 * 606 * This function should block if there is no sensor event 607 * available when being called. Thus, return value should always be 608 * positive. 609 */ 610 int (*poll)(struct sensors_poll_device_t *dev, 611 sensors_event_t* data, int count); 612 }; 613 }; 614 615 616 /* 617 * Sets a sensors parameters, including sampling frequency and maximum 618 * report latency. This function can be called while the sensor is 619 * activated, in which case it must not cause any sensor measurements to 620 * be lost: transitioning from one sampling rate to the other cannot cause 621 * lost events, nor can transitioning from a high maximum report latency to 622 * a low maximum report latency. 623 * See the Batching sensor results page for details: 624 * http://source.android.com/devices/sensors/batching.html 625 */ 626 int (*batch)(struct sensors_poll_device_1* dev, 627 int sensor_handle, int flags, int64_t sampling_period_ns, 628 int64_t max_report_latency_ns); 629 630 /* 631 * Flush adds a META_DATA_FLUSH_COMPLETE event (sensors_event_meta_data_t) 632 * to the end of the "batch mode" FIFO for the specified sensor and flushes 633 * the FIFO. 634 * If the FIFO is empty or if the sensor doesn't support batching (FIFO size zero), 635 * it should return SUCCESS along with a trivial META_DATA_FLUSH_COMPLETE event added to the 636 * event stream. This applies to all sensors other than one-shot sensors. 637 * If the sensor is a one-shot sensor, flush must return -EINVAL and not generate 638 * any flush complete metadata. 639 * If the sensor is not active at the time flush() is called, flush() should return 640 * -EINVAL. 641 */ 642 int (*flush)(struct sensors_poll_device_1* dev, int sensor_handle); 643 644 /* 645 * Inject a single sensor sample to be to this device. 646 * data points to the sensor event to be injected 647 * return 0 on success 648 * -EPERM if operation is not allowed 649 * -EINVAL if sensor event cannot be injected 650 */ 651 int (*inject_sensor_data)(struct sensors_poll_device_1 *dev, const sensors_event_t *data); 652 653 /* 654 * Register/unregister direct report channel. 655 * 656 * A HAL declares support for direct report by setting non-NULL values for both 657 * register_direct_channel and config_direct_report. 658 * 659 * This function has two operation modes: 660 * 661 * Register: mem != NULL, register a channel using supplied shared memory information. By the 662 * time this function returns, sensors must finish initializing shared memory content 663 * (format dependent, see SENSOR_DIRECT_FMT_*). 664 * Parameters: 665 * mem points to a valid struct sensors_direct_mem_t. 666 * channel_handle is ignored. 667 * Return value: 668 * A handle of channel (>0, <INT32_MAX) when success, which later can be referred in 669 * unregister or config_direct_report call, or error code (<0) when failed 670 * Unregister: mem == NULL, unregister a previously registered channel. 671 * Parameters: 672 * mem set to NULL 673 * channel_handle contains handle of channel to be unregistered 674 * Return value: 675 * 0, even if the channel_handle is invalid, in which case it will be a no-op. 676 */ 677 int (*register_direct_channel)(struct sensors_poll_device_1 *dev, 678 const struct sensors_direct_mem_t* mem, int channel_handle); 679 680 /* 681 * Configure direct sensor event report in direct channel. 682 * 683 * Start, modify rate or stop direct report of a sensor in a certain direct channel. A special 684 * case is setting sensor handle -1 to stop means to stop all active sensor report on the 685 * channel specified. 686 * 687 * A HAL declares support for direct report by setting non-NULL values for both 688 * register_direct_channel and config_direct_report. 689 * 690 * Parameters: 691 * sensor_handle sensor to be configured. The sensor has to support direct report 692 * mode by setting flags of sensor_t. Also, direct report mode is only 693 * defined for continuous reporting mode sensors. 694 * channel_handle channel handle to be configured. 695 * config direct report parameters, see sensor_direct_cfg_t. 696 * Return value: 697 * - when sensor is started or sensor rate level is changed: return positive identifier of 698 * sensor in specified channel if successful, otherwise return negative error code. 699 * - when sensor is stopped: return 0 for success or negative error code for failure. 700 */ 701 int (*config_direct_report)(struct sensors_poll_device_1 *dev, 702 int sensor_handle, int channel_handle, const struct sensors_direct_cfg_t *config); 703 704 /* 705 * Reserved for future use, must be zero. 706 */ 707 void (*reserved_procs[5])(void); 708 709 } sensors_poll_device_1_t; 710 711 712 /** convenience API for opening and closing a device */ 713 714 static inline int sensors_open(const struct hw_module_t* module, 715 struct sensors_poll_device_t** device) { 716 return module->methods->open(module, 717 SENSORS_HARDWARE_POLL, TO_HW_DEVICE_T_OPEN(device)); 718 } 719 720 static inline int sensors_close(struct sensors_poll_device_t* device) { 721 return device->common.close(&device->common); 722 } 723 724 static inline int sensors_open_1(const struct hw_module_t* module, 725 sensors_poll_device_1_t** device) { 726 return module->methods->open(module, 727 SENSORS_HARDWARE_POLL, TO_HW_DEVICE_T_OPEN(device)); 728 } 729 730 static inline int sensors_close_1(sensors_poll_device_1_t* device) { 731 return device->common.close(&device->common); 732 } 733 734 __END_DECLS 735 736 #endif // ANDROID_SENSORS_INTERFACE_H 737
