include/hal-sensor-types.h

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   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 __HAL_SENSOR_TYPES__
  18 #define __HAL_SENSOR_TYPES__
  19
  20 #include <stdbool.h>
  21 #include <stdint.h>
  22 #include <time.h>
  23
  24 #define SENSOR_HAL_VERSION(maj, min) ((((maj)&0xFFFF) << 24) | ((min)&0xFFFF))
  25
  26 #ifdef __cplusplus
  27 extern "C" {
  28 #endif /* __cplusplus */
  29
  30 /*
  31  * Sensor Types
  32  * These types are used to controll the sensors
  33  *
  34  * - base unit
  35  *   acceleration values : meter per second^2 (m/s^2)
  36  *   magnetic values     : micro-Tesla (uT)
  37  *   orientation values  : degrees
  38  *   gyroscope values    : degree/s
  39  *   temperature values  : degrees centigrade
  40  *   proximity valeus    : distance
  41  *   light values        : lux
  42  *   pressure values     : hectopascal (hPa)
  43  *   humidity            : relative humidity (%)
  44  */
  45 typedef enum {
  46   SENSOR_DEVICE_UNKNOWN = -2,
  47   SENSOR_DEVICE_ALL = -1,
  48   SENSOR_DEVICE_ACCELEROMETER,
  49   SENSOR_DEVICE_GRAVITY,
  50   SENSOR_DEVICE_LINEAR_ACCELERATION,
  51   SENSOR_DEVICE_GEOMAGNETIC,
  52   SENSOR_DEVICE_ROTATION_VECTOR,
  53   SENSOR_DEVICE_ORIENTATION,
  54   SENSOR_DEVICE_GYROSCOPE,
  55   SENSOR_DEVICE_LIGHT,
  56   SENSOR_DEVICE_PROXIMITY,
  57   SENSOR_DEVICE_PRESSURE,
  58   SENSOR_DEVICE_ULTRAVIOLET,
  59   SENSOR_DEVICE_TEMPERATURE,
  60   SENSOR_DEVICE_HUMIDITY,
  61   SENSOR_DEVICE_HRM,
  62   SENSOR_DEVICE_HRM_LED_GREEN,
  63   SENSOR_DEVICE_HRM_LED_IR,
  64   SENSOR_DEVICE_HRM_LED_RED,
  65   SENSOR_DEVICE_GYROSCOPE_UNCAL,
  66   SENSOR_DEVICE_GEOMAGNETIC_UNCAL,
  67   SENSOR_DEVICE_GYROSCOPE_RV,
  68   SENSOR_DEVICE_GEOMAGNETIC_RV,
  69
  70   SENSOR_DEVICE_SIGNIFICANT_MOTION = 0x100,
  71
  72   SENSOR_DEVICE_HRM_BATCH = 0x200,
  73   SENSOR_DEVICE_HRM_LED_GREEN_BATCH,
  74
  75   SENSOR_DEVICE_HUMAN_PEDOMETER = 0x300,
  76   SENSOR_DEVICE_HUMAN_SLEEP_MONITOR,
  77   SENSOR_DEVICE_HUMAN_SLEEP_DETECTOR,
  78   SENSOR_DEVICE_HUMAN_STRESS_MONITOR,
  79
  80   SENSOR_DEVICE_LIDAR = 1000,
  81
  82   SENSOR_DEVICE_EXERCISE_WALKING = 0x400,
  83   SENSOR_DEVICE_EXERCISE_RUNNING,
  84   SENSOR_DEVICE_EXERCISE_HIKING,
  85   SENSOR_DEVICE_EXERCISE_CYCLING,
  86   SENSOR_DEVICE_EXERCISE_ELLIPTICAL,
  87   SENSOR_DEVICE_EXERCISE_INDOOR_CYCLING,
  88   SENSOR_DEVICE_EXERCISE_ROWING,
  89   SENSOR_DEVICE_EXERCISE_STEPPER,
  90
  91   SENSOR_DEVICE_DATA_JOURNAL = 0x500,
  92   SENSOR_DEVICE_MOTION_SENSOR,
  93   SENSOR_DEVICE_FAKE,
  94   SENSOR_DEVICE_TAP_SENSOR,
  95   SENSOR_DEVICE_COLOR_SENSOR,
  96   SENSOR_DEVICE_WIFI_MOTION_DETECTOR,
  97
  98   SENSOR_DEVICE_FUSION = 0x900,
  99   SENSOR_DEVICE_AUTO_ROTATION,
 100   SENSOR_DEVICE_AUTO_BRIGHTNESS,
 101   SENSOR_DEVICE_MYOTEST,
 102
 103   SENSOR_DEVICE_GESTURE_MOVEMENT = 0x1200,
 104   SENSOR_DEVICE_GESTURE_WRIST_UP,
 105   SENSOR_DEVICE_GESTURE_WRIST_DOWN,
 106   SENSOR_DEVICE_GESTURE_MOVEMENT_STATE,
 107   SENSOR_DEVICE_GESTURE_PICK_UP,
 108   SENSOR_DEVICE_GESTURE_FACE_DOWN,
 109
 110   SENSOR_DEVICE_ACTIVITY_TRACKER = 0x1A00,
 111   SENSOR_DEVICE_ACTIVITY_LEVEL_MONITOR,
 112   SENSOR_DEVICE_GPS_BATCH,
 113   SENSOR_DEVICE_PPG_BATCH,
 114   SENSOR_DEVICE_GPS_TIMESYNC,
 115
 116   SENSOR_DEVICE_HRM_CTRL = 0x1A80,
 117   SENSOR_DEVICE_REG_CTRL,
 118   SENSOR_DEVICE_GPS_CTRL,
 119
 120   SENSOR_DEVICE_WEAR_STATUS = 0x2000,
 121   SENSOR_DEVICE_WEAR_ON_MONITOR,
 122   SENSOR_DEVICE_NO_MOVE_DETECTOR,
 123   SENSOR_DEVICE_RESTING_HR,
 124   SENSOR_DEVICE_STEP_LEVEL_MONITOR,
 125   SENSOR_DEVICE_EXERCISE_STANDALONE,
 126   SENSOR_DEVICE_EXERCISE_HR,
 127   SENSOR_DEVICE_WORKOUT,
 128   SENSOR_DEVICE_CYCLE_MONITOR,
 129   SENSOR_DEVICE_STAIR_TRACKER,
 130   SENSOR_DEVICE_PRESSURE_INDICATOR,
 131   SENSOR_DEVICE_PRESSURE_ALERT,
 132   SENSOR_DEVICE_HR_CALORIE,
 133   SENSOR_DEVICE_SWIMMING_TRACKER,
 134   SENSOR_DEVICE_STRESS_TRACKER,
 135   SENSOR_DEVICE_FAKE_MOTION,
 136   SENSOR_DEVICE_GEOFENCE,
 137   SENSOR_DEVICE_SWIMMING_OUTDOOR,
 138   SENSOR_DEVICE_AUTO_SWIMMING,
 139   SENSOR_DEVICE_INACTIVITY_DETECTOR,
 140   SENSOR_DEVICE_HRM_BP,
 141   SENSOR_DEVICE_ECG,
 142   SENSOR_DEVICE_FALL_DETECTION,
 143
 144   SENSOR_DEVICE_CONTEXT = 0x7000,
 145   SENSOR_DEVICE_MOTION,
 146   SENSOR_DEVICE_PIR,
 147   SENSOR_DEVICE_PIR_LONG,
 148   SENSOR_DEVICE_DUST,
 149   SENSOR_DEVICE_THERMOMETER,
 150   SENSOR_DEVICE_PEDOMETER,
 151   SENSOR_DEVICE_FLAT,
 152   SENSOR_DEVICE_HRM_RAW,
 153   SENSOR_DEVICE_TILT,
 154   SENSOR_DEVICE_ROTATION_VECTOR_RAW,
 155   SENSOR_DEVICE_GSR,
 156   SENSOR_DEVICE_SIMSENSE,
 157   SENSOR_DEVICE_PPG,
 158 } sensor_device_type;
 159
 160 /*
 161  * A platform sensor handler is generated based on this handle
 162  * This id can be assigned from HAL developer. so it has to be unique in 1
 163  * sensor_device.
 164  */
 165 typedef struct sensor_info_t {
 166   uint32_t id;
 167   const char *name;
 168   int type; // sensor_device_type
 169   unsigned int event_type;  // for Internal API
 170   const char *model_name;
 171   const char *vendor;
 172   float min_range;
 173   float max_range;
 174   float resolution;
 175   int min_interval;
 176   int max_interval;
 177   int max_batch_count;
 178   bool wakeup_supported;
 179 } sensor_info_t;
 180
 181 enum sensor_accuracy_t {
 182   SENSOR_ACCURACY_UNDEFINED = -1,
 183   SENSOR_ACCURACY_BAD = 0,
 184   SENSOR_ACCURACY_NORMAL = 1,
 185   SENSOR_ACCURACY_GOOD = 2,
 186   SENSOR_ACCURACY_VERYGOOD = 3
 187 };
 188
 189 #define SENSOR_DATA_VALUE_SIZE 16
 190
 191 /* sensor_data_t */
 192 typedef struct sensor_data_t {
 193   int accuracy;
 194   unsigned long long timestamp;
 195   int value_count;
 196   float values[SENSOR_DATA_VALUE_SIZE];
 197 } sensor_data_t;
 198
 199 #define SENSORHUB_DATA_VALUE_SIZE 4096
 200
 201 /* sensorhub_data_t */
 202 typedef struct sensorhub_data_t {
 203   int accuracy;
 204   unsigned long long timestamp;
 205
 206   /*
 207    *  Use "value_count" instead of "hub_data_size"
 208    *  which is going to be removed soon
 209    */
 210   union {
 211     int value_count;
 212     int hub_data_size; /* deprecated */
 213   };
 214
 215   /*
 216    *  Use "values" instead of "hub_data"
 217    *  which is going to be removed soon
 218    */
 219   union {
 220     char values[SENSORHUB_DATA_VALUE_SIZE];
 221     char hub_data[SENSORHUB_DATA_VALUE_SIZE]; /* deprecated */
 222   };
 223 } sensorhub_data_t;
 224
 225 #define SENSOR_PEDOMETER_DATA_DIFFS_SIZE 20
 226
 227 typedef struct {
 228   int accuracy;
 229   unsigned long long timestamp;
 230   int value_count; /* value_count == 8 */
 231   float values[SENSOR_DATA_VALUE_SIZE];
 232   /* values = {step count, walk step count, run step count,
 233                moving distance, calorie burned, last speed,
 234                last stepping frequency (steps per sec),
 235                last step status (walking, running, ...)} */
 236   /* Additional data attributes (not in sensor_data_t)*/
 237   int diffs_count;
 238   struct differences {
 239     int timestamp;
 240     int steps;
 241     int walk_steps;
 242     int run_steps;
 243     int walk_up_steps;
 244     int walk_down_steps;
 245     int run_up_steps;
 246     int run_down_steps;
 247     float distance;
 248     float calories;
 249     float speed;
 250   } diffs[SENSOR_PEDOMETER_DATA_DIFFS_SIZE];
 251 } sensor_pedometer_data_t;
 252
 253 #define CONVERT_TYPE_ATTR(type, index) ((type) << 8 | 0x80 | (index))
 254
 255 enum sensor_attribute {
 256   SENSOR_ATTR_ACCELEROMETER_INJECTION =
 257       CONVERT_TYPE_ATTR(SENSOR_DEVICE_ACCELEROMETER, 0xFF),
 258   SENSOR_ATTR_ACTIVITY = CONVERT_TYPE_ATTR(SENSOR_DEVICE_ACTIVITY_TRACKER, 0x1),
 259
 260   SENSOR_ATTR_HRM_BATCH_OPR_MODE =
 261       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x1),
 262   SENSOR_ATTR_HRM_BATCH_ACTIVITY_TYPE =
 263       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x2),
 264   SENSOR_ATTR_HRM_BATCH_BATCH_DUR =
 265       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x3),
 266   SENSOR_ATTR_HRM_BATCH_FLUSH = CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x4),
 267   SENSOR_ATTR_HRM_BATCH_ELEVATED_DUR =
 268       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x5),
 269   SENSOR_ATTR_HRM_BATCH_ELEVATED_THR =
 270       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x6),
 271   SENSOR_ATTR_HRM_BATCH_BPM_RAW =
 272       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x7),
 273   SENSOR_ATTR_HRM_BATCH_LOW_ALERT_DUR =
 274       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x8),
 275   SENSOR_ATTR_HRM_BATCH_LOW_ALERT_THR =
 276       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_BATCH, 0x9),
 277
 278   SENSOR_ATTR_HRM_LED_GREEN_BATCH_POLLING_INTERVAL =
 279       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_LED_GREEN_BATCH, 0x1),
 280   SENSOR_ATTR_HRM_LED_GREEN_BATCH_FLUSH =
 281       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_LED_GREEN_BATCH, 0x2),
 282   SENSOR_ATTR_HRM_LED_GREEN_BATCH_BATCH_PERIOD =
 283       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HRM_LED_GREEN_BATCH, 0x3),
 284
 285   SENSOR_ATTR_PEDOMETER_HEIGHT =
 286       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x1),
 287   SENSOR_ATTR_PEDOMETER_WEIGHT =
 288       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x2),
 289   SENSOR_ATTR_PEDOMETER_GENDER =
 290       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x3),
 291   SENSOR_ATTR_PEDOMETER_AGE =
 292       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x4),
 293   SENSOR_ATTR_PEDOMETER_FLUSH =
 294       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_PEDOMETER, 0x2F),
 295
 296   SENSOR_ATTR_STRESS_MONITOR_AGE =
 297       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x1),
 298
 299   SENSOR_ATTR_EXERCISE_TYPE =
 300       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x1),
 301   SENSOR_ATTR_EXERCISE_GPS =
 302       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x2),
 303   SENSOR_ATTR_EXERCISE_BATCH_INTERVAL =
 304       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x3),
 305   SENSOR_ATTR_EXERCISE_PSERVICE =
 306       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_STANDALONE, 0x4),
 307
 308   SENSOR_ATTR_CYCLE_DURATION =
 309       CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x1),
 310   SENSOR_ATTR_CYCLE_HOLDING_POSITION =
 311       CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x2),
 312   SENSOR_ATTR_CYCLE_VELOCITY =
 313       CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x3),
 314   SENSOR_ATTR_CYCLE_GET_DATA_TYPE =
 315       CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x4),
 316   SENSOR_ATTR_CYCLE_DATA_FLUSH =
 317       CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x5),
 318   SENSOR_ATTR_CYCLE_GPS_AGREEMENT =
 319       CONVERT_TYPE_ATTR(SENSOR_DEVICE_CYCLE_MONITOR, 0x6),
 320
 321   SENSOR_ATTR_WORKOUT_TYPE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_WORKOUT, 0x1),
 322   SENSOR_ATTR_WORKOUT_DURATION = CONVERT_TYPE_ATTR(SENSOR_DEVICE_WORKOUT, 0x2),
 323
 324   SENSOR_ATTR_RESTING_HR_OPR_MODE =
 325       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x1),
 326   SENSOR_ATTR_RESTING_HR_MAX_RHR =
 327       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x2),
 328   SENSOR_ATTR_RESTING_HR_MIN_RHR =
 329       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x3),
 330   SENSOR_ATTR_RESTING_HR_AVG_RHR =
 331       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x4),
 332   SENSOR_ATTR_RESTING_HR_HOUR =
 333       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x5),
 334   SENSOR_ATTR_RESTING_HR_MIN = CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x6),
 335   SENSOR_ATTR_RESTING_HR_SEC = CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x7),
 336   SENSOR_ATTR_RESTING_HR_PROPERTY_TYPE =
 337       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x10),
 338   SENSOR_ATTR_RESTING_HR_PROPERTY_HR_TYPE =
 339       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x11),
 340   SENSOR_ATTR_RESTING_HR_PROPERTY_HR_VALUE =
 341       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x12),
 342   SENSOR_ATTR_RESTING_HR_PROPERTY_DURATION =
 343       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x13),
 344   SENSOR_ATTR_RESTING_HR_PROPERTY_ACT_TYPE =
 345       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x14),
 346   SENSOR_ATTR_RESTING_HR_PROPERTY_ACT_DUR =
 347       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x15),
 348   SENSOR_ATTR_RESTING_HR_PROPERTY_CONT_DUR =
 349       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x16),
 350   SENSOR_ATTR_RESTING_HR_DATA_TYPE =
 351       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x20),
 352   SENSOR_ATTR_RESTING_HR_DATA_FLUSH =
 353       CONVERT_TYPE_ATTR(SENSOR_DEVICE_RESTING_HR, 0x21),
 354
 355   SENSOR_ATTR_STEP_LEVEL_MONITOR_DW_DURATION =
 356       CONVERT_TYPE_ATTR(SENSOR_DEVICE_STEP_LEVEL_MONITOR, 0x1),
 357
 358   SENSOR_ATTR_EXERCISE_HR_OPR_MODE =
 359       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x1),
 360   SENSOR_ATTR_EXERCISE_HR_ACTIVITY_TYPE =
 361       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x2),
 362   SENSOR_ATTR_EXERCISE_HR_BATCH_DUR =
 363       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x3),
 364   SENSOR_ATTR_EXERCISE_HR_FLUSH =
 365       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x4),
 366   SENSOR_ATTR_EXERCISE_HR_ELEVATED_DUR =
 367       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x5),
 368   SENSOR_ATTR_EXERCISE_HR_ELEVATED_THR =
 369       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x6),
 370   SENSOR_ATTR_EXERCISE_HR_BPM_RAW =
 371       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x7),
 372   SENSOR_ATTR_EXERCISE_HR_LOW_ALERT_DUR =
 373       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x8),
 374   SENSOR_ATTR_EXERCISE_HR_LOW_ALERT_THR =
 375       CONVERT_TYPE_ATTR(SENSOR_DEVICE_EXERCISE_HR, 0x9),
 376
 377   SENSOR_ATTR_PRESSURE_INDICATOR_START =
 378       CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x1),
 379   SENSOR_ATTR_PRESSURE_INDICATOR_STOP =
 380       CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x2),
 381   SENSOR_ATTR_PRESSURE_INDICATOR_FLUSH =
 382       CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x3),
 383   SENSOR_ATTR_PRESSURE_INDICATOR_RESTORE_TIME =
 384       CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x4),
 385   SENSOR_ATTR_PRESSURE_INDICATOR_RESTORE_VALUE =
 386       CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x5),
 387   SENSOR_ATTR_PRESSURE_INDICATOR_CURRENT_TIME =
 388       CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_INDICATOR, 0x6),
 389
 390   SENSOR_ATTR_PRESSURE_ALERT_START =
 391       CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_ALERT, 0x1),
 392   SENSOR_ATTR_PRESSURE_ALERT_STOP =
 393       CONVERT_TYPE_ATTR(SENSOR_DEVICE_PRESSURE_ALERT, 0x2),
 394
 395   SENSOR_ATTR_HR_CALORIE_AGE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x1),
 396   SENSOR_ATTR_HR_CALORIE_HEIGHT =
 397       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x2),
 398   SENSOR_ATTR_HR_CALORIE_WEIGHT =
 399       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x3),
 400   SENSOR_ATTR_HR_CALORIE_GENDER =
 401       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x4),
 402   SENSOR_ATTR_HR_CALORIE_INST =
 403       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x10),
 404   SENSOR_ATTR_HR_CALORIE_EXERCISE_TYPE =
 405       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x11),
 406   SENSOR_ATTR_HR_CALORIE_TARGET_CAL =
 407       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x12),
 408   SENSOR_ATTR_HR_CALORIE_MAX_HEARTRATE =
 409       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x13),
 410   SENSOR_ATTR_HR_CALORIE_FLUSH =
 411       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HR_CALORIE, 0x20),
 412
 413   SENSOR_ATTR_SWIMMING_TRACKER_PLACE =
 414       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x1),
 415   SENSOR_ATTR_SWIMMING_TRACKER_DISTANCE =
 416       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x2),
 417   SENSOR_ATTR_SWIMMING_TRACKER_FLUSH =
 418       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x3),
 419   SENSOR_ATTR_SWIMMING_TRACKER_BATCH =
 420       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x4),
 421   SENSOR_ATTR_SWIMMING_TRACKER_GOAL_CALORIES =
 422       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x5),
 423   SENSOR_ATTR_SWIMMING_TRACKER_GOAL_LAPS =
 424       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x6),
 425   SENSOR_ATTR_SWIMMING_TRACKER_TIME_REST =
 426       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x7),
 427   SENSOR_ATTR_SWIMMING_TRACKER_TIME_TURN =
 428       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_TRACKER, 0x8),
 429
 430   SENSOR_ATTR_SWIMMING_OUTDOOR_SET_BATCH_LAP_COUNT =
 431       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x1),
 432   SENSOR_ATTR_SWIMMING_OUTDOOR_SETGOAL_LENGTH =
 433       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x2),
 434   SENSOR_ATTR_SWIMMING_OUTDOOR_SETGOAL_TIME =
 435       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x3),
 436   SENSOR_ATTR_SWIMMING_OUTDOOR_SET_GPS_PERMISSION =
 437       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x4),
 438   SENSOR_ATTR_SWIMMING_OUTDOOR_FLUSH =
 439       CONVERT_TYPE_ATTR(SENSOR_DEVICE_SWIMMING_OUTDOOR, 0x6),
 440
 441   SENSOR_ATTR_AUTO_SWIMMING_DURATION =
 442       CONVERT_TYPE_ATTR(SENSOR_DEVICE_AUTO_SWIMMING, 0x1),
 443
 444   SENSOR_ATTR_INACTIVITY_DETECTOR_LEVEL =
 445       CONVERT_TYPE_ATTR(SENSOR_DEVICE_INACTIVITY_DETECTOR, 0x1),
 446   SENSOR_ATTR_INACTIVITY_DETECTOR_DURATION =
 447       CONVERT_TYPE_ATTR(SENSOR_DEVICE_INACTIVITY_DETECTOR, 0x2),
 448
 449   SENSOR_ATTR_STRESS_TRACKER_DUR =
 450       CONVERT_TYPE_ATTR(SENSOR_DEVICE_STRESS_TRACKER, 0x1),
 451   SENSOR_ATTR_STRESS_TRACKER_FLUSH =
 452       CONVERT_TYPE_ATTR(SENSOR_DEVICE_STRESS_TRACKER, 0x2),
 453
 454   SENSOR_ATTR_STRESS_MONITOR_BASE_HR =
 455       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x1),
 456   SENSOR_ATTR_STRESS_MONITOR_HISTO_INDEX =
 457       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x2),
 458   SENSOR_ATTR_STRESS_MONITOR_HISTO_VALUE =
 459       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x3),
 460   SENSOR_ATTR_STRESS_MONITOR_TUNE_INDEX =
 461       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x4),
 462   SENSOR_ATTR_STRESS_MONITOR_TUNE_VALUE =
 463       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x5),
 464   SENSOR_ATTR_STRESS_MONITOR_FLUSH =
 465       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x6),
 466   SENSOR_ATTR_STRESS_MONITOR_OPERATION =
 467       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_STRESS_MONITOR, 0x7),
 468
 469   SENSOR_ATTR_SLEEP_MONITOR_STOP =
 470       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_MONITOR, 0x1),
 471   SENSOR_ATTR_SLEEP_MONITOR_FLUSH =
 472       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_MONITOR, 0x2),
 473
 474   SENSOR_ATTR_SLEEP_DETECTOR_STOP =
 475       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_DETECTOR, 0x1),
 476   SENSOR_ATTR_SLEEP_DETECTOR_SETTING =
 477       CONVERT_TYPE_ATTR(SENSOR_DEVICE_HUMAN_SLEEP_DETECTOR, 0x2),
 478
 479   SENSOR_ATTR_DATA_JOURNAL_START =
 480       CONVERT_TYPE_ATTR(SENSOR_DEVICE_DATA_JOURNAL, 0x1),
 481   SENSOR_ATTR_DATA_JOURNAL_STOP =
 482       CONVERT_TYPE_ATTR(SENSOR_DEVICE_DATA_JOURNAL, 0x2),
 483
 484   SENSOR_ATTR_GPS_BATCH_OPR_MODE =
 485       CONVERT_TYPE_ATTR(SENSOR_DEVICE_GPS_BATCH, 0x1),
 486
 487   SENSOR_ATTR_PPG_BATCH_POLLING_INTERVAL =
 488       CONVERT_TYPE_ATTR(SENSOR_DEVICE_PPG_BATCH, 0x1),
 489   SENSOR_ATTR_PPG_BATCH_FLUSH = CONVERT_TYPE_ATTR(SENSOR_DEVICE_PPG_BATCH, 0x2),
 490
 491   SENSOR_ATTR_REG_CTRL_TYPE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x1),
 492   SENSOR_ATTR_REG_CTRL_ADDRESS = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x2),
 493   SENSOR_ATTR_REG_CTRL_VALUE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x3),
 494   SENSOR_ATTR_REG_CTRL_MODE = CONVERT_TYPE_ATTR(SENSOR_DEVICE_REG_CTRL, 0x4),
 495
 496   SENSOR_ATTR_GPS_CTRL_SETTING = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GPS_CTRL, 0x1),
 497
 498   SENSOR_ATTR_FAKE_MOTION_EVENT_INTERVAL =
 499       CONVERT_TYPE_ATTR(SENSOR_DEVICE_FAKE_MOTION, 0x1),
 500   SENSOR_ATTR_FAKE_MOTION_EVENT_COUNT =
 501       CONVERT_TYPE_ATTR(SENSOR_DEVICE_FAKE_MOTION, 0x2),
 502   SENSOR_ATTR_FAKE_MOTION_PAUSE_INTERVAL =
 503       CONVERT_TYPE_ATTR(SENSOR_DEVICE_FAKE_MOTION, 0x3),
 504
 505   SENSOR_ATTR_GEOFENCE_ID = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x1),
 506   SENSOR_ATTR_GEOFENCE_LAT = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x2),
 507   SENSOR_ATTR_GEOFENCE_LON = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x3),
 508   SENSOR_ATTR_GEOFENCE_RADIUS = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x4),
 509   SENSOR_ATTR_GEOFENCE_PROVIDER =
 510       CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x5),
 511   SENSOR_ATTR_GEOFENCE_ACCURACY =
 512       CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x6),
 513   SENSOR_ATTR_GEOFENCE_TIMESTAMP =
 514       CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x7),
 515   SENSOR_ATTR_GEOFENCE_CONNECT = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x8),
 516   SENSOR_ATTR_GEOFENCE_START = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x10),
 517   SENSOR_ATTR_GEOFENCE_STOP = CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x11),
 518   SENSOR_ATTR_GEOFENCE_SET_LOCATION =
 519       CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x12),
 520   SENSOR_ATTR_GEOFENCE_BT_CONNECT =
 521       CONVERT_TYPE_ATTR(SENSOR_DEVICE_GEOFENCE, 0x13),
 522
 523   SENSOR_ATTR_FALL_DETECTION_OPR_MODE =
 524       CONVERT_TYPE_ATTR(SENSOR_DEVICE_FALL_DETECTION, 0x1),
 525
 526   HAL_SENSOR_ATTR_PROXIMITY_SENSITIVITY_LEVEL =
 527       CONVERT_TYPE_ATTR(SENSOR_DEVICE_PROXIMITY, 0x1),
 528
 529   HAL_SENSOR_ATTR_LIDAR_POWER_STATE =
 530       CONVERT_TYPE_ATTR(SENSOR_DEVICE_LIDAR, 0x1),
 531 };
 532
 533 enum sensor_attribute_common {
 534   SENSOR_ATTR_COMMON_START = 0x1000000,
 535   SENSOR_ATTR_POWER_STATE = SENSOR_ATTR_COMMON_START + 10001,
 536 };
 537
 538 enum sensor_activity {
 539   SENSOR_ACTIVITY_UNKNOWN = 1,
 540   SENSOR_ACTIVITY_STILL = 2,
 541   SENSOR_ACTIVITY_WALKING = 4,
 542   SENSOR_ACTIVITY_RUNNING = 8,
 543   SENSOR_ACTIVITY_IN_VEHICLE = 16,
 544   SENSOR_ACTIVITY_ON_BICYCLE = 32,
 545 };
 546
 547 /* HAL_SENSOR_ATTR_PROXIMITY_SENSITIVITY_LEVEL attribute value */
 548 enum hal_sensor_proximity_sensitivity_level {
 549         HAL_SENSOR_PROXIMITY_SENSITIVITY_LEVEL_WEAK = 1,
 550         HAL_SENSOR_PROXIMITY_SENSITIVITY_LEVEL_MEDIUM = 2,
 551         HAL_SENSOR_PROXIMITY_SENSITIVITY_LEVEL_STRONG = 3
 552 };
 553
 554 /* HAL_SENSOR_ATTR_LIDAR_POWER_STATE attribute value */
 555 enum hal_sensor_lidar_power_state {
 556         HAL_SENSOR_LIDAR_POWER_STATE_OFF = 0,
 557         HAL_SENSOR_LIDAR_POWER_STATE_ON = 1
 558 };
 559
 560 #ifdef __cplusplus
 561 }
 562
 563 /*
 564  * Create devices
 565  */
 566 typedef void *sensor_device_t;
 567 typedef int (*create_t)(sensor_device_t **devices);
 568
 569 /*
 570  * Sensor device interface
 571  * 1 device must be abstracted from 1 device event node
 572  */
 573 class sensor_device {
 574  public:
 575   virtual ~sensor_device() {}
 576
 577   uint32_t get_hal_version(void) { return SENSOR_HAL_VERSION(1, 0); }
 578
 579   virtual int get_poll_fd(void) = 0;
 580   virtual int get_sensors(const sensor_info_t **sensors) = 0;
 581
 582   virtual bool enable(uint32_t id) = 0;
 583   virtual bool disable(uint32_t id) = 0;
 584
 585   virtual int read_fd(uint32_t **ids) = 0;
 586   virtual int get_data(uint32_t id, sensor_data_t **data, int *length) = 0;
 587
 588   virtual bool set_interval(uint32_t id, unsigned long val) { return true; }
 589   virtual bool set_batch_latency(uint32_t id, unsigned long val) {
 590     return true;
 591   }
 592   virtual bool set_attribute_int(uint32_t id, int32_t attribute,
 593                                  int32_t value) {
 594     return true;
 595   }
 596   virtual bool set_attribute_str(uint32_t id, int32_t attribute, const char *value,
 597                                  int len) {
 598     return true;
 599   }
 600   virtual bool get_attribute_int(uint32_t id, int32_t attribute,
 601                                  int32_t *value) {
 602     return true;
 603   }
 604   virtual bool get_attribute_str(uint32_t id, int32_t attribute, char **value,
 605                                  int *len) {
 606     return true;
 607   }
 608
 609   virtual bool flush(uint32_t id) { return true; }
 610 };
 611
 612 #endif /* __cplusplus */
 613 #endif /* __HAL_SENSOR_TYPES__ */