1/* 2 * Copyright (C) 2016 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 17package android.hardware.automotive.vehicle@2.0; 18 19/** 20 * Enumerates supported data type for VehicleProperty. 21 * 22 * Used to create property ID in VehicleProperty enum. 23 */ 24enum VehiclePropertyType : int32_t { 25 STRING = 0x00100000, 26 BOOLEAN = 0x00200000, 27 INT32 = 0x00400000, 28 INT32_VEC = 0x00410000, 29 INT64 = 0x00500000, 30 INT64_VEC = 0x00510000, 31 FLOAT = 0x00600000, 32 FLOAT_VEC = 0x00610000, 33 BYTES = 0x00700000, 34 35 /** 36 * Any combination of scalar or vector types. The exact format must be 37 * provided in the description of the property. 38 * 39 * For vendor MIXED type properties, configArray needs to be formatted in this 40 * structure. 41 * configArray[0], 1 indicates the property has a String value 42 * configArray[1], 1 indicates the property has a Boolean value . 43 * configArray[2], 1 indicates the property has an Integer value. 44 * configArray[3], the number indicates the size of Integer[] in the property. 45 * configArray[4], 1 indicates the property has a Long value. 46 * configArray[5], the number indicates the size of Long[] in the property. 47 * configArray[6], 1 indicates the property has a Float value. 48 * configArray[7], the number indicates the size of Float[] in the property. 49 * configArray[8], the number indicates the size of byte[] in the property. 50 * For example: 51 * {@code configArray = {1, 1, 1, 3, 0, 0, 0, 0, 0}} indicates the property has 52 * a String value, a Boolean value, an Integer value and an array with 3 integers. 53 */ 54 MIXED = 0x00e00000, 55 56 MASK = 0x00ff0000 57}; 58 59/** 60 * Vehicle Areas 61 * Used to construct property IDs in the VehicleProperty enum. 62 * 63 * Some properties may be associated with particular vehicle areas. For 64 * example, VehicleProperty:DOOR_LOCK property must be associated with 65 * particular door, thus this property must be marked with 66 * VehicleArea:DOOR flag. 67 * 68 * Other properties may not be associated with particular vehicle area. 69 * These kinds of properties must have VehicleArea:GLOBAL flag. 70 * 71 * [Definition] Area: An area represents a unique element of an AreaType. 72 * For instance, if AreaType is WINDOW, then an area may be FRONT_WINDSHIELD. 73 * 74 * [Definition] AreaID: An AreaID is a combination of one or more areas, 75 * and is represented using a bitmask of Area enums. Different AreaTypes may 76 * not be mixed in a single AreaID. For instance, a window area cannot be 77 * combined with a seat area in an AreaID. 78 * 79 * Rules for mapping a zoned property to AreaIDs: 80 * - A property must be mapped to an array of AreaIDs that are impacted when 81 * the property value changes. 82 * - Each element in the array must represent an AreaID, in which the 83 * property value can only be changed together in all the areas within 84 * the AreaID and never independently. That is, when the property value 85 * changes in one of the areas in an AreaID in the array, then it must 86 * automatically change in all other areas in the AreaID. 87 * - The property value must be independently controllable in any two 88 * different AreaIDs in the array. 89 * - An area must only appear once in the array of AreaIDs. That is, an 90 * area must only be part of a single AreaID in the array. 91 * 92 * [Definition] Global Property: A property that applies to the entire car 93 * and is not associated with a specific area. For example, FUEL_LEVEL, 94 * HVAC_STEERING_WHEEL_HEAT. 95 * 96 * Rules for mapping a global property to AreaIDs: 97 * - A global property must not be mapped to AreaIDs. 98*/ 99enum VehicleArea : int32_t { 100 GLOBAL = 0x01000000, 101 /** WINDOW maps to enum VehicleAreaWindow */ 102 WINDOW = 0x03000000, 103 /** MIRROR maps to enum VehicleAreaMirror */ 104 MIRROR = 0x04000000, 105 /** SEAT maps to enum VehicleAreaSeat */ 106 SEAT = 0x05000000, 107 /** DOOR maps to enum VehicleAreaDoor */ 108 DOOR = 0x06000000, 109 /** WHEEL maps to enum VehicleAreaWheel */ 110 WHEEL = 0x07000000, 111 112 MASK = 0x0f000000, 113}; 114 115/** 116 * Enumerates property groups. 117 * 118 * Used to create property ID in VehicleProperty enum. 119 */ 120enum VehiclePropertyGroup : int32_t { 121 /** 122 * Properties declared in AOSP must use this flag. 123 */ 124 SYSTEM = 0x10000000, 125 126 /** 127 * Properties declared by vendors must use this flag. 128 */ 129 VENDOR = 0x20000000, 130 131 MASK = 0xf0000000, 132}; 133 134/** 135 * Declares all vehicle properties. VehicleProperty has a bitwise structure. 136 * Each property must have: 137 * - a unique id from range 0x0100 - 0xffff 138 * - associated data type using VehiclePropertyType 139 * - property group (VehiclePropertyGroup) 140 * - vehicle area (VehicleArea) 141 * 142 * Vendors are allowed to extend this enum with their own properties. In this 143 * case they must use VehiclePropertyGroup:VENDOR flag when the property is 144 * declared. 145 * 146 * When a property's status field is not set to AVAILABLE: 147 * - IVehicle#set may return StatusCode::NOT_AVAILABLE. 148 * - IVehicle#get is not guaranteed to work. 149 * 150 * Properties set to values out of range must be ignored and no action taken 151 * in response to such ill formed requests. 152 */ 153enum VehicleProperty : int32_t { 154 155 /** Undefined property. */ 156 INVALID = 0x00000000, 157 158 /** 159 * VIN of vehicle 160 * 161 * @change_mode VehiclePropertyChangeMode:STATIC 162 * @access VehiclePropertyAccess:READ 163 */ 164 INFO_VIN = ( 165 0x0100 166 | VehiclePropertyGroup:SYSTEM 167 | VehiclePropertyType:STRING 168 | VehicleArea:GLOBAL), 169 170 /** 171 * Manufacturer of vehicle 172 * 173 * @change_mode VehiclePropertyChangeMode:STATIC 174 * @access VehiclePropertyAccess:READ 175 */ 176 INFO_MAKE = ( 177 0x0101 178 | VehiclePropertyGroup:SYSTEM 179 | VehiclePropertyType:STRING 180 | VehicleArea:GLOBAL), 181 182 /** 183 * Model of vehicle 184 * 185 * @change_mode VehiclePropertyChangeMode:STATIC 186 * @access VehiclePropertyAccess:READ 187 */ 188 INFO_MODEL = ( 189 0x0102 190 | VehiclePropertyGroup:SYSTEM 191 | VehiclePropertyType:STRING 192 | VehicleArea:GLOBAL), 193 194 /** 195 * Model year of vehicle. 196 * 197 * @change_mode VehiclePropertyChangeMode:STATIC 198 * @access VehiclePropertyAccess:READ 199 * @unit VehicleUnit:YEAR 200 */ 201 INFO_MODEL_YEAR = ( 202 0x0103 203 | VehiclePropertyGroup:SYSTEM 204 | VehiclePropertyType:INT32 205 | VehicleArea:GLOBAL), 206 207 /** 208 * Fuel capacity of the vehicle in milliliters 209 * 210 * @change_mode VehiclePropertyChangeMode:STATIC 211 * @access VehiclePropertyAccess:READ 212 * @unit VehicleUnit:MILLILITER 213 */ 214 INFO_FUEL_CAPACITY = ( 215 0x0104 216 | VehiclePropertyGroup:SYSTEM 217 | VehiclePropertyType:FLOAT 218 | VehicleArea:GLOBAL), 219 220 /** 221 * List of fuels the vehicle may use 222 * 223 * @change_mode VehiclePropertyChangeMode:STATIC 224 * @access VehiclePropertyAccess:READ 225 * @data_enum FuelType 226 */ 227 INFO_FUEL_TYPE = ( 228 0x0105 229 | VehiclePropertyGroup:SYSTEM 230 | VehiclePropertyType:INT32_VEC 231 | VehicleArea:GLOBAL), 232 233 /** 234 * Battery capacity of the vehicle, if EV or hybrid. This is the nominal 235 * battery capacity when the vehicle is new. 236 * 237 * @change_mode VehiclePropertyChangeMode:STATIC 238 * @access VehiclePropertyAccess:READ 239 * @unit VehicleUnit:WH 240 */ 241 INFO_EV_BATTERY_CAPACITY = ( 242 0x0106 243 | VehiclePropertyGroup:SYSTEM 244 | VehiclePropertyType:FLOAT 245 | VehicleArea:GLOBAL), 246 247 /** 248 * List of connectors this EV may use 249 * 250 * @change_mode VehiclePropertyChangeMode:STATIC 251 * @data_enum EvConnectorType 252 * @access VehiclePropertyAccess:READ 253 */ 254 INFO_EV_CONNECTOR_TYPE = ( 255 0x0107 256 | VehiclePropertyGroup:SYSTEM 257 | VehiclePropertyType:INT32_VEC 258 | VehicleArea:GLOBAL), 259 260 /** 261 * Fuel door location 262 * 263 * @change_mode VehiclePropertyChangeMode:STATIC 264 * @data_enum PortLocationType 265 * @access VehiclePropertyAccess:READ 266 */ 267 INFO_FUEL_DOOR_LOCATION = ( 268 0x0108 269 | VehiclePropertyGroup:SYSTEM 270 | VehiclePropertyType:INT32 271 | VehicleArea:GLOBAL), 272 273 /** 274 * EV port location 275 * 276 * @change_mode VehiclePropertyChangeMode:STATIC 277 * @access VehiclePropertyAccess:READ 278 * @data_enum PortLocationType 279 */ 280 INFO_EV_PORT_LOCATION = ( 281 0x0109 282 | VehiclePropertyGroup:SYSTEM 283 | VehiclePropertyType:INT32 284 | VehicleArea:GLOBAL), 285 286 /** 287 * Driver's seat location 288 * VHAL implementations must ignore the areaId. Use VehicleArea:GLOBAL. 289 * 290 * @change_mode VehiclePropertyChangeMode:STATIC 291 * @data_enum VehicleAreaSeat 292 * @access VehiclePropertyAccess:READ 293 */ 294 INFO_DRIVER_SEAT = ( 295 0x010A 296 | VehiclePropertyGroup:SYSTEM 297 | VehiclePropertyType:INT32 298 | VehicleArea:SEAT), 299 300 /** 301 * Exterior dimensions of vehicle. 302 * 303 * int32Values[0] = height 304 * int32Values[1] = length 305 * int32Values[2] = width 306 * int32Values[3] = width including mirrors 307 * int32Values[4] = wheel base 308 * int32Values[5] = track width front 309 * int32Values[6] = track width rear 310 * int32Values[7] = curb to curb turning radius 311 * 312 * @change_mode VehiclePropertyChangeMode:STATIC 313 * @access VehiclePropertyAccess:READ 314 * @unit VehicleUnit:MILLIMETER 315 */ 316 INFO_EXTERIOR_DIMENSIONS = ( 317 0x010B 318 | VehiclePropertyGroup:SYSTEM 319 | VehiclePropertyType:INT32_VEC 320 | VehicleArea:GLOBAL), 321 322 /** 323 * Multiple EV port locations 324 * 325 * Implement this property if the vehicle has multiple EV ports. 326 * Port locations are defined in PortLocationType. 327 * For example, a car has one port in front left and one port in rear left: 328 * int32Values[0] = PortLocationType::FRONT_LEFT 329 * int32Values[0] = PortLocationType::REAR_LEFT 330 * 331 * @change_mode VehiclePropertyChangeMode:STATIC 332 * @access VehiclePropertyAccess:READ 333 * @data_enum PortLocationType 334 */ 335 INFO_MULTI_EV_PORT_LOCATIONS = ( 336 0x010C 337 | VehiclePropertyGroup:SYSTEM 338 | VehiclePropertyType:INT32_VEC 339 | VehicleArea:GLOBAL), 340 341 /** 342 * Current odometer value of the vehicle 343 * 344 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 345 * @access VehiclePropertyAccess:READ 346 * @unit VehicleUnit:KILOMETER 347 */ 348 PERF_ODOMETER = ( 349 0x0204 350 | VehiclePropertyGroup:SYSTEM 351 | VehiclePropertyType:FLOAT 352 | VehicleArea:GLOBAL), 353 354 /** 355 * Speed of the vehicle 356 * 357 * The value must be positive when the vehicle is moving forward and negative when 358 * the vehicle is moving backward. This value is independent of gear value 359 * (CURRENT_GEAR or GEAR_SELECTION), for example, if GEAR_SELECTION is GEAR_NEUTRAL, 360 * PERF_VEHICLE_SPEED is positive when the vehicle is moving forward, negative when moving 361 * backward, and zero when not moving. 362 * 363 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 364 * @access VehiclePropertyAccess:READ 365 * @unit VehicleUnit:METER_PER_SEC 366 */ 367 PERF_VEHICLE_SPEED = ( 368 0x0207 369 | VehiclePropertyGroup:SYSTEM 370 | VehiclePropertyType:FLOAT 371 | VehicleArea:GLOBAL), 372 373 /** 374 * Speed of the vehicle for displays 375 * 376 * Some cars display a slightly slower speed than the actual speed. This is 377 * usually displayed on the speedometer. 378 * 379 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 380 * @access VehiclePropertyAccess:READ 381 * @unit VehicleUnit:METER_PER_SEC 382 */ 383 PERF_VEHICLE_SPEED_DISPLAY = ( 384 0x0208 385 | VehiclePropertyGroup:SYSTEM 386 | VehiclePropertyType:FLOAT 387 | VehicleArea:GLOBAL), 388 389 /** 390 * Front bicycle model steering angle for vehicle 391 * 392 * Angle is in degrees. Left is negative. 393 * 394 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 395 * @access VehiclePropertyAccess:READ 396 * @unit VehicleUnit:DEGREES 397 */ 398 PERF_STEERING_ANGLE = ( 399 0x0209 400 | VehiclePropertyGroup:SYSTEM 401 | VehiclePropertyType:FLOAT 402 | VehicleArea:GLOBAL), 403 404 /** 405 * Rear bicycle model steering angle for vehicle 406 * 407 * Angle is in degrees. Left is negative. 408 * 409 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 410 * @access VehiclePropertyAccess:READ 411 * @unit VehicleUnit:DEGREES 412 */ 413 PERF_REAR_STEERING_ANGLE = ( 414 0x0210 415 | VehiclePropertyGroup:SYSTEM 416 | VehiclePropertyType:FLOAT 417 | VehicleArea:GLOBAL), 418 419 /** 420 * Temperature of engine coolant 421 * 422 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 423 * @access VehiclePropertyAccess:READ 424 * @unit VehicleUnit:CELSIUS 425 */ 426 ENGINE_COOLANT_TEMP = ( 427 0x0301 428 | VehiclePropertyGroup:SYSTEM 429 | VehiclePropertyType:FLOAT 430 | VehicleArea:GLOBAL), 431 432 /** 433 * Engine oil level 434 * 435 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 436 * @access VehiclePropertyAccess:READ 437 * @data_enum VehicleOilLevel 438 */ 439 ENGINE_OIL_LEVEL = ( 440 0x0303 441 | VehiclePropertyGroup:SYSTEM 442 | VehiclePropertyType:INT32 443 | VehicleArea:GLOBAL), 444 445 /** 446 * Temperature of engine oil 447 * 448 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 449 * @access VehiclePropertyAccess:READ 450 * @unit VehicleUnit:CELSIUS 451 */ 452 ENGINE_OIL_TEMP = ( 453 0x0304 454 | VehiclePropertyGroup:SYSTEM 455 | VehiclePropertyType:FLOAT 456 | VehicleArea:GLOBAL), 457 458 /** 459 * Engine rpm 460 * 461 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 462 * @access VehiclePropertyAccess:READ 463 * @unit VehicleUnit:RPM 464 */ 465 ENGINE_RPM = ( 466 0x0305 467 | VehiclePropertyGroup:SYSTEM 468 | VehiclePropertyType:FLOAT 469 | VehicleArea:GLOBAL), 470 471 /** 472 * Reports wheel ticks 473 * 474 * The first element in the vector is a reset count. A reset indicates 475 * previous tick counts are not comparable with this and future ones. Some 476 * sort of discontinuity in tick counting has occurred. 477 * 478 * The next four elements represent ticks for individual wheels in the 479 * following order: front left, front right, rear right, rear left. All 480 * tick counts are cumulative. Tick counts increment when the vehicle 481 * moves forward, and decrement when vehicles moves in reverse. The ticks 482 * should be reset to 0 when the vehicle is started by the user. 483 * 484 * int64Values[0] = reset count 485 * int64Values[1] = front left ticks 486 * int64Values[2] = front right ticks 487 * int64Values[3] = rear right ticks 488 * int64Values[4] = rear left ticks 489 * 490 * configArray is used to indicate the micrometers-per-wheel-tick values and 491 * which wheels are supported. Each micrometers-per-wheel-tick value is static (i.e. will not 492 * update based on wheel's status) and a best approximation. For example, if a vehicle has 493 * multiple rim/tire size options, the micrometers-per-wheel-tick values are set to those for 494 * the typically expected rim/tire size. configArray is set as follows: 495 * 496 * configArray[0], bits [0:3] = supported wheels. Uses enum Wheel. 497 * configArray[1] = micrometers per front left wheel tick 498 * configArray[2] = micrometers per front right wheel tick 499 * configArray[3] = micrometers per rear right wheel tick 500 * configArray[4] = micrometers per rear left wheel tick 501 * 502 * NOTE: If a wheel is not supported, its value shall always be set to 0. 503 * 504 * VehiclePropValue.timestamp must be correctly filled in. 505 * 506 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 507 * @access VehiclePropertyAccess:READ 508 */ 509 WHEEL_TICK = ( 510 0x0306 511 | VehiclePropertyGroup:SYSTEM 512 | VehiclePropertyType:INT64_VEC 513 | VehicleArea:GLOBAL), 514 515 516 /** 517 * Fuel remaining in the the vehicle, in milliliters 518 * 519 * Value may not exceed INFO_FUEL_CAPACITY 520 * 521 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 522 * @access VehiclePropertyAccess:READ 523 * @unit VehicleUnit:MILLILITER 524 */ 525 FUEL_LEVEL = ( 526 0x0307 527 | VehiclePropertyGroup:SYSTEM 528 | VehiclePropertyType:FLOAT 529 | VehicleArea:GLOBAL), 530 531 /** 532 * Fuel door open 533 * 534 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 535 * @access VehiclePropertyAccess:READ_WRITE 536 */ 537 FUEL_DOOR_OPEN = ( 538 0x0308 539 | VehiclePropertyGroup:SYSTEM 540 | VehiclePropertyType:BOOLEAN 541 | VehicleArea:GLOBAL), 542 543 /** 544 * EV battery level in WH, if EV or hybrid 545 * 546 * Value may not exceed INFO_EV_BATTERY_CAPACITY 547 * 548 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 549 * @access VehiclePropertyAccess:READ 550 * @unit VehicleUnit:WH 551 */ 552 EV_BATTERY_LEVEL = ( 553 0x0309 554 | VehiclePropertyGroup:SYSTEM 555 | VehiclePropertyType:FLOAT 556 | VehicleArea:GLOBAL), 557 558 /** 559 * EV charge port open 560 * 561 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 562 * @access VehiclePropertyAccess:READ_WRITE 563 */ 564 EV_CHARGE_PORT_OPEN = ( 565 0x030A 566 | VehiclePropertyGroup:SYSTEM 567 | VehiclePropertyType:BOOLEAN 568 | VehicleArea:GLOBAL), 569 570 /** 571 * EV charge port connected 572 * 573 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 574 * @access VehiclePropertyAccess:READ 575 */ 576 EV_CHARGE_PORT_CONNECTED = ( 577 0x030B 578 | VehiclePropertyGroup:SYSTEM 579 | VehiclePropertyType:BOOLEAN 580 | VehicleArea:GLOBAL), 581 582 /** 583 * EV instantaneous charge rate in milliwatts 584 * 585 * Positive value indicates battery is being charged. 586 * Negative value indicates battery being discharged. 587 * 588 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 589 * @access VehiclePropertyAccess:READ 590 * @unit VehicleUnit:MW 591 */ 592 EV_BATTERY_INSTANTANEOUS_CHARGE_RATE = ( 593 0x030C 594 | VehiclePropertyGroup:SYSTEM 595 | VehiclePropertyType:FLOAT 596 | VehicleArea:GLOBAL), 597 598 /** 599 * Range remaining 600 * 601 * Meters remaining of fuel and charge. Range remaining shall account for 602 * all energy sources in a vehicle. For example, a hybrid car's range will 603 * be the sum of the ranges based on fuel and battery. 604 * 605 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 606 * @access VehiclePropertyAccess:READ_WRITE 607 * @unit VehicleUnit:METER 608 */ 609 RANGE_REMAINING = ( 610 0x0308 611 | VehiclePropertyGroup:SYSTEM 612 | VehiclePropertyType:FLOAT 613 | VehicleArea:GLOBAL), 614 615 /** 616 * Tire pressure 617 * 618 * Each tires is identified by its areaConfig.areaId config and their 619 * minFloatValue/maxFloatValue are used to store OEM recommended pressure 620 * range. 621 * The Min value in the areaConfig data represents the lower bound of 622 * the recommended tire pressure. 623 * The Max value in the areaConfig data represents the upper bound of 624 * the recommended tire pressure. 625 * For example: 626 * The following areaConfig indicates the recommended tire pressure 627 * of left_front tire is from 200.0 KILOPASCAL to 240.0 KILOPASCAL. 628 * .areaConfigs = { 629 * VehicleAreaConfig { 630 * .areaId = VehicleAreaWheel::LEFT_FRONT, 631 * .minFloatValue = 200.0, 632 * .maxFloatValue = 240.0, 633 * } 634 * }, 635 * 636 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 637 * @access VehiclePropertyAccess:READ 638 * @unit VehicleUnit:KILOPASCAL 639 */ 640 TIRE_PRESSURE = ( 641 0x0309 642 | VehiclePropertyGroup:SYSTEM 643 | VehiclePropertyType:FLOAT 644 | VehicleArea:WHEEL), 645 646 /** 647 * Critically low tire pressure 648 * 649 * This property indicates the critically low pressure threshold for each tire. 650 * It indicates when it is time for tires to be replaced or fixed. The value 651 * must be less than or equal to minFloatValue in TIRE_PRESSURE. 652 * Minimum and maximum property values (that is, minFloatValue, maxFloatValue) 653 * are not applicable to this property. 654 * 655 * @change_mode VehiclePropertyChangeMode:STATIC 656 * @access VehiclePropertyAccess:READ 657 * @unit VehicleUnit:KILOPASCAL 658 */ 659 CRITICALLY_LOW_TIRE_PRESSURE = ( 660 0x030A 661 | VehiclePropertyGroup:SYSTEM 662 | VehiclePropertyType:FLOAT 663 | VehicleArea:WHEEL), 664 665 /** 666 * Currently selected gear 667 * 668 * This is the gear selected by the user. 669 * 670 * Values in the config data must represent the list of supported gears 671 * for this vehicle. For example, config data for an automatic transmission 672 * must contain {GEAR_NEUTRAL, GEAR_REVERSE, GEAR_PARK, GEAR_DRIVE, 673 * GEAR_1, GEAR_2,...} and for manual transmission the list must be 674 * {GEAR_NEUTRAL, GEAR_REVERSE, GEAR_1, GEAR_2,...} 675 * 676 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 677 * @access VehiclePropertyAccess:READ 678 * @data_enum VehicleGear 679 */ 680 GEAR_SELECTION = ( 681 0x0400 682 | VehiclePropertyGroup:SYSTEM 683 | VehiclePropertyType:INT32 684 | VehicleArea:GLOBAL), 685 686 /** 687 * Current gear. In non-manual case, selected gear may not 688 * match the current gear. For example, if the selected gear is GEAR_DRIVE, 689 * the current gear will be one of GEAR_1, GEAR_2 etc, which reflects 690 * the actual gear the transmission is currently running in. 691 * 692 * Values in the config data must represent the list of supported gears 693 * for this vehicle. For example, config data for an automatic transmission 694 * must contain {GEAR_NEUTRAL, GEAR_REVERSE, GEAR_PARK, GEAR_1, GEAR_2,...} 695 * and for manual transmission the list must be 696 * {GEAR_NEUTRAL, GEAR_REVERSE, GEAR_1, GEAR_2,...}. This list need not be the 697 * same as that of the supported gears reported in GEAR_SELECTION. 698 * 699 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 700 * @access VehiclePropertyAccess:READ 701 * @data_enum VehicleGear 702 */ 703 CURRENT_GEAR = ( 704 0x0401 705 | VehiclePropertyGroup:SYSTEM 706 | VehiclePropertyType:INT32 707 | VehicleArea:GLOBAL), 708 709 /** 710 * Parking brake state. 711 * 712 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 713 * @access VehiclePropertyAccess:READ 714 */ 715 PARKING_BRAKE_ON = ( 716 0x0402 717 | VehiclePropertyGroup:SYSTEM 718 | VehiclePropertyType:BOOLEAN 719 | VehicleArea:GLOBAL), 720 721 /** 722 * Auto-apply parking brake. 723 * 724 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 725 * @access VehiclePropertyAccess:READ 726 */ 727 PARKING_BRAKE_AUTO_APPLY = ( 728 0x0403 729 | VehiclePropertyGroup:SYSTEM 730 | VehiclePropertyType:BOOLEAN 731 | VehicleArea:GLOBAL), 732 733 /** 734 * Warning for fuel low level. 735 * 736 * This property corresponds to the low fuel warning on the dashboard. 737 * Once FUEL_LEVEL_LOW is set, it should not be cleared until more fuel is 738 * added to the vehicle. This property may take into account all fuel 739 * sources for a vehicle - for example: 740 * 741 * For a gas powered vehicle, this property is based soley on gas level. 742 * For a battery powered vehicle, this property is based solely on battery level. 743 * For a hybrid vehicle, this property may be based on the combination of gas and battery 744 * levels, at the OEM's discretion. 745 * 746 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 747 * @access VehiclePropertyAccess:READ 748 */ 749 FUEL_LEVEL_LOW = ( 750 0x0405 751 | VehiclePropertyGroup:SYSTEM 752 | VehiclePropertyType:BOOLEAN 753 | VehicleArea:GLOBAL), 754 755 /** 756 * Night mode 757 * 758 * True indicates that the night mode sensor has detected that the car cabin environment has 759 * low light. The platform could use this, for example, to enable appropriate UI for 760 * better viewing in dark or low light environments. 761 * 762 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 763 * @access VehiclePropertyAccess:READ 764 */ 765 NIGHT_MODE = ( 766 0x0407 767 | VehiclePropertyGroup:SYSTEM 768 | VehiclePropertyType:BOOLEAN 769 | VehicleArea:GLOBAL), 770 771 /** 772 * State of the vehicles turn signals 773 * 774 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 775 * @access VehiclePropertyAccess:READ 776 * @data_enum VehicleTurnSignal 777 */ 778 TURN_SIGNAL_STATE = ( 779 0x0408 780 | VehiclePropertyGroup:SYSTEM 781 | VehiclePropertyType:INT32 782 | VehicleArea:GLOBAL), 783 784 /** 785 * Represents ignition state 786 * 787 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 788 * @access VehiclePropertyAccess:READ 789 * @data_enum VehicleIgnitionState 790 */ 791 IGNITION_STATE = ( 792 0x0409 793 | VehiclePropertyGroup:SYSTEM 794 | VehiclePropertyType:INT32 795 | VehicleArea:GLOBAL), 796 797 /** 798 * ABS is active 799 * 800 * Set to true when ABS is active. Reset to false when ABS is off. This 801 * property may be intermittently set (pulsing) based on the real-time 802 * state of the ABS system. 803 * 804 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 805 * @access VehiclePropertyAccess:READ 806 */ 807 ABS_ACTIVE = ( 808 0x040A 809 | VehiclePropertyGroup:SYSTEM 810 | VehiclePropertyType:BOOLEAN 811 | VehicleArea:GLOBAL), 812 813 /** 814 * Traction Control is active 815 * 816 * Set to true when traction control (TC) is active. Reset to false when 817 * TC is off. This property may be intermittently set (pulsing) based on 818 * the real-time state of the TC system. 819 * 820 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 821 * @access VehiclePropertyAccess:READ 822 */ 823 TRACTION_CONTROL_ACTIVE = ( 824 0x040B 825 | VehiclePropertyGroup:SYSTEM 826 | VehiclePropertyType:BOOLEAN 827 | VehicleArea:GLOBAL), 828 829 /* 830 * HVAC Properties 831 * 832 * Additional rules for mapping a zoned HVAC property (except 833 * HVAC_MAX_DEFROST_ON) to AreaIDs: 834 * - Every seat in VehicleAreaSeat that is available in the car, must be 835 * part of an AreaID in the AreaID array. 836 * 837 * Example 1: A car has two front seats (ROW_1_LEFT, ROW_1_RIGHT) and three 838 * back seats (ROW_2_LEFT, ROW_2_CENTER, ROW_2_RIGHT). There are two 839 * temperature control units -- driver side and passenger side. 840 * - A valid mapping set of AreaIDs for HVAC_TEMPERATURE_SET would be a 841 * two element array: 842 * - ROW_1_LEFT | ROW_2_LEFT 843 * - ROW_1_RIGHT | ROW_2_CENTER | ROW_2_RIGHT 844 * - An alternative mapping for the same hardware configuration would be: 845 * - ROW_1_LEFT | ROW_2_CENTER | ROW_2_LEFT 846 * - ROW_1_RIGHT | ROW_2_RIGHT 847 * The temperature controllers are assigned to the seats which they 848 * "most influence", but every seat must be included exactly once. The 849 * assignment of the center rear seat to the left or right AreaID may seem 850 * arbitrary, but the inclusion of every seat in exactly one AreaID ensures 851 * that the seats in the car are all expressed and that a "reasonable" way 852 * to affect each seat is available. 853 * 854 * Example 2: A car has three seat rows with two seats in the front row (ROW_1_LEFT, 855 * ROW_1_RIGHT) and three seats in the second (ROW_2_LEFT, ROW_2_CENTER, 856 * ROW_2_RIGHT) and third rows (ROW_3_LEFT, ROW_3_CENTER, ROW_3_RIGHT). There 857 * are three temperature control units -- driver side, passenger side, and rear. 858 * - A reasonable way to map HVAC_TEMPERATURE_SET to AreaIDs is a three 859 * element array: 860 * - ROW_1_LEFT 861 * - ROW_1_RIGHT 862 * - ROW_2_LEFT | ROW_2_CENTER | ROW_2_RIGHT | ROW_3_LEFT | ROW_3_CENTER | ROW_3_RIGHT 863 */ 864 865 /** 866 * Fan speed setting 867 * 868 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 869 * @access VehiclePropertyAccess:READ_WRITE 870 */ 871 HVAC_FAN_SPEED = ( 872 0x0500 873 | VehiclePropertyGroup:SYSTEM 874 | VehiclePropertyType:INT32 875 | VehicleArea:SEAT), 876 877 /** 878 * Fan direction setting 879 * 880 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 881 * @access VehiclePropertyAccess:READ_WRITE 882 * @data_enum VehicleHvacFanDirection 883 */ 884 HVAC_FAN_DIRECTION = ( 885 0x0501 886 | VehiclePropertyGroup:SYSTEM 887 | VehiclePropertyType:INT32 888 | VehicleArea:SEAT), 889 890 /** 891 * HVAC current temperature. 892 * 893 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 894 * @access VehiclePropertyAccess:READ 895 * @unit VehicleUnit:CELSIUS 896 */ 897 HVAC_TEMPERATURE_CURRENT = ( 898 0x0502 899 | VehiclePropertyGroup:SYSTEM 900 | VehiclePropertyType:FLOAT 901 | VehicleArea:SEAT), 902 903 /** 904 * HVAC, target temperature set. 905 * 906 * The configArray is used to indicate the valid values for HVAC in Fahrenheit and Celsius. 907 * Android might use it in the HVAC app UI. 908 * The configArray is set as follows: 909 * configArray[0] = [the lower bound of the supported temperature in Celsius] * 10. 910 * configArray[1] = [the upper bound of the supported temperature in Celsius] * 10. 911 * configArray[2] = [the increment in Celsius] * 10. 912 * configArray[3] = [the lower bound of the supported temperature in Fahrenheit] * 10. 913 * configArray[4] = [the upper bound of the supported temperature in Fahrenheit] * 10. 914 * configArray[5] = [the increment in Fahrenheit] * 10. 915 * For example, if the vehicle supports temperature values as: 916 * [16.0, 16.5, 17.0 ,..., 28.0] in Celsius 917 * [60.5, 61.5, 62.5 ,..., 85.5] in Fahrenheit. 918 * The configArray should be configArray = {160, 280, 5, 605, 825, 10}. 919 * 920 * If the vehicle supports HVAC_TEMPERATURE_VALUE_SUGGESTION, the application can use 921 * that property to get the suggested value before setting HVAC_TEMPERATURE_SET. Otherwise, 922 * the application may choose the value in HVAC_TEMPERATURE_SET configArray by itself. 923 * 924 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 925 * @access VehiclePropertyAccess:READ_WRITE 926 * @unit VehicleUnit:CELSIUS 927 */ 928 HVAC_TEMPERATURE_SET = ( 929 0x0503 930 | VehiclePropertyGroup:SYSTEM 931 | VehiclePropertyType:FLOAT 932 | VehicleArea:SEAT), 933 934 /** 935 * Fan-based defrost for designated window. 936 * 937 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 938 * @access VehiclePropertyAccess:READ_WRITE 939 */ 940 HVAC_DEFROSTER = ( 941 0x0504 942 | VehiclePropertyGroup:SYSTEM 943 | VehiclePropertyType:BOOLEAN 944 | VehicleArea:WINDOW), 945 946 /** 947 * On/off AC for designated areaId 948 * 949 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 950 * @access VehiclePropertyAccess:READ_WRITE 951 * @config_flags Supported areaIds 952 */ 953 HVAC_AC_ON = ( 954 0x0505 955 | VehiclePropertyGroup:SYSTEM 956 | VehiclePropertyType:BOOLEAN 957 | VehicleArea:SEAT), 958 959 /** 960 * On/off max AC 961 * 962 * When MAX AC is on, the ECU may adjust the vent position, fan speed, 963 * temperature, etc as necessary to cool the vehicle as quickly as possible. 964 * Any parameters modified as a side effect of turning on/off the MAX AC 965 * parameter shall generate onPropertyEvent() callbacks to the VHAL. 966 * 967 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 968 * @access VehiclePropertyAccess:READ_WRITE 969 */ 970 HVAC_MAX_AC_ON = ( 971 0x0506 972 | VehiclePropertyGroup:SYSTEM 973 | VehiclePropertyType:BOOLEAN 974 | VehicleArea:SEAT), 975 976 /** 977 * On/off max defrost 978 * 979 * When MAX DEFROST is on, the ECU may adjust the vent position, fan speed, 980 * temperature, etc as necessary to defrost the windows as quickly as 981 * possible. Any parameters modified as a side effect of turning on/off 982 * the MAX DEFROST parameter shall generate onPropertyEvent() callbacks to 983 * the VHAL. 984 * The AreaIDs for HVAC_MAX_DEFROST_ON indicate MAX DEFROST can be controlled 985 * in the area. 986 * For example: 987 * areaConfig.areaId = {ROW_1_LEFT | ROW_1_RIGHT} indicates HVAC_MAX_DEFROST_ON 988 * only can be controlled for the front rows. 989 * 990 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 991 * @access VehiclePropertyAccess:READ_WRITE 992 */ 993 HVAC_MAX_DEFROST_ON = ( 994 0x0507 995 | VehiclePropertyGroup:SYSTEM 996 | VehiclePropertyType:BOOLEAN 997 | VehicleArea:SEAT), 998 999 /** 1000 * Recirculation on/off 1001 * 1002 * Controls the supply of exterior air to the cabin. Recirc “on” means the 1003 * majority of the airflow into the cabin is originating in the cabin. 1004 * Recirc “off” means the majority of the airflow into the cabin is coming 1005 * from outside the car. 1006 * 1007 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1008 * @access VehiclePropertyAccess:READ_WRITE 1009 */ 1010 HVAC_RECIRC_ON = ( 1011 0x0508 1012 | VehiclePropertyGroup:SYSTEM 1013 | VehiclePropertyType:BOOLEAN 1014 | VehicleArea:SEAT), 1015 1016 /** 1017 * Enable temperature coupling between areas. 1018 * 1019 * The AreaIDs for HVAC_DUAL_ON property shall contain a combination of 1020 * HVAC_TEMPERATURE_SET AreaIDs that can be coupled together. If 1021 * HVAC_TEMPERATURE_SET is mapped to AreaIDs [a_1, a_2, ..., a_n], and if 1022 * HVAC_DUAL_ON can be enabled to couple a_i and a_j, then HVAC_DUAL_ON 1023 * property must be mapped to [a_i | a_j]. Further, if a_k and a_l can also 1024 * be coupled together separately then HVAC_DUAL_ON must be mapped to 1025 * [a_i | a_j, a_k | a_l]. 1026 * 1027 * Example: A car has two front seats (ROW_1_LEFT, ROW_1_RIGHT) and three 1028 * back seats (ROW_2_LEFT, ROW_2_CENTER, ROW_2_RIGHT). There are two 1029 * temperature control units -- driver side and passenger side -- which can 1030 * be optionally synchronized. This may be expressed in the AreaIDs this way: 1031 * - HVAC_TEMPERATURE_SET->[ROW_1_LEFT | ROW_2_LEFT, ROW_1_RIGHT | ROW_2_CENTER | ROW_2_RIGHT] 1032 * - HVAC_DUAL_ON->[ROW_1_LEFT | ROW_2_LEFT | ROW_1_RIGHT | ROW_2_CENTER | ROW_2_RIGHT] 1033 * 1034 * When the property is enabled, the ECU must synchronize the temperature 1035 * for the affected areas. Any parameters modified as a side effect 1036 * of turning on/off the DUAL_ON parameter shall generate 1037 * onPropertyEvent() callbacks to the VHAL. In addition, if setting 1038 * a temperature (i.e. driver's temperature) changes another temperature 1039 * (i.e. front passenger's temperature), then the appropriate 1040 * onPropertyEvent() callbacks must be generated. If a user changes a 1041 * temperature that breaks the coupling (e.g. setting the passenger 1042 * temperature independently) then the VHAL must send the appropriate 1043 * onPropertyEvent() callbacks (i.e. HVAC_DUAL_ON = false, 1044 * HVAC_TEMPERATURE_SET[AreaID] = xxx, etc). 1045 * 1046 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1047 * @access VehiclePropertyAccess:READ_WRITE 1048 */ 1049 HVAC_DUAL_ON = ( 1050 0x0509 1051 | VehiclePropertyGroup:SYSTEM 1052 | VehiclePropertyType:BOOLEAN 1053 | VehicleArea:SEAT), 1054 1055 /** 1056 * On/off automatic mode 1057 * 1058 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1059 * @access VehiclePropertyAccess:READ_WRITE 1060 */ 1061 HVAC_AUTO_ON = ( 1062 0x050A 1063 | VehiclePropertyGroup:SYSTEM 1064 | VehiclePropertyType:BOOLEAN 1065 | VehicleArea:SEAT), 1066 1067 /** 1068 * Seat heating/cooling 1069 * 1070 * Negative values indicate cooling. 1071 * 0 indicates off. 1072 * Positive values indicate heating. 1073 * 1074 * Some vehicles may have multiple levels of heating and cooling. The 1075 * min/max range defines the allowable range and number of steps in each 1076 * direction. 1077 * 1078 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1079 * @access VehiclePropertyAccess:READ_WRITE 1080 */ 1081 HVAC_SEAT_TEMPERATURE = ( 1082 0x050B 1083 | VehiclePropertyGroup:SYSTEM 1084 | VehiclePropertyType:INT32 1085 | VehicleArea:SEAT), 1086 1087 /** 1088 * Side Mirror Heat 1089 * 1090 * Increasing values denote higher heating levels for side mirrors. 1091 * The Max value in the config data represents the highest heating level. 1092 * The Min value in the config data MUST be zero and indicates no heating. 1093 * 1094 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1095 * @access VehiclePropertyAccess:READ_WRITE 1096 */ 1097 HVAC_SIDE_MIRROR_HEAT = ( 1098 0x050C 1099 | VehiclePropertyGroup:SYSTEM 1100 | VehiclePropertyType:INT32 1101 | VehicleArea:MIRROR), 1102 1103 /** 1104 * Steering Wheel Heating/Cooling 1105 * 1106 * Sets the amount of heating/cooling for the steering wheel 1107 * config data Min and Max MUST be set appropriately. 1108 * Positive value indicates heating. 1109 * Negative value indicates cooling. 1110 * 0 indicates temperature control is off. 1111 * 1112 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1113 * @access VehiclePropertyAccess:READ_WRITE 1114 */ 1115 HVAC_STEERING_WHEEL_HEAT = ( 1116 0x050D 1117 | VehiclePropertyGroup:SYSTEM 1118 | VehiclePropertyType:INT32 1119 | VehicleArea:GLOBAL), 1120 1121 /** 1122 * Temperature units for display 1123 * 1124 * Indicates whether the vehicle is displaying temperature to the user as 1125 * Celsius or Fahrenheit. 1126 * VehiclePropConfig.configArray is used to indicate the supported temperature display units. 1127 * For example: configArray[0] = CELSIUS 1128 * configArray[1] = FAHRENHEIT 1129 * 1130 * This parameter MAY be used for displaying any HVAC temperature in the system. 1131 * Values must be one of VehicleUnit::CELSIUS or VehicleUnit::FAHRENHEIT 1132 * Note that internally, all temperatures are represented in floating point Celsius. 1133 * 1134 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1135 * @access VehiclePropertyAccess:READ_WRITE 1136 * @data_enum VehicleUnit 1137 */ 1138 HVAC_TEMPERATURE_DISPLAY_UNITS = ( 1139 0x050E 1140 | VehiclePropertyGroup:SYSTEM 1141 | VehiclePropertyType:INT32 1142 | VehicleArea:GLOBAL), 1143 1144 /** 1145 * Actual fan speed 1146 * 1147 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1148 * @access VehiclePropertyAccess:READ 1149 */ 1150 HVAC_ACTUAL_FAN_SPEED_RPM = ( 1151 0x050F 1152 | VehiclePropertyGroup:SYSTEM 1153 | VehiclePropertyType:INT32 1154 | VehicleArea:SEAT), 1155 1156 /** 1157 * Represents global power state for HVAC. Setting this property to false 1158 * MAY mark some properties that control individual HVAC features/subsystems 1159 * to UNAVAILABLE state. Setting this property to true MAY mark some 1160 * properties that control individual HVAC features/subsystems to AVAILABLE 1161 * state (unless any/all of them are UNAVAILABLE on their own individual 1162 * merits). 1163 * 1164 * [Definition] HvacPower_DependentProperties: Properties that need HVAC to be 1165 * powered on in order to enable their functionality. For example, in some cars, 1166 * in order to turn on the AC, HVAC must be powered on first. 1167 * 1168 * HvacPower_DependentProperties list must be set in the 1169 * VehiclePropConfig.configArray. HvacPower_DependentProperties must only contain 1170 * properties that are associated with VehicleArea:SEAT. Properties that are not 1171 * associated with VehicleArea:SEAT, for example, HVAC_DEFROSTER, must never 1172 * depend on HVAC_POWER_ON property and must never be part of 1173 * HvacPower_DependentProperties list. 1174 * 1175 * AreaID mapping for HVAC_POWER_ON property must contain all AreaIDs that 1176 * HvacPower_DependentProperties are mapped to. 1177 * 1178 * Example 1: A car has two front seats (ROW_1_LEFT, ROW_1_RIGHT) and three back 1179 * seats (ROW_2_LEFT, ROW_2_CENTER, ROW_2_RIGHT). If the HVAC features (AC, 1180 * Temperature etc.) throughout the car are dependent on a single HVAC power 1181 * controller then HVAC_POWER_ON must be mapped to 1182 * [ROW_1_LEFT | ROW_1_RIGHT | ROW_2_LEFT | ROW_2_CENTER | ROW_2_RIGHT]. 1183 * 1184 * Example 2: A car has two seats in the front row (ROW_1_LEFT, ROW_1_RIGHT) and 1185 * three seats in the second (ROW_2_LEFT, ROW_2_CENTER, ROW_2_RIGHT) and third 1186 * rows (ROW_3_LEFT, ROW_3_CENTER, ROW_3_RIGHT). If the car has temperature 1187 * controllers in the front row which can operate entirely independently of 1188 * temperature controllers in the back of the vehicle, then HVAC_POWER_ON 1189 * must be mapped to a two element array: 1190 * - ROW_1_LEFT | ROW_1_RIGHT 1191 * - ROW_2_LEFT | ROW_2_CENTER | ROW_2_RIGHT | ROW_3_LEFT | ROW_3_CENTER | ROW_3_RIGHT 1192 * 1193 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1194 * @access VehiclePropertyAccess:READ_WRITE 1195 */ 1196 HVAC_POWER_ON = ( 1197 0x0510 1198 | VehiclePropertyGroup:SYSTEM 1199 | VehiclePropertyType:BOOLEAN 1200 | VehicleArea:SEAT), 1201 1202 /** 1203 * Fan Positions Available 1204 * 1205 * This is a bit mask of fan positions available for the zone. Each 1206 * available fan direction is denoted by a separate entry in the vector. A 1207 * fan direction may have multiple bits from vehicle_hvac_fan_direction set. 1208 * For instance, a typical car may have the following fan positions: 1209 * - FAN_DIRECTION_FACE (0x1) 1210 * - FAN_DIRECTION_FLOOR (0x2) 1211 * - FAN_DIRECTION_FACE | FAN_DIRECTION_FLOOR (0x3) 1212 * - FAN_DIRECTION_DEFROST (0x4) 1213 * - FAN_DIRECTION_FLOOR | FAN_DIRECTION_DEFROST (0x6) 1214 * 1215 * @change_mode VehiclePropertyChangeMode:STATIC 1216 * @access VehiclePropertyAccess:READ 1217 * @data_enum VehicleHvacFanDirection 1218 */ 1219 HVAC_FAN_DIRECTION_AVAILABLE = ( 1220 0x0511 1221 | VehiclePropertyGroup:SYSTEM 1222 | VehiclePropertyType:INT32_VEC 1223 | VehicleArea:SEAT), 1224 1225 /** 1226 * Automatic recirculation on/off 1227 * 1228 * When automatic recirculation is ON, the HVAC system may automatically 1229 * switch to recirculation mode if the vehicle detects poor incoming air 1230 * quality. 1231 * 1232 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1233 * @access VehiclePropertyAccess:READ_WRITE 1234 */ 1235 HVAC_AUTO_RECIRC_ON = ( 1236 0x0512 1237 | VehiclePropertyGroup:SYSTEM 1238 | VehiclePropertyType:BOOLEAN 1239 | VehicleArea:SEAT), 1240 1241 /** 1242 * Seat ventilation 1243 * 1244 * 0 indicates off. 1245 * Positive values indicates ventilation level. 1246 * 1247 * Used by HVAC apps and Assistant to enable, change, or read state of seat 1248 * ventilation. This is different than seating cooling. It can be on at the 1249 * same time as cooling, or not. 1250 * 1251 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1252 * @access VehiclePropertyAccess:READ_WRITE 1253 */ 1254 HVAC_SEAT_VENTILATION = ( 1255 0x0513 1256 | VehiclePropertyGroup:SYSTEM 1257 | VehiclePropertyType:INT32 1258 | VehicleArea:SEAT), 1259 1260 /** 1261 * Electric defrosters' status 1262 * 1263 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1264 * @access VehiclePropertyAccess:READ_WRITE 1265 */ 1266 HVAC_ELECTRIC_DEFROSTER_ON = ( 1267 0x0514 1268 | VehiclePropertyGroup:SYSTEM 1269 | VehiclePropertyType:BOOLEAN 1270 | VehicleArea:WINDOW), 1271 1272 /** 1273 * Suggested values for setting HVAC temperature. 1274 * 1275 * Implement the property to help applications understand the closest supported temperature 1276 * value in Celsius or Fahrenheit. 1277 * 1278 * floatValues[0] = the requested value that an application wants to set a temperature to. 1279 * floatValues[1] = the unit for floatValues[0]. It should be one of 1280 * {VehicleUnit:CELSIUS, VehicleUnit:FAHRENHEIT}. 1281 * floatValues[2] = the value OEMs suggested in CELSIUS. This value is not included 1282 * in the request. 1283 * floatValues[3] = the value OEMs suggested in FAHRENHEIT. This value is not included 1284 * in the request. 1285 * 1286 * An application calls set(VehiclePropValue propValue) with the requested value and unit for 1287 * the value. OEMs need to return the suggested values in floatValues[2] and floatValues[3] by 1288 * onPropertyEvent() callbacks. 1289 * 1290 * For example, when a user uses the voice assistant to set HVAC temperature to 66.2 in 1291 * Fahrenheit. 1292 * First, an application will set this property with the value 1293 * [66.2, (float)VehicleUnit:FAHRENHEIT,0,0]. 1294 * If OEMs suggest to set 19.0 in Celsius or 66.5 in Fahrenheit for user's request, then VHAL 1295 * must generate a callback with property value 1296 * [66.2, (float)VehicleUnit:FAHRENHEIT, 19.0, 66.5]. After the voice assistant gets the 1297 * callback, it will inform the user and set HVAC temperature to the suggested value. 1298 * 1299 * Another example, an application receives 21 Celsius as the current temperature value by 1300 * querying HVC_TEMPERATURE_SET. But the application wants to know what value is displayed on 1301 * the car's UI in Fahrenheit. 1302 * For this, the application sets the property to [21, (float)VehicleUnit:CELSIUS, 0, 0]. If 1303 * the suggested value by the OEM for 21 Celsius is 70 Fahrenheit, then VHAL must generate a 1304 * callback with property value [21, (float)VehicleUnit:CELSIUS, 21.0, 70.0]. 1305 * In this case, the application can know that the value is 70.0 Fahrenheit in the car’s UI. 1306 * 1307 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1308 * @access VehiclePropertyAccess:READ_WRITE 1309 */ 1310 HVAC_TEMPERATURE_VALUE_SUGGESTION = ( 1311 0x0515 1312 | VehiclePropertyGroup:SYSTEM 1313 | VehiclePropertyType:FLOAT_VEC 1314 | VehicleArea:GLOBAL), 1315 1316 /** 1317 * Distance units for display 1318 * 1319 * Indicates which units the car is using to display distances to the user. Eg. Mile, Meter 1320 * Kilometer. 1321 * 1322 * Distance units are defined in VehicleUnit. 1323 * VehiclePropConfig.configArray is used to indicate the supported distance display units. 1324 * For example: configArray[0] = METER 1325 * configArray[1] = KILOMETER 1326 * configArray[2] = MILE 1327 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1328 * @access VehiclePropertyAccess:READ_WRITE 1329 * @data_enum VehicleUnit 1330 */ 1331 DISTANCE_DISPLAY_UNITS = ( 1332 0x0600 1333 | VehiclePropertyGroup:SYSTEM 1334 | VehiclePropertyType:INT32 1335 | VehicleArea:GLOBAL), 1336 1337 /** 1338 * Fuel volume units for display 1339 * 1340 * Indicates which units the car is using to display fuel volume to the user. Eg. Liter or 1341 * Gallon. 1342 * 1343 * VehiclePropConfig.configArray is used to indicate the supported fuel volume display units. 1344 * Volume units are defined in VehicleUnit. 1345 * For example: configArray[0] = LITER 1346 * configArray[1] = GALLON 1347 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1348 * @access VehiclePropertyAccess:READ_WRITE 1349 * @data_enum VehicleUnit 1350 */ 1351 FUEL_VOLUME_DISPLAY_UNITS = ( 1352 0x0601 1353 | VehiclePropertyGroup:SYSTEM 1354 | VehiclePropertyType:INT32 1355 | VehicleArea:GLOBAL), 1356 1357 /** 1358 * Tire pressure units for display 1359 * 1360 * Indicates which units the car is using to display tire pressure to the user. Eg. PSI, Bar or 1361 * Kilopascal. 1362 * 1363 * VehiclePropConfig.configArray is used to indicate the supported pressure display units. 1364 * Pressure units are defined in VehicleUnit. 1365 * For example: configArray[0] = KILOPASCAL 1366 * configArray[1] = PSI 1367 * configArray[2] = BAR 1368 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1369 * @access VehiclePropertyAccess:READ_WRITE 1370 * @data_enum VehicleUnit 1371 */ 1372 TIRE_PRESSURE_DISPLAY_UNITS = ( 1373 0x0602 1374 | VehiclePropertyGroup:SYSTEM 1375 | VehiclePropertyType:INT32 1376 | VehicleArea:GLOBAL), 1377 1378 /** 1379 * EV battery units for display 1380 * 1381 * Indicates which units the car is using to display EV battery information to the user. Eg. 1382 * watt-hours(Wh), kilowatt-hours(kWh) or ampere-hours(Ah). 1383 * 1384 * VehiclePropConfig.configArray is used to indicate the supported electrical energy units. 1385 * Electrical energy units are defined in VehicleUnit. 1386 * For example: configArray[0] = WATT_HOUR 1387 * configArray[1] = AMPERE_HOURS 1388 * configArray[2] = KILOWATT_HOUR 1389 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1390 * @access VehiclePropertyAccess:READ_WRITE 1391 * @data_enum VehicleUnit 1392 */ 1393 EV_BATTERY_DISPLAY_UNITS = ( 1394 0x0603 1395 | VehiclePropertyGroup:SYSTEM 1396 | VehiclePropertyType:INT32 1397 | VehicleArea:GLOBAL), 1398 1399 /** 1400 * Fuel consumption units for display 1401 * 1402 * Indicates type of units the car is using to display fuel consumption information to user 1403 * True indicates units are distance over volume such as MPG. 1404 * False indicates units are volume over distance such as L/100KM. 1405 * 1406 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1407 * @access VehiclePropertyAccess:READ_WRITE 1408 */ 1409 FUEL_CONSUMPTION_UNITS_DISTANCE_OVER_VOLUME = ( 1410 0x0604 1411 | VehiclePropertyGroup:SYSTEM 1412 | VehiclePropertyType:BOOLEAN 1413 | VehicleArea:GLOBAL), 1414 1415 /** 1416 * Speed units for display 1417 * 1418 * Indicates type of units the car is using to display speed to user. Eg. m/s, km/h, or mph. 1419 * 1420 * VehiclePropConfig.configArray is used to indicate the supported speed display units. 1421 * Pressure units are defined in VehicleUnit. 1422 * For example: configArray[0] = METER_PER_SEC 1423 * configArray[1] = MILES_PER_HOUR 1424 * configArray[2] = KILOMETERS_PER_HOUR 1425 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1426 * @access VehiclePropertyAccess:READ_WRITE 1427 */ 1428 VEHICLE_SPEED_DISPLAY_UNITS = ( 1429 0x0605 1430 | VehiclePropertyGroup:SYSTEM 1431 | VehiclePropertyType:INT32 1432 | VehicleArea:GLOBAL), 1433 1434 /** 1435 * Current date and time, encoded as Unix time (in milliseconds). 1436 * This value denotes the number of milliseconds seconds that have 1437 * elapsed since 1/1/1970 UTC. 1438 * 1439 * AAOS will write to this value to give VHAL the Android system's time, 1440 * if the VHAL supports this property. This can be useful to synchronize 1441 * other vehicle systems (dash clock etc) with Android's time. 1442 * 1443 * AAOS writes to this property once during boot, and 1444 * will thereafter write only when some time-source changes are propagated. 1445 * AAOS will fill in VehiclePropValue.timestamp correctly. 1446 * Note that AAOS will not send updates for natural elapse of time. 1447 * int64Values[0] = provided Unix time (in milliseconds) 1448 * 1449 * Note that the property may take >0 ms to get propagated through the stack 1450 * and, having a timestamped property helps reduce any time drift. So, 1451 * for all writes to the property, the timestamp can be used to negate this 1452 * drift: 1453 * drift = currentTimeMillis - PropValue.timestamp 1454 * effectiveTime = PropValue.value.int64Values[0] + diff 1455 * 1456 * Aside, this property could have been better named ANDROID_EPOCH_TIME, but it 1457 * continues to be called EPOCH_TIME for legacy reasons. We will try to fix 1458 * this naming discrepancy when we migrate to AIDL. 1459 * 1460 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1461 * @access VehiclePropertyAccess:WRITE_ONLY 1462 * @unit VehicleUnit:MILLI_SECS 1463 */ 1464 EPOCH_TIME = ( 1465 0x0606 1466 | VehiclePropertyGroup:SYSTEM 1467 | VehiclePropertyType:INT64 1468 | VehicleArea:GLOBAL), 1469 1470 /** 1471 * External encryption binding seed. 1472 * 1473 * This value is mixed with the local key storage encryption key. 1474 * This property holds 16 bytes, and is expected to be persisted on an ECU separate from 1475 * the IVI. The property is initially set by AAOS, who generates it using a CSRNG. 1476 * AAOS will then read the property on subsequent boots. The binding seed is expected to be 1477 * reliably persisted. Any loss of the seed results in a factory reset of the IVI. 1478 * 1479 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1480 * @access VehiclePropertyAccess:READ_WRITE 1481 */ 1482 STORAGE_ENCRYPTION_BINDING_SEED = ( 1483 0x0607 1484 | VehiclePropertyGroup:SYSTEM 1485 | VehiclePropertyType:BYTES 1486 | VehicleArea:GLOBAL), 1487 1488 /** 1489 * Outside temperature 1490 * 1491 * @change_mode VehiclePropertyChangeMode:CONTINUOUS 1492 * @access VehiclePropertyAccess:READ 1493 * @unit VehicleUnit:CELSIUS 1494 */ 1495 ENV_OUTSIDE_TEMPERATURE = ( 1496 0x0703 1497 | VehiclePropertyGroup:SYSTEM 1498 | VehiclePropertyType:FLOAT 1499 | VehicleArea:GLOBAL), 1500 1501 /** 1502 * Property to control power state of application processor 1503 * 1504 * It is assumed that AP's power state is controlled by a separate power 1505 * controller. 1506 * 1507 * For configuration information, VehiclePropConfig.configArray can have bit flag combining 1508 * values in VehicleApPowerStateConfigFlag. 1509 * 1510 * int32Values[0] : VehicleApPowerStateReq enum value 1511 * int32Values[1] : additional parameter relevant for each state, 1512 * 0 if not used. 1513 * 1514 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1515 * @access VehiclePropertyAccess:READ 1516 */ 1517 AP_POWER_STATE_REQ = ( 1518 0x0A00 1519 | VehiclePropertyGroup:SYSTEM 1520 | VehiclePropertyType:INT32_VEC 1521 | VehicleArea:GLOBAL), 1522 1523 /** 1524 * Property to report power state of application processor 1525 * 1526 * It is assumed that AP's power state is controller by separate power 1527 * controller. 1528 * 1529 * int32Values[0] : VehicleApPowerStateReport enum value 1530 * int32Values[1] : Time in ms to wake up, if necessary. Otherwise 0. 1531 1532 * 1533 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1534 * @access VehiclePropertyAccess:READ_WRITE 1535 */ 1536 AP_POWER_STATE_REPORT = ( 1537 0x0A01 1538 | VehiclePropertyGroup:SYSTEM 1539 | VehiclePropertyType:INT32_VEC 1540 | VehicleArea:GLOBAL), 1541 1542 /** 1543 * Property to report bootup reason for the current power on. This is a 1544 * static property that will not change for the whole duration until power 1545 * off. For example, even if user presses power on button after automatic 1546 * power on with door unlock, bootup reason must stay with 1547 * VehicleApPowerBootupReason#USER_UNLOCK. 1548 * 1549 * int32Values[0] must be VehicleApPowerBootupReason. 1550 * 1551 * @change_mode VehiclePropertyChangeMode:STATIC 1552 * @access VehiclePropertyAccess:READ 1553 */ 1554 AP_POWER_BOOTUP_REASON = ( 1555 0x0A02 1556 | VehiclePropertyGroup:SYSTEM 1557 | VehiclePropertyType:INT32 1558 | VehicleArea:GLOBAL), 1559 1560 /** 1561 * Property to represent brightness of the display. Some cars have single 1562 * control for the brightness of all displays and this property is to share 1563 * change in that control. 1564 * 1565 * If this is writable, android side can set this value when user changes 1566 * display brightness from Settings. If this is read only, user may still 1567 * change display brightness from Settings, but that must not be reflected 1568 * to other displays. 1569 * 1570 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1571 * @access VehiclePropertyAccess:READ_WRITE 1572 */ 1573 DISPLAY_BRIGHTNESS = ( 1574 0x0A03 1575 | VehiclePropertyGroup:SYSTEM 1576 | VehiclePropertyType:INT32 1577 | VehicleArea:GLOBAL), 1578 1579 /** 1580 * Property to feed H/W input events to android 1581 * 1582 * int32Values[0] : action defined by VehicleHwKeyInputAction 1583 * int32Values[1] : key code, must use standard android key code 1584 * int32Values[2] : target display defined in VehicleDisplay. Events not 1585 * tied to specific display must be sent to 1586 * VehicleDisplay#MAIN. 1587 * int32Values[3] : [optional] Number of ticks. The value must be equal or 1588 * greater than 1. When omitted, Android will default to 1. 1589 * 1590 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1591 * @access VehiclePropertyAccess:READ 1592 * @config_flags 1593 */ 1594 HW_KEY_INPUT = ( 1595 0x0A10 1596 | VehiclePropertyGroup:SYSTEM 1597 | VehiclePropertyType:INT32_VEC 1598 | VehicleArea:GLOBAL), 1599 1600 /** 1601 * Property to feed H/W rotary events to android 1602 * 1603 * int32Values[0] : RotaryInputType identifying which rotary knob rotated 1604 * int32Values[1] : number of detents (clicks), positive for clockwise, 1605 * negative for counterclockwise 1606 * int32Values[2] : target display defined in VehicleDisplay. Events not 1607 * tied to specific display must be sent to 1608 * VehicleDisplay#MAIN. 1609 * int32values[3 .. 3 + abs(number of detents) - 2]: 1610 * nanosecond deltas between pairs of consecutive detents, 1611 * if the number of detents is > 1 or < -1 1612 * 1613 * VehiclePropValue.timestamp: when the rotation occurred. If the number of 1614 * detents is > 1 or < -1, this is when the 1615 * first detent of rotation occurred. 1616 * 1617 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1618 * @data_enum RotaryInputType 1619 * @access VehiclePropertyAccess:READ 1620 */ 1621 HW_ROTARY_INPUT = ( 1622 0x0A20 1623 | VehiclePropertyGroup:SYSTEM 1624 | VehiclePropertyType:INT32_VEC 1625 | VehicleArea:GLOBAL), 1626 1627 /** 1628 * Defines a custom OEM partner input event. 1629 * 1630 * This input event must be used by OEM partners who wish to propagate events not supported 1631 * by Android. It is composed by an array of int32 values only. 1632 * 1633 * The Android properties are: 1634 * 1635 * int32Values[0] : Input code identifying the function representing this event. Valid event 1636 * types are defined by CustomInputType.CUSTOM_EVENT_F1 up to 1637 * CustomInputType.CUSTOM_EVENT_F10. They represent the custom event to be 1638 * defined by OEM partners. 1639 * int32Values[1] : target display type defined in VehicleDisplay. Events not tied to specific 1640 * display must be sent to VehicleDisplay#MAIN. 1641 * int32Values[2] : repeat counter, if 0 then event is not repeated. Values 1 or above means 1642 * how many times this event repeated. 1643 * 1644 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1645 * @data_enum CustomInputType 1646 * @access VehiclePropertyAccess:READ 1647 */ 1648 HW_CUSTOM_INPUT = ( 1649 0X0A30 1650 | VehiclePropertyGroup:SYSTEM 1651 | VehiclePropertyType:INT32_VEC 1652 | VehicleArea:GLOBAL), 1653 1654 /*************************************************************************** 1655 * Most Car Cabin properties have both a POSition and MOVE parameter. These 1656 * are used to control the various movements for seats, doors, and windows 1657 * in a vehicle. 1658 * 1659 * A POS parameter allows the user to set the absolution position. For 1660 * instance, for a door, 0 indicates fully closed and max value indicates 1661 * fully open. Thus, a value halfway between min and max must indicate 1662 * the door is halfway open. 1663 * 1664 * A MOVE parameter moves the device in a particular direction. The sign 1665 * indicates direction, and the magnitude indicates speed (if multiple 1666 * speeds are available). For a door, a move of -1 will close the door, and 1667 * a move of +1 will open it. Once a door reaches the limit of open/close, 1668 * the door should automatically stop moving. The user must NOT need to 1669 * send a MOVE(0) command to stop the door at the end of its range. 1670 **************************************************************************/ 1671 1672 /** 1673 * Door position 1674 * 1675 * This is an integer in case a door may be set to a particular position. 1676 * Max value indicates fully open, min value (0) indicates fully closed. 1677 * 1678 * Some vehicles (minivans) can open the door electronically. Hence, the 1679 * ability to write this property. 1680 * 1681 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1682 * @access VehiclePropertyAccess:READ_WRITE 1683 */ 1684 DOOR_POS = ( 1685 0x0B00 1686 | VehiclePropertyGroup:SYSTEM 1687 | VehiclePropertyType:INT32 1688 | VehicleArea:DOOR), 1689 1690 /** 1691 * Door move 1692 * 1693 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1694 * @access VehiclePropertyAccess:READ_WRITE 1695 */ 1696 DOOR_MOVE = ( 1697 0x0B01 1698 | VehiclePropertyGroup:SYSTEM 1699 | VehiclePropertyType:INT32 1700 | VehicleArea:DOOR), 1701 1702 /** 1703 * Door lock 1704 * 1705 * 'true' indicates door is locked 1706 * 1707 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1708 * @access VehiclePropertyAccess:READ_WRITE 1709 */ 1710 DOOR_LOCK = ( 1711 0x0B02 1712 | VehiclePropertyGroup:SYSTEM 1713 | VehiclePropertyType:BOOLEAN 1714 | VehicleArea:DOOR), 1715 1716 /** 1717 * Mirror Z Position 1718 * 1719 * Positive value indicates tilt upwards, negative value is downwards 1720 * 1721 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1722 * @access VehiclePropertyAccess:READ_WRITE 1723 */ 1724 MIRROR_Z_POS = ( 1725 0x0B40 1726 | VehiclePropertyGroup:SYSTEM 1727 | VehiclePropertyType:INT32 1728 | VehicleArea:MIRROR), 1729 1730 /** 1731 * Mirror Z Move 1732 * 1733 * Positive value indicates tilt upwards, negative value is downwards 1734 * 1735 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1736 * @access VehiclePropertyAccess:READ_WRITE 1737 */ 1738 MIRROR_Z_MOVE = ( 1739 0x0B41 1740 | VehiclePropertyGroup:SYSTEM 1741 | VehiclePropertyType:INT32 1742 | VehicleArea:MIRROR), 1743 1744 /** 1745 * Mirror Y Position 1746 * 1747 * Positive value indicate tilt right, negative value is left 1748 * 1749 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1750 * @access VehiclePropertyAccess:READ_WRITE 1751 */ 1752 MIRROR_Y_POS = ( 1753 0x0B42 1754 | VehiclePropertyGroup:SYSTEM 1755 | VehiclePropertyType:INT32 1756 | VehicleArea:MIRROR), 1757 1758 /** 1759 * Mirror Y Move 1760 * 1761 * Positive value indicate tilt right, negative value is left 1762 * 1763 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1764 * @access VehiclePropertyAccess:READ_WRITE 1765 */ 1766 MIRROR_Y_MOVE = ( 1767 0x0B43 1768 | VehiclePropertyGroup:SYSTEM 1769 | VehiclePropertyType:INT32 1770 | VehicleArea:MIRROR), 1771 1772 /** 1773 * Mirror Lock 1774 * 1775 * True indicates mirror positions are locked and not changeable 1776 * 1777 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1778 * @access VehiclePropertyAccess:READ_WRITE 1779 */ 1780 MIRROR_LOCK = ( 1781 0x0B44 1782 | VehiclePropertyGroup:SYSTEM 1783 | VehiclePropertyType:BOOLEAN 1784 | VehicleArea:GLOBAL), 1785 1786 /** 1787 * Mirror Fold 1788 * 1789 * True indicates mirrors are folded 1790 * 1791 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1792 * @access VehiclePropertyAccess:READ_WRITE 1793 */ 1794 MIRROR_FOLD = ( 1795 0x0B45 1796 | VehiclePropertyGroup:SYSTEM 1797 | VehiclePropertyType:BOOLEAN 1798 | VehicleArea:GLOBAL), 1799 1800 /** 1801 * Seat memory select 1802 * 1803 * This parameter selects the memory preset to use to select the seat 1804 * position. The minValue is always 0, and the maxValue determines the 1805 * number of seat positions available. 1806 * 1807 * For instance, if the driver's seat has 3 memory presets, the maxValue 1808 * will be 3. When the user wants to select a preset, the desired preset 1809 * number (1, 2, or 3) is set. 1810 * 1811 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1812 * @access VehiclePropertyAccess:WRITE 1813 */ 1814 SEAT_MEMORY_SELECT = ( 1815 0x0B80 1816 | VehiclePropertyGroup:SYSTEM 1817 | VehiclePropertyType:INT32 1818 | VehicleArea:SEAT), 1819 1820 /** 1821 * Seat memory set 1822 * 1823 * This setting allows the user to save the current seat position settings 1824 * into the selected preset slot. The maxValue for each seat position 1825 * must match the maxValue for SEAT_MEMORY_SELECT. 1826 * 1827 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1828 * @access VehiclePropertyAccess:WRITE 1829 */ 1830 SEAT_MEMORY_SET = ( 1831 0x0B81 1832 | VehiclePropertyGroup:SYSTEM 1833 | VehiclePropertyType:INT32 1834 | VehicleArea:SEAT), 1835 1836 /** 1837 * Seatbelt buckled 1838 * 1839 * True indicates belt is buckled. 1840 * 1841 * Write access indicates automatic seat buckling capabilities. There are 1842 * no known cars at this time, but you never know... 1843 * 1844 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1845 * @access VehiclePropertyAccess:READ_WRITE 1846 */ 1847 SEAT_BELT_BUCKLED = ( 1848 0x0B82 1849 | VehiclePropertyGroup:SYSTEM 1850 | VehiclePropertyType:BOOLEAN 1851 | VehicleArea:SEAT), 1852 1853 /** 1854 * Seatbelt height position 1855 * 1856 * Adjusts the shoulder belt anchor point. 1857 * Max value indicates highest position 1858 * Min value indicates lowest position 1859 * 1860 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1861 * @access VehiclePropertyAccess:READ_WRITE 1862 */ 1863 SEAT_BELT_HEIGHT_POS = ( 1864 0x0B83 1865 | VehiclePropertyGroup:SYSTEM 1866 | VehiclePropertyType:INT32 1867 | VehicleArea:SEAT), 1868 1869 /** 1870 * Seatbelt height move 1871 * 1872 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1873 * @access VehiclePropertyAccess:READ_WRITE 1874 */ 1875 SEAT_BELT_HEIGHT_MOVE = ( 1876 0x0B84 1877 | VehiclePropertyGroup:SYSTEM 1878 | VehiclePropertyType:INT32 1879 | VehicleArea:SEAT), 1880 1881 /** 1882 * Seat fore/aft position 1883 * 1884 * Sets the seat position forward (closer to steering wheel) and backwards. 1885 * Max value indicates closest to wheel, min value indicates most rearward 1886 * position. 1887 * 1888 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1889 * @access VehiclePropertyAccess:READ_WRITE 1890 */ 1891 SEAT_FORE_AFT_POS = ( 1892 0x0B85 1893 | VehiclePropertyGroup:SYSTEM 1894 | VehiclePropertyType:INT32 1895 | VehicleArea:SEAT), 1896 1897 /** 1898 * Seat fore/aft move 1899 * 1900 * Moves the seat position forward and aft. 1901 * 1902 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1903 * @access VehiclePropertyAccess:READ_WRITE 1904 */ 1905 SEAT_FORE_AFT_MOVE = ( 1906 0x0B86 1907 | VehiclePropertyGroup:SYSTEM 1908 | VehiclePropertyType:INT32 1909 | VehicleArea:SEAT), 1910 1911 /** 1912 * Seat backrest angle 1 position 1913 * 1914 * Backrest angle 1 is the actuator closest to the bottom of the seat. 1915 * Max value indicates angling forward towards the steering wheel. 1916 * Min value indicates full recline. 1917 * 1918 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1919 * @access VehiclePropertyAccess:READ_WRITE 1920 */ 1921 SEAT_BACKREST_ANGLE_1_POS = ( 1922 0x0B87 1923 | VehiclePropertyGroup:SYSTEM 1924 | VehiclePropertyType:INT32 1925 | VehicleArea:SEAT), 1926 1927 /** 1928 * Seat backrest angle 1 move 1929 * 1930 * Moves the backrest forward or recline. 1931 * 1932 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1933 * @access VehiclePropertyAccess:READ_WRITE 1934 */ 1935 SEAT_BACKREST_ANGLE_1_MOVE = ( 1936 0x0B88 1937 | VehiclePropertyGroup:SYSTEM 1938 | VehiclePropertyType:INT32 1939 | VehicleArea:SEAT), 1940 1941 /** 1942 * Seat backrest angle 2 position 1943 * 1944 * Backrest angle 2 is the next actuator up from the bottom of the seat. 1945 * Max value indicates angling forward towards the steering wheel. 1946 * Min value indicates full recline. 1947 * 1948 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1949 * @access VehiclePropertyAccess:READ_WRITE 1950 */ 1951 SEAT_BACKREST_ANGLE_2_POS = ( 1952 0x0B89 1953 | VehiclePropertyGroup:SYSTEM 1954 | VehiclePropertyType:INT32 1955 | VehicleArea:SEAT), 1956 1957 /** 1958 * Seat backrest angle 2 move 1959 * 1960 * Moves the backrest forward or recline. 1961 * 1962 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1963 * @access VehiclePropertyAccess:READ_WRITE 1964 */ 1965 SEAT_BACKREST_ANGLE_2_MOVE = ( 1966 0x0B8A 1967 | VehiclePropertyGroup:SYSTEM 1968 | VehiclePropertyType:INT32 1969 | VehicleArea:SEAT), 1970 1971 /** 1972 * Seat height position 1973 * 1974 * Sets the seat height. 1975 * Max value indicates highest position. 1976 * Min value indicates lowest position. 1977 * 1978 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1979 * @access VehiclePropertyAccess:READ_WRITE 1980 */ 1981 SEAT_HEIGHT_POS = ( 1982 0x0B8B 1983 | VehiclePropertyGroup:SYSTEM 1984 | VehiclePropertyType:INT32 1985 | VehicleArea:SEAT), 1986 1987 /** 1988 * Seat height move 1989 * 1990 * Moves the seat height. 1991 * 1992 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 1993 * @access VehiclePropertyAccess:READ_WRITE 1994 */ 1995 SEAT_HEIGHT_MOVE = ( 1996 0x0B8C 1997 | VehiclePropertyGroup:SYSTEM 1998 | VehiclePropertyType:INT32 1999 | VehicleArea:SEAT), 2000 2001 /** 2002 * Seat depth position 2003 * 2004 * Sets the seat depth, distance from back rest to front edge of seat. 2005 * Max value indicates longest depth position. 2006 * Min value indicates shortest position. 2007 * 2008 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2009 * @access VehiclePropertyAccess:READ_WRITE 2010 */ 2011 SEAT_DEPTH_POS = ( 2012 0x0B8D 2013 | VehiclePropertyGroup:SYSTEM 2014 | VehiclePropertyType:INT32 2015 | VehicleArea:SEAT), 2016 2017 /** 2018 * Seat depth move 2019 * 2020 * Adjusts the seat depth. 2021 * 2022 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2023 * @access VehiclePropertyAccess:READ_WRITE 2024 */ 2025 SEAT_DEPTH_MOVE = ( 2026 0x0B8E 2027 | VehiclePropertyGroup:SYSTEM 2028 | VehiclePropertyType:INT32 2029 | VehicleArea:SEAT), 2030 2031 /** 2032 * Seat tilt position 2033 * 2034 * Sets the seat tilt. 2035 * Max value indicates front edge of seat higher than back edge. 2036 * Min value indicates front edge of seat lower than back edge. 2037 * 2038 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2039 * @access VehiclePropertyAccess:READ_WRITE 2040 */ 2041 SEAT_TILT_POS = ( 2042 0x0B8F 2043 | VehiclePropertyGroup:SYSTEM 2044 | VehiclePropertyType:INT32 2045 | VehicleArea:SEAT), 2046 2047 /** 2048 * Seat tilt move 2049 * 2050 * Tilts the seat. 2051 * 2052 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2053 * @access VehiclePropertyAccess:READ_WRITE 2054 */ 2055 SEAT_TILT_MOVE = ( 2056 0x0B90 2057 | VehiclePropertyGroup:SYSTEM 2058 | VehiclePropertyType:INT32 2059 | VehicleArea:SEAT), 2060 2061 /** 2062 * Lumber fore/aft position 2063 * 2064 * Pushes the lumbar support forward and backwards 2065 * Max value indicates most forward position. 2066 * Min value indicates most rearward position. 2067 * 2068 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2069 * @access VehiclePropertyAccess:READ_WRITE 2070 */ 2071 SEAT_LUMBAR_FORE_AFT_POS = ( 2072 0x0B91 2073 | VehiclePropertyGroup:SYSTEM 2074 | VehiclePropertyType:INT32 2075 | VehicleArea:SEAT), 2076 2077 /** 2078 * Lumbar fore/aft move 2079 * 2080 * Adjusts the lumbar support. 2081 * 2082 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2083 * @access VehiclePropertyAccess:READ_WRITE 2084 */ 2085 SEAT_LUMBAR_FORE_AFT_MOVE = ( 2086 0x0B92 2087 | VehiclePropertyGroup:SYSTEM 2088 | VehiclePropertyType:INT32 2089 | VehicleArea:SEAT), 2090 2091 /** 2092 * Lumbar side support position 2093 * 2094 * Sets the amount of lateral lumbar support. 2095 * Max value indicates widest lumbar setting (i.e. least support) 2096 * Min value indicates thinnest lumbar setting. 2097 * 2098 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2099 * @access VehiclePropertyAccess:READ_WRITE 2100 */ 2101 SEAT_LUMBAR_SIDE_SUPPORT_POS = ( 2102 0x0B93 2103 | VehiclePropertyGroup:SYSTEM 2104 | VehiclePropertyType:INT32 2105 | VehicleArea:SEAT), 2106 2107 /** 2108 * Lumbar side support move 2109 * 2110 * Adjusts the amount of lateral lumbar support. 2111 * 2112 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2113 * @access VehiclePropertyAccess:READ_WRITE 2114 */ 2115 SEAT_LUMBAR_SIDE_SUPPORT_MOVE = ( 2116 0x0B94 2117 | VehiclePropertyGroup:SYSTEM 2118 | VehiclePropertyType:INT32 2119 | VehicleArea:SEAT), 2120 2121 /** 2122 * Headrest height position 2123 * 2124 * Sets the headrest height. 2125 * Max value indicates tallest setting. 2126 * Min value indicates shortest setting. 2127 * 2128 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2129 * @access VehiclePropertyAccess:READ_WRITE 2130 */ 2131 SEAT_HEADREST_HEIGHT_POS = ( 2132 0x0B95 2133 | VehiclePropertyGroup:SYSTEM 2134 | VehiclePropertyType:INT32 2135 | VehicleArea:GLOBAL), 2136 2137 /** 2138 * Headrest height move 2139 * 2140 * Moves the headrest up and down. 2141 * 2142 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2143 * @access VehiclePropertyAccess:READ_WRITE 2144 */ 2145 SEAT_HEADREST_HEIGHT_MOVE = ( 2146 0x0B96 2147 | VehiclePropertyGroup:SYSTEM 2148 | VehiclePropertyType:INT32 2149 | VehicleArea:SEAT), 2150 2151 /** 2152 * Headrest angle position 2153 * 2154 * Sets the angle of the headrest. 2155 * Max value indicates most upright angle. 2156 * Min value indicates shallowest headrest angle. 2157 * 2158 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2159 * @access VehiclePropertyAccess:READ_WRITE 2160 */ 2161 SEAT_HEADREST_ANGLE_POS = ( 2162 0x0B97 2163 | VehiclePropertyGroup:SYSTEM 2164 | VehiclePropertyType:INT32 2165 | VehicleArea:SEAT), 2166 2167 /** 2168 * Headrest angle move 2169 * 2170 * Adjusts the angle of the headrest 2171 * 2172 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2173 * @access VehiclePropertyAccess:READ_WRITE 2174 */ 2175 SEAT_HEADREST_ANGLE_MOVE = ( 2176 0x0B98 2177 | VehiclePropertyGroup:SYSTEM 2178 | VehiclePropertyType:INT32 2179 | VehicleArea:SEAT), 2180 2181 /** 2182 * Headrest fore/aft position 2183 * 2184 * Adjusts the headrest forwards and backwards. 2185 * Max value indicates position closest to front of car. 2186 * Min value indicates position closest to rear of car. 2187 * 2188 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2189 * @access VehiclePropertyAccess:READ_WRITE 2190 */ 2191 SEAT_HEADREST_FORE_AFT_POS = ( 2192 0x0B99 2193 | VehiclePropertyGroup:SYSTEM 2194 | VehiclePropertyType:INT32 2195 | VehicleArea:SEAT), 2196 2197 /** 2198 * Headrest fore/aft move 2199 * 2200 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2201 * @access VehiclePropertyAccess:READ_WRITE 2202 */ 2203 SEAT_HEADREST_FORE_AFT_MOVE = ( 2204 0x0B9A 2205 | VehiclePropertyGroup:SYSTEM 2206 | VehiclePropertyType:INT32 2207 | VehicleArea:SEAT), 2208 2209 /** 2210 * Seat Occupancy 2211 * 2212 * Indicates whether a particular seat is occupied or not, to the best of the car's ability 2213 * to determine. Valid values are from the VehicleSeatOccupancyState enum. 2214 * 2215 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2216 * @access VehiclePropertyAccess:READ 2217 * @data_enum VehicleSeatOccupancyState 2218 */ 2219 SEAT_OCCUPANCY = ( 2220 0x0BB0 2221 | VehiclePropertyGroup:SYSTEM 2222 | VehiclePropertyType:INT32 2223 | VehicleArea:SEAT), 2224 2225 /** 2226 * Window Position 2227 * 2228 * Min = window up / closed 2229 * Max = window down / open 2230 * 2231 * For a window that may open out of plane (i.e. vent mode of sunroof) this 2232 * parameter will work with negative values as follows: 2233 * Max = sunroof completely open 2234 * 0 = sunroof closed. 2235 * Min = sunroof vent completely open 2236 * 2237 * Note that in this mode, 0 indicates the window is closed. 2238 * 2239 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2240 * @access VehiclePropertyAccess:READ_WRITE 2241 */ 2242 WINDOW_POS = ( 2243 0x0BC0 2244 | VehiclePropertyGroup:SYSTEM 2245 | VehiclePropertyType:INT32 2246 | VehicleArea:WINDOW), 2247 2248 /** 2249 * Window Move 2250 * 2251 * Max = Open the window as fast as possible 2252 * Min = Close the window as fast as possible 2253 * Magnitude denotes relative speed. I.e. +2 is faster than +1 in closing 2254 * the window. 2255 * 2256 * For a window that may open out of plane (i.e. vent mode of sunroof) this 2257 * parameter will work as follows: 2258 * 2259 * If sunroof is open: 2260 * Max = open the sunroof further, automatically stop when fully open. 2261 * Min = close the sunroof, automatically stop when sunroof is closed. 2262 * 2263 * If vent is open: 2264 * Max = close the vent, automatically stop when vent is closed. 2265 * Min = open the vent further, automatically stop when vent is fully open. 2266 * 2267 * If sunroof is in the closed position: 2268 * Max = open the sunroof, automatically stop when sunroof is fully open. 2269 * Min = open the vent, automatically stop when vent is fully open. 2270 * 2271 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2272 * @access VehiclePropertyAccess:READ_WRITE 2273 */ 2274 WINDOW_MOVE = ( 2275 0x0BC1 2276 | VehiclePropertyGroup:SYSTEM 2277 | VehiclePropertyType:INT32 2278 | VehicleArea:WINDOW), 2279 2280 /** 2281 * Window Lock 2282 * 2283 * True indicates windows are locked and can't be moved. 2284 * 2285 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2286 * @access VehiclePropertyAccess:READ_WRITE 2287 */ 2288 WINDOW_LOCK = ( 2289 0x0BC4 2290 | VehiclePropertyGroup:SYSTEM 2291 | VehiclePropertyType:BOOLEAN 2292 | VehicleArea:WINDOW), 2293 2294 2295 /** 2296 * Vehicle Maps Service (VMS) message 2297 * 2298 * This property uses MIXED data to communicate vms messages. 2299 * 2300 * Its contents are to be interpreted as follows: 2301 * the indices defined in VmsMessageIntegerValuesIndex are to be used to 2302 * read from int32Values; 2303 * bytes is a serialized VMS message as defined in the vms protocol 2304 * which is opaque to the framework; 2305 * 2306 * IVehicle#get must always return StatusCode::NOT_AVAILABLE. 2307 * 2308 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2309 * @access VehiclePropertyAccess:READ_WRITE 2310 */ 2311 VEHICLE_MAP_SERVICE = ( 2312 0x0C00 2313 | VehiclePropertyGroup:SYSTEM 2314 | VehiclePropertyType:MIXED 2315 | VehicleArea:GLOBAL), 2316 2317 /** 2318 * OBD2 Live Sensor Data 2319 * 2320 * Reports a snapshot of the current (live) values of the OBD2 sensors available. 2321 * 2322 * The configArray is set as follows: 2323 * configArray[0] = number of vendor-specific integer-valued sensors 2324 * configArray[1] = number of vendor-specific float-valued sensors 2325 * 2326 * The values of this property are to be interpreted as in the following example. 2327 * Considering a configArray = {2,3} 2328 * int32Values must be a vector containing Obd2IntegerSensorIndex.LAST_SYSTEM_INDEX + 2 2329 * elements (that is, 33 elements); 2330 * floatValues must be a vector containing Obd2FloatSensorIndex.LAST_SYSTEM_INDEX + 3 2331 * elements (that is, 73 elements); 2332 * 2333 * It is possible for each frame to contain a different subset of sensor values, both system 2334 * provided sensors, and vendor-specific ones. In order to support that, the bytes element 2335 * of the property value is used as a bitmask,. 2336 * 2337 * bytes must have a sufficient number of bytes to represent the total number of possible 2338 * sensors (in this case, 14 bytes to represent 106 possible values); it is to be read as 2339 * a contiguous bitmask such that each bit indicates the presence or absence of a sensor 2340 * from the frame, starting with as many bits as the size of int32Values, immediately 2341 * followed by as many bits as the size of floatValues. 2342 * 2343 * For example, should bytes[0] = 0x4C (0b01001100) it would mean that: 2344 * int32Values[0 and 1] are not valid sensor values 2345 * int32Values[2 and 3] are valid sensor values 2346 * int32Values[4 and 5] are not valid sensor values 2347 * int32Values[6] is a valid sensor value 2348 * int32Values[7] is not a valid sensor value 2349 * Should bytes[5] = 0x61 (0b01100001) it would mean that: 2350 * int32Values[32] is a valid sensor value 2351 * floatValues[0 thru 3] are not valid sensor values 2352 * floatValues[4 and 5] are valid sensor values 2353 * floatValues[6] is not a valid sensor value 2354 * 2355 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2356 * @access VehiclePropertyAccess:READ 2357 */ 2358 OBD2_LIVE_FRAME = ( 2359 0x0D00 2360 | VehiclePropertyGroup:SYSTEM 2361 | VehiclePropertyType:MIXED 2362 | VehicleArea:GLOBAL), 2363 2364 /** 2365 * OBD2 Freeze Frame Sensor Data 2366 * 2367 * Reports a snapshot of the value of the OBD2 sensors available at the time that a fault 2368 * occurred and was detected. 2369 * 2370 * A configArray must be provided with the same meaning as defined for OBD2_LIVE_FRAME. 2371 * 2372 * The values of this property are to be interpreted in a similar fashion as those for 2373 * OBD2_LIVE_FRAME, with the exception that the stringValue field may contain a non-empty 2374 * diagnostic troubleshooting code (DTC). 2375 * 2376 * A IVehicle#get request of this property must provide a value for int64Values[0]. 2377 * This will be interpreted as the timestamp of the freeze frame to retrieve. A list of 2378 * timestamps can be obtained by a IVehicle#get of OBD2_FREEZE_FRAME_INFO. 2379 * 2380 * Should no freeze frame be available at the given timestamp, a response of NOT_AVAILABLE 2381 * must be returned by the implementation. Because vehicles may have limited storage for 2382 * freeze frames, it is possible for a frame request to respond with NOT_AVAILABLE even if 2383 * the associated timestamp has been recently obtained via OBD2_FREEZE_FRAME_INFO. 2384 * 2385 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2386 * @access VehiclePropertyAccess:READ 2387 */ 2388 OBD2_FREEZE_FRAME = ( 2389 0x0D01 2390 | VehiclePropertyGroup:SYSTEM 2391 | VehiclePropertyType:MIXED 2392 | VehicleArea:GLOBAL), 2393 2394 /** 2395 * OBD2 Freeze Frame Information 2396 * 2397 * This property describes the current freeze frames stored in vehicle 2398 * memory and available for retrieval via OBD2_FREEZE_FRAME. 2399 * 2400 * The values are to be interpreted as follows: 2401 * each element of int64Values must be the timestamp at which a a fault code 2402 * has been detected and the corresponding freeze frame stored, and each 2403 * such element can be used as the key to OBD2_FREEZE_FRAME to retrieve 2404 * the corresponding freeze frame. 2405 * 2406 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2407 * @access VehiclePropertyAccess:READ 2408 */ 2409 OBD2_FREEZE_FRAME_INFO = ( 2410 0x0D02 2411 | VehiclePropertyGroup:SYSTEM 2412 | VehiclePropertyType:MIXED 2413 | VehicleArea:GLOBAL), 2414 2415 /** 2416 * OBD2 Freeze Frame Clear 2417 * 2418 * This property allows deletion of any of the freeze frames stored in 2419 * vehicle memory, as described by OBD2_FREEZE_FRAME_INFO. 2420 * 2421 * The configArray is set as follows: 2422 * configArray[0] = 1 if the implementation is able to clear individual freeze frames 2423 * by timestamp, 0 otherwise 2424 * 2425 * IVehicle#set of this property is to be interpreted as follows: 2426 * if int64Values contains no elements, then all frames stored must be cleared; 2427 * if int64Values contains one or more elements, then frames at the timestamps 2428 * stored in int64Values must be cleared, and the others not cleared. Should the 2429 * vehicle not support selective clearing of freeze frames, this latter mode must 2430 * return NOT_AVAILABLE. 2431 * 2432 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2433 * @access VehiclePropertyAccess:WRITE 2434 */ 2435 OBD2_FREEZE_FRAME_CLEAR = ( 2436 0x0D03 2437 | VehiclePropertyGroup:SYSTEM 2438 | VehiclePropertyType:MIXED 2439 | VehicleArea:GLOBAL), 2440 2441 /** 2442 * Headlights State 2443 * 2444 * Return the current state of headlights. 2445 * 2446 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2447 * @access VehiclePropertyAccess:READ 2448 * @data_enum VehicleLightState 2449 */ 2450 HEADLIGHTS_STATE = ( 2451 0x0E00 2452 | VehiclePropertyGroup:SYSTEM 2453 | VehiclePropertyType:INT32 2454 | VehicleArea:GLOBAL), 2455 2456 /** 2457 * High beam lights state 2458 * 2459 * Return the current state of high beam lights. 2460 * 2461 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2462 * @access VehiclePropertyAccess:READ 2463 * @data_enum VehicleLightState 2464 */ 2465 HIGH_BEAM_LIGHTS_STATE = ( 2466 0x0E01 2467 | VehiclePropertyGroup:SYSTEM 2468 | VehiclePropertyType:INT32 2469 | VehicleArea:GLOBAL), 2470 2471 /** 2472 * Fog light state 2473 * 2474 * Return the current state of fog lights. 2475 * 2476 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2477 * @access VehiclePropertyAccess:READ 2478 * @data_enum VehicleLightState 2479 */ 2480 FOG_LIGHTS_STATE = ( 2481 0x0E02 2482 | VehiclePropertyGroup:SYSTEM 2483 | VehiclePropertyType:INT32 2484 | VehicleArea:GLOBAL), 2485 2486 /** 2487 * Hazard light status 2488 * 2489 * Return the current status of hazard lights. 2490 * 2491 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2492 * @access VehiclePropertyAccess:READ 2493 * @data_enum VehicleLightState 2494 */ 2495 HAZARD_LIGHTS_STATE = ( 2496 0x0E03 2497 | VehiclePropertyGroup:SYSTEM 2498 | VehiclePropertyType:INT32 2499 | VehicleArea:GLOBAL), 2500 2501 /** 2502 * Headlight switch 2503 * 2504 * The setting that the user wants. 2505 * 2506 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2507 * @access VehiclePropertyAccess:READ_WRITE 2508 * @data_enum VehicleLightSwitch 2509 */ 2510 HEADLIGHTS_SWITCH = ( 2511 0x0E10 2512 | VehiclePropertyGroup:SYSTEM 2513 | VehiclePropertyType:INT32 2514 | VehicleArea:GLOBAL), 2515 2516 /** 2517 * High beam light switch 2518 * 2519 * The setting that the user wants. 2520 * 2521 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2522 * @access VehiclePropertyAccess:READ_WRITE 2523 * @data_enum VehicleLightSwitch 2524 */ 2525 HIGH_BEAM_LIGHTS_SWITCH = ( 2526 0x0E11 2527 | VehiclePropertyGroup:SYSTEM 2528 | VehiclePropertyType:INT32 2529 | VehicleArea:GLOBAL), 2530 2531 /** 2532 * Fog light switch 2533 * 2534 * The setting that the user wants. 2535 * 2536 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2537 * @access VehiclePropertyAccess:READ_WRITE 2538 * @data_enum VehicleLightSwitch 2539 */ 2540 FOG_LIGHTS_SWITCH = ( 2541 0x0E12 2542 | VehiclePropertyGroup:SYSTEM 2543 | VehiclePropertyType:INT32 2544 | VehicleArea:GLOBAL), 2545 2546 /** 2547 * Hazard light switch 2548 * 2549 * The setting that the user wants. 2550 * 2551 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2552 * @access VehiclePropertyAccess:READ_WRITE 2553 * @data_enum VehicleLightSwitch 2554 */ 2555 HAZARD_LIGHTS_SWITCH = ( 2556 0x0E13 2557 | VehiclePropertyGroup:SYSTEM 2558 | VehiclePropertyType:INT32 2559 | VehicleArea:GLOBAL), 2560 2561 /** 2562 * Cabin lights 2563 * 2564 * Return current status of cabin lights. 2565 * 2566 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2567 * @access VehiclePropertyAccess:READ 2568 * @data_enum VehicleLightState 2569 */ 2570 CABIN_LIGHTS_STATE = ( 2571 0x0F01 2572 | VehiclePropertyGroup:SYSTEM 2573 | VehiclePropertyType:INT32 2574 | VehicleArea:GLOBAL), 2575 2576 /** 2577 * Cabin lights switch 2578 * 2579 * The position of the physical switch which controls the cabin lights. 2580 * This might be different than the CABIN_LIGHTS_STATE if the lights are on because a door 2581 * is open or because of a voice command. 2582 * For example, while the switch is in the "off" or "automatic" position. 2583 * 2584 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2585 * @access VehiclePropertyAccess:READ_WRITE 2586 * @data_enum VehicleLightSwitch 2587 */ 2588 CABIN_LIGHTS_SWITCH = ( 2589 0x0F02 2590 | VehiclePropertyGroup:SYSTEM 2591 | VehiclePropertyType:INT32 2592 | VehicleArea:GLOBAL), 2593 2594 /** 2595 * Reading lights 2596 * 2597 * Return current status of reading lights. 2598 * 2599 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2600 * @access VehiclePropertyAccess:READ 2601 * @data_enum VehicleLightState 2602 */ 2603 READING_LIGHTS_STATE = ( 2604 0x0F03 2605 | VehiclePropertyGroup:SYSTEM 2606 | VehiclePropertyType:INT32 2607 | VehicleArea:SEAT), 2608 2609 /** 2610 * Reading lights switch 2611 * 2612 * The position of the physical switch which controls the reading lights. 2613 * This might be different than the READING_LIGHTS_STATE if the lights are on because a door 2614 * is open or because of a voice command. 2615 * For example, while the switch is in the "off" or "automatic" position. 2616 * 2617 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2618 * @access VehiclePropertyAccess:READ_WRITE 2619 * @data_enum VehicleLightSwitch 2620 */ 2621 READING_LIGHTS_SWITCH = ( 2622 0x0F04 2623 | VehiclePropertyGroup:SYSTEM 2624 | VehiclePropertyType:INT32 2625 | VehicleArea:SEAT), 2626 2627 /** 2628 * Support customize permissions for vendor properties 2629 * 2630 * Implement this property if vehicle hal support customize vendor permissions feature. 2631 * VehiclePropConfig.configArray is used to indicate vendor properties and permissions 2632 * which selected for this vendor property. The permission must be one of enum in 2633 * VehicleVendorPermission. 2634 * The configArray is set as follows: 2635 * configArray[n] = propId : property ID for the vendor property 2636 * configArray[n+1] = one of enums in VehicleVendorPermission. It indicates the permission 2637 * for reading value of the property. 2638 * configArray[n+2] = one of enums in VehicleVendorPermission. It indicates the permission 2639 * for writing value of the property. 2640 * 2641 * For example: 2642 * configArray = { 2643 * vendor_prop_1, PERMISSION_VENDOR_SEAT_READ, PERMISSION_VENDOR_SEAT_WRITE, 2644 * vendor_prop_2, PERMISSION_VENDOR_INFO, PERMISSION_NOT_ACCESSIBLE, 2645 * } 2646 * If vendor properties are not in this array, they will have the default vendor permission. 2647 * If vendor chose PERMISSION_NOT_ACCESSIBLE, android will not have access to the property. In 2648 * the example, Android can not write value for vendor_prop_2. 2649 * 2650 * @change_mode VehiclePropertyChangeMode:STATIC 2651 * @access VehiclePropertyAccess:READ 2652 */ 2653 SUPPORT_CUSTOMIZE_VENDOR_PERMISSION = ( 2654 0x0F05 2655 | VehiclePropertyGroup:SYSTEM 2656 | VehiclePropertyType:BOOLEAN 2657 | VehicleArea:GLOBAL), 2658 2659 /** 2660 * Allow disabling optional featurs from vhal. 2661 * 2662 * This property reports optional features that should be disabled. 2663 * All allowed optional features for the system is declared in Car service overlay, 2664 * config_allowed_optional_car_features. 2665 * This property allows disabling features defined in the overlay. Without this property, 2666 * all the features declared in the overlay will be enabled. 2667 * 2668 * Value read should include all features disabled with ',' separation. 2669 * ex) "com.android.car.user.CarUserNoticeService,storage_monitoring" 2670 * @change_mode VehiclePropertyChangeMode:STATIC 2671 * @access VehiclePropertyAccess:READ 2672 */ 2673 DISABLED_OPTIONAL_FEATURES = ( 2674 0x0F06 2675 | VehiclePropertyGroup:SYSTEM 2676 | VehiclePropertyType:STRING 2677 | VehicleArea:GLOBAL), 2678 2679 /** 2680 * Defines the initial Android user to be used during initialization. 2681 * 2682 * This property is called by the Android system when it initializes and it lets the HAL 2683 * define which Android user should be started. 2684 * 2685 * This request is made by setting a VehiclePropValue (defined by InitialUserInfoRequest), 2686 * and the HAL must respond with a property change event (defined by InitialUserInfoResponse). 2687 * If the HAL doesn't respond after some time (defined by the Android system), the Android 2688 * system will proceed as if HAL returned a response of action 2689 * InitialUserInfoResponseAction:DEFAULT. 2690 * 2691 * For example, on first boot, the request could be: 2692 * 2693 * int32[0]: 42 // request id (arbitrary number set by Android system) 2694 * int32[1]: 1 // InitialUserInfoRequestType::FIRST_BOOT 2695 * int32[2]: 0 // id of current user (usersInfo.currentUser.userId) 2696 * int32[3]: 1 // flag of current user (usersInfo.currentUser.flags = SYSTEM) 2697 * int32[4]: 1 // number of existing users (usersInfo.numberUsers); 2698 * int32[5]: 0 // user #0 (usersInfo.existingUsers[0].userId) 2699 * int32[6]: 1 // flags of user #0 (usersInfo.existingUsers[0].flags) 2700 * 2701 * And if the HAL want to respond with the creation of an admin user called "Owner", the 2702 * response would be: 2703 * 2704 * int32[0]: 42 // must match the request id from the request 2705 * int32[1]: 2 // action = InitialUserInfoResponseAction::CREATE 2706 * int32[2]: -10000 // userToSwitchOrCreate.userId (not used as user will be created) 2707 * int32[3]: 8 // userToSwitchOrCreate.flags = ADMIN 2708 * string: "||Owner" // userLocales + separator + userNameToCreate 2709 * 2710 * Notice the string value represents multiple values, separated by ||. The first value is the 2711 * (optional) system locales for the user to be created (in this case, it's empty, meaning it 2712 * will use Android's default value), while the second value is the (also optional) name of the 2713 * to user to be created (when the type of response is InitialUserInfoResponseAction:CREATE). 2714 * For example, to create the same "Owner" user with "en-US" and "pt-BR" locales, the string 2715 * value of the response would be "en-US,pt-BR||Owner". As such, neither the locale nor the 2716 * name can have || on it, although a single | is fine. 2717 * 2718 * NOTE: if the HAL doesn't support user management, then it should not define this property, 2719 * which in turn would disable the other user-related properties (for example, the Android 2720 * system would never issue them and user-related requests from the HAL layer would be ignored 2721 * by the Android System). But if it supports user management, then it must support all core 2722 * user-related properties (INITIAL_USER_INFO, SWITCH_USER, CREATE_USER, and REMOVE_USER). 2723 * 2724 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2725 * @access VehiclePropertyAccess:READ_WRITE 2726 */ 2727 INITIAL_USER_INFO = ( 2728 0x0F07 2729 | VehiclePropertyGroup:SYSTEM 2730 | VehiclePropertyType:MIXED 2731 | VehicleArea:GLOBAL), 2732 2733 /** 2734 * Defines a request to switch the foreground Android user. 2735 * 2736 * This property is used primarily by the Android System to inform the HAL that the 2737 * current foreground Android user is switching, but it could also be used by the HAL to request 2738 * the Android system to switch users - the 2739 * 2740 * When the request is made by Android, it sets a VehiclePropValue and the HAL must responde 2741 * with a property change event; when the HAL is making the request, it must also do it through 2742 * a property change event (the main difference is that the request id will be positive in the 2743 * former case, and negative in the latter; the SwitchUserMessageType will also be different). 2744 * 2745 * The format of both request is defined by SwitchUserRequest and the format of the response 2746 * (when needed) is defined by SwitchUserResponse. How the HAL (or Android System) should 2747 * proceed depends on the message type (which is defined by the SwitchUserMessageType 2748 * parameter), as defined below. 2749 * 2750 * 1.LEGACY_ANDROID_SWITCH 2751 * ----------------------- 2752 * 2753 * Called by the Android System to indicate the Android user is about to change, when the change 2754 * request was made in a way that is not integrated with the HAL (for example, through 2755 * adb shell am switch-user). 2756 * 2757 * The HAL can switch its internal user once it receives this request, but it doesn't need to 2758 * reply back to the Android System. If its internal user cannot be changed for some reason, 2759 * then it must wait for the SWITCH_USER(type=ANDROID_POST_SWITCH) call to recover 2760 * (for example, it could issue a SWITCH_USER(type=VEHICLE_REQUEST) to switch back to 2761 * the previous user), but ideally it should never fail (as switching back could result in a 2762 * confusing experience for the end user). 2763 * 2764 * For example, if the system have users (0, 10, 11) and it's switching from 0 to 11 (where none 2765 * of them have any special flag), the request would be: 2766 * 2767 * int32[0]: 42 // request id 2768 * int32[1]: 1 // SwitchUserMessageType::LEGACY_ANDROID_SWITCH 2769 * int32[2]: 11 // target user id 2770 * int32[3]: 0 // target user flags (none) 2771 * int32[4]: 10 // current user 2772 * int32[5]: 0 // current user flags (none) 2773 * int32[6]: 3 // number of users 2774 * int32[7]: 0 // user #0 (Android user id 0) 2775 * int32[8]: 0 // flags of user #0 (none) 2776 * int32[9]: 10 // user #1 (Android user id 10) 2777 * int32[10]: 0 // flags of user #1 (none) 2778 * int32[11]: 11 // user #2 (Android user id 11) 2779 * int32[12]: 0 // flags of user #2 (none) 2780 * 2781 * 2.ANDROID_SWITCH 2782 * ---------------- 2783 * Called by the Android System to indicate the Android user is about to change, but Android 2784 * will wait for the HAL's response (up to some time) before proceeding. 2785 * 2786 * The HAL must switch its internal user once it receives this request, then respond back to 2787 * Android with a SWITCH_USER(type=VEHICLE_RESPONSE) indicating whether its internal 2788 * user was switched or not (through the SwitchUserStatus enum). 2789 * 2790 * For example, if Android has users (0, 10, 11) and it's switching from 10 to 11 (where 2791 * none of them have any special flag), the request would be: 2792 * 2793 * int32[0]: 42 // request id 2794 * int32[1]: 2 // SwitchUserMessageType::ANDROID_SWITCH 2795 * int32[2]: 11 // target user id 2796 * int32[3]: 0 // target user flags (none) 2797 * int32[4]: 10 // current user 2798 * int32[5]: 0 // current user flags (none) 2799 * int32[6]: 3 // number of users 2800 * int32[7]: 0 // 1st user (user 0) 2801 * int32[8]: 1 // 1st user flags (SYSTEM) 2802 * int32[9]: 10 // 2nd user (user 10) 2803 * int32[10]: 0 // 2nd user flags (none) 2804 * int32[11]: 11 // 3rd user (user 11) 2805 * int32[12]: 0 // 3rd user flags (none) 2806 * 2807 * If the request succeeded, the HAL must update the propery with: 2808 * 2809 * int32[0]: 42 // request id 2810 * int32[1]: 3 // messageType = SwitchUserMessageType::VEHICLE_RESPONSE 2811 * int32[2]: 1 // status = SwitchUserStatus::SUCCESS 2812 * 2813 * But if it failed, the response would be something like: 2814 * 2815 * int32[0]: 42 // request id 2816 * int32[1]: 3 // messageType = SwitchUserMessageType::VEHICLE_RESPONSE 2817 * int32[2]: 2 // status = SwitchUserStatus::FAILURE 2818 * string: "108-D'OH!" // OEM-spefic error message 2819 * 2820 * 3.VEHICLE_RESPONSE 2821 * ------------------ 2822 * Called by the HAL to indicate whether a request of type ANDROID_SWITCH should proceed or 2823 * abort - see the ANDROID_SWITCH section above for more info. 2824 * 2825 * 4.VEHICLE_REQUEST 2826 * ------------------ 2827 * Called by the HAL to request that the current foreground Android user is switched. 2828 * 2829 * This is useful in situations where Android started as one user, but the vehicle identified 2830 * the driver as another user. For example, user A unlocked the car using the key fob of user B; 2831 * the INITIAL_USER_INFO request returned user B, but then a face recognition subsubsystem 2832 * identified the user as A. 2833 * 2834 * The HAL makes this request by a property change event (passing a negative request id), and 2835 * the Android system will response by issue an ANDROID_POST_SWITCH call which the same 2836 * request id. 2837 * 2838 * For example, if the current foreground Android user is 10 and the HAL asked it to switch to 2839 * 11, the request would be: 2840 * 2841 * int32[0]: -108 // request id 2842 * int32[1]: 4 // messageType = SwitchUserMessageType::VEHICLE_REQUEST 2843 * int32[2]: 11 // Android user id 2844 * 2845 * If the request succeeded and Android has 3 users (0, 10, 11), the response would be: 2846 * 2847 * int32[0]: -108 // request id 2848 * int32[1]: 5 // messageType = SwitchUserMessageType::ANDROID_POST_SWITCH 2849 * int32[2]: 11 // target user id 2850 * int32[3]: 0 // target user id flags (none) 2851 * int32[4]: 11 // current user 2852 * int32[5]: 0 // current user flags (none) 2853 * int32[6]: 3 // number of users 2854 * int32[7]: 0 // 1st user (user 0) 2855 * int32[8]: 0 // 1st user flags (none) 2856 * int32[9]: 10 // 2nd user (user 10) 2857 * int32[10]: 4 // 2nd user flags (none) 2858 * int32[11]: 11 // 3rd user (user 11) 2859 * int32[12]: 3 // 3rd user flags (none) 2860 * 2861 * Notice that both the current and target user ids are the same - if the request failed, then 2862 * they would be different (i.e, target user would be 11, but current user would still be 10). 2863 * 2864 * 5.ANDROID_POST_SWITCH 2865 * --------------------- 2866 * Called by the Android System after a request to switch a user was made. 2867 * 2868 * This property is called after switch requests of any type (i.e., LEGACY_ANDROID_SWITCH, 2869 * ANDROID_SWITCH, or VEHICLE_REQUEST) and can be used to determine if the request succeeded or 2870 * failed: 2871 * 2872 * 1. When it succeeded, it's called when the Android user is in the unlocked state and the 2873 * value of the current and target users ids in the response are the same. This would be 2874 * equivalent to receiving an Intent.ACTION_USER_UNLOCKED in an Android app. 2875 * 2. When it failed it's called right away and the value of the current and target users ids 2876 * in the response are different (as the current user didn't change to the target). 2877 * 3. If a new switch request is made before the HAL responded to the previous one or before 2878 * the user was unlocked, then the ANDROID_POST_SWITCH request is not made. For example, 2879 * the driver could accidentally switch to the wrong user which has lock credentials, then 2880 * switch to the right one before entering the credentials. 2881 * 2882 * The HAL can update its internal state once it receives this request, but it doesn't need to 2883 * reply back to the Android System. 2884 * 2885 * Request: the first N values as defined by INITIAL_USER_INFO (where the request-specific 2886 * value at index 1 is SwitchUserMessageType::ANDROID_POST_SWITCH), then 2 more values for the 2887 * target user id (i.e., the Android user id that was requested to be switched to) and its flags 2888 * (as defined by UserFlags). 2889 * 2890 * Response: none. 2891 * 2892 * Example: see VEHICLE_REQUEST section above. 2893 * 2894 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2895 * @access VehiclePropertyAccess:READ_WRITE 2896 */ 2897 SWITCH_USER = ( 2898 0x0F08 2899 | VehiclePropertyGroup:SYSTEM 2900 | VehiclePropertyType:MIXED 2901 | VehicleArea:GLOBAL), 2902 2903 /** 2904 * Called by the Android System after an Android user was created. 2905 * 2906 * The HAL can use this property to create its equivalent user. 2907 * 2908 * This is an async request: Android makes the request by setting a VehiclePropValue, and HAL 2909 * must respond with a property change indicating whether the request succeeded or failed. If 2910 * it failed, the Android system will remove the user. 2911 * 2912 * The format of the request is defined by CreateUserRequest and the format of the response by 2913 * CreateUserResponse. 2914 * 2915 * For example, if system had 2 users (0 and 10) and a 3rd one (which is an ephemeral guest) was 2916 * created, the request would be: 2917 * 2918 * int32[0]: 42 // request id 2919 * int32[1]: 11 // Android id of the created user 2920 * int32[2]: 6 // Android flags (ephemeral guest) of the created user 2921 * int32[3]: 10 // current user 2922 * int32[4]: 0 // current user flags (none) 2923 * int32[5]: 3 // number of users 2924 * int32[6]: 0 // 1st user (user 0) 2925 * int32[7]: 0 // 1st user flags (none) 2926 * int32[8]: 10 // 2nd user (user 10) 2927 * int32[9]: 0 // 2nd user flags (none) 2928 * int32[19]: 11 // 3rd user (user 11) 2929 * int32[11]: 6 // 3rd user flags (ephemeral guest) 2930 * string: "ElGuesto" // name of the new user 2931 * 2932 * Then if the request succeeded, the HAL would return: 2933 * 2934 * int32[0]: 42 // request id 2935 * int32[1]: 1 // CreateUserStatus::SUCCESS 2936 * 2937 * But if it failed: 2938 * 2939 * int32[0]: 42 // request id 2940 * int32[1]: 2 // CreateUserStatus::FAILURE 2941 * string: "D'OH!" // The meaning is a blackbox - it's passed to the caller (like Settings UI), 2942 * // which in turn can take the proper action. 2943 * 2944 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 2945 * @access VehiclePropertyAccess:READ_WRITE 2946 */ 2947 CREATE_USER = ( 2948 0x0F09 2949 | VehiclePropertyGroup:SYSTEM 2950 | VehiclePropertyType:MIXED 2951 | VehicleArea:GLOBAL), 2952 2953 /** 2954 * Called by the Android System after an Android user was removed. 2955 * 2956 * The HAL can use this property to remove its equivalent user. 2957 * 2958 * This is write-only call - the Android System is not expecting a reply from the HAL. Hence, 2959 * this request should not fail - if the equivalent HAL user cannot be removed, then HAL should 2960 * mark it as inactive or recover in some other way. 2961 * 2962 * The request is made by setting the VehiclePropValue with the contents defined by 2963 * RemoveUserRequest. 2964 * 2965 * For example, if system had 3 users (0, 10, and 11) and user 11 was removed, the request 2966 * would be: 2967 * 2968 * int32[0]: 42 // request id 2969 * int32[1]: 11 // (Android user id of the removed user) 2970 * int32[2]: 0 // (Android user flags of the removed user) 2971 * int32[3]: 10 // current user 2972 * int32[4]: 0 // current user flags (none) 2973 * int32[5]: 2 // number of users 2974 * int32[6]: 0 // 1st user (user 0) 2975 * int32[7]: 0 // 1st user flags (none) 2976 * int32[8]: 10 // 2nd user (user 10) 2977 * int32[9]: 0 // 2nd user flags (none) 2978 * 2979 * @change_mode VehiclePropertyChangeMode:STATIC 2980 * @access VehiclePropertyAccess:WRITE 2981 */ 2982 REMOVE_USER = ( 2983 0x0F0A 2984 | VehiclePropertyGroup:SYSTEM 2985 | VehiclePropertyType:MIXED 2986 | VehicleArea:GLOBAL), 2987 2988 /** 2989 * Property used to associate (or query the association) the current user with vehicle-specific 2990 * identification mechanisms (such as key FOB). 2991 * 2992 * This is an optional user management property - the OEM could still support user management 2993 * without defining it. In fact, this property could be used without supporting the core 2994 * user-related functions described on INITIAL_USER_INFO. 2995 * 2996 * To query the association, the Android system gets the property, passing a VehiclePropValue 2997 * containing the types of associations are being queried, as defined by 2998 * UserIdentificationGetRequest. The HAL must return right away, returning a VehiclePropValue 2999 * with a UserIdentificationResponse. Notice that user identification should have already 3000 * happened while system is booting up and the VHAL implementation should only return the 3001 * already identified association (like the key FOB used to unlock the car), instead of starting 3002 * a new association from the get call. 3003 * 3004 * To associate types, the Android system sets the property, passing a VehiclePropValue 3005 * containing the types and values of associations being set, as defined by the 3006 * UserIdentificationSetRequest. The HAL will then use a property change event (whose 3007 * VehiclePropValue is defined by UserIdentificationResponse) indicating the current status of 3008 * the types after the request. 3009 * 3010 * For example, to query if the current user (10) is associated with the FOB that unlocked the 3011 * car and a custom mechanism provided by the OEM, the request would be: 3012 * 3013 * int32[0]: 42 // request id 3014 * int32[1]: 10 (Android user id) 3015 * int32[2]: 0 (Android user flags) 3016 * int32[3]: 2 (number of types queried) 3017 * int32[4]: 1 (1st type queried, UserIdentificationAssociationType::KEY_FOB) 3018 * int32[5]: 101 (2nd type queried, UserIdentificationAssociationType::CUSTOM_1) 3019 * 3020 * If the user is associated with the FOB but not with the custom mechanism, the response would 3021 * be: 3022 * 3023 * int32[0]: 42 // request id 3024 * int32[1]: 2 (number of associations in the response) 3025 * int32[2]: 1 (1st type: UserIdentificationAssociationType::KEY_FOB) 3026 * int32[3]: 2 (1st value: UserIdentificationAssociationValue::ASSOCIATED_CURRENT_USER) 3027 * int32[4]: 101 (2st type: UserIdentificationAssociationType::CUSTOM_1) 3028 * int32[5]: 4 (2nd value: UserIdentificationAssociationValue::NOT_ASSOCIATED_ANY_USER) 3029 * 3030 * Then to associate the user with the custom mechanism, a set request would be made: 3031 * 3032 * int32[0]: 43 // request id 3033 * int32[1]: 10 (Android user id) 3034 * int32[2]: 0 (Android user flags) 3035 * int32[3]: 1 (number of associations being set) 3036 * int32[4]: 101 (1st type: UserIdentificationAssociationType::CUSTOM_1) 3037 * int32[5]: 1 (1st value: UserIdentificationAssociationSetValue::ASSOCIATE_CURRENT_USER) 3038 * 3039 * If the request succeeded, the response would be simply: 3040 * 3041 * int32[0]: 43 // request id 3042 * int32[1]: 1 (number of associations in the response) 3043 * int32[2]: 101 (1st type: UserIdentificationAssociationType::CUSTOM_1) 3044 * int32[3]: 1 (1st value: UserIdentificationAssociationValue::ASSOCIATED_CURRENT_USER) 3045 * 3046 * Notice that the set request adds associations, but doesn't remove the existing ones. In the 3047 * example above, the end state would be 2 associations (FOB and CUSTOM_1). If we wanted to 3048 * associate the user with just CUSTOM_1 but not FOB, then the request should have been: 3049 * 3050 * int32[0]: 43 // request id 3051 * int32[1]: 10 (Android user id) 3052 * int32[2]: 2 (number of types set) 3053 * int32[3]: 1 (1st type: UserIdentificationAssociationType::KEY_FOB) 3054 * int32[4]: 2 (1st value: UserIdentificationAssociationValue::DISASSOCIATE_CURRENT_USER) 3055 * int32[5]: 101 (2nd type: UserIdentificationAssociationType::CUSTOM_1) 3056 * int32[6]: 1 (2nd value: UserIdentificationAssociationValue::ASSOCIATE_CURRENT_USER) 3057 * 3058 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3059 * @access VehiclePropertyAccess:READ_WRITE 3060 */ 3061 USER_IDENTIFICATION_ASSOCIATION = ( 3062 0x0F0B 3063 | VehiclePropertyGroup:SYSTEM 3064 | VehiclePropertyType:MIXED 3065 | VehicleArea:GLOBAL), 3066 3067 /** 3068 * Enable/request an EVS service. 3069 * 3070 * The property provides a generalized way to trigger EVS services. VHAL 3071 * should use this property to request Android to start or stop EVS service. 3072 * 3073 * int32Values[0] = a type of the EVS service. The value must be one of enums in 3074 * EvsServiceType. 3075 * int32Values[1] = the state of the EVS service. The value must be one of enums in 3076 * EvsServiceState. 3077 * 3078 * For example, to enable rear view EVS service, android side can set the property value as 3079 * [EvsServiceType::REAR_VIEW, EvsServiceState::ON]. 3080 * 3081 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3082 * @access VehiclePropertyAccess:READ 3083 */ 3084 EVS_SERVICE_REQUEST = ( 3085 0x0F10 3086 | VehiclePropertyGroup:SYSTEM 3087 | VehiclePropertyType:INT32_VEC 3088 | VehicleArea:GLOBAL), 3089 3090 /** 3091 * Defines a request to apply power policy. 3092 * 3093 * VHAL sets this property to change car power policy. Car power policy service subscribes to 3094 * this property and actually changes the power policy. 3095 * The request is made by setting the VehiclePropValue with the ID of a power policy which is 3096 * defined at /vendor/etc/power_policy.xml. If the given ID is not defined, car power policy 3097 * service ignores the request and the current power policy is maintained. 3098 * 3099 * string: "sample_policy_id" // power policy ID 3100 * 3101 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3102 * @access VehiclePropertyAccess:READ 3103 */ 3104 POWER_POLICY_REQ = ( 3105 0x0F21 3106 | VehiclePropertyGroup:SYSTEM 3107 | VehiclePropertyType:STRING 3108 | VehicleArea:GLOBAL), 3109 3110 /** 3111 * Defines a request to set the power polic group used to decide a default power policy per 3112 * power status transition. 3113 * 3114 * VHAL sets this property with the ID of a power policy group in order to set the default power 3115 * policy applied at power status transition. Power policy groups are defined at 3116 * /vendor/etc/power_policy.xml. If the given ID is not defined, car power policy service 3117 * ignores the request. 3118 * Car power policy service subscribes to this property and sets the power policy group. 3119 * The actual application of power policy takes place when the system power status changes and 3120 * there is a valid mapped power policy for the new power status. 3121 * 3122 * string: "sample_policy_group_id" // power policy group ID 3123 * 3124 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3125 * @access VehiclePropertyAccess:READ 3126 */ 3127 POWER_POLICY_GROUP_REQ = ( 3128 0x0F22 3129 | VehiclePropertyGroup:SYSTEM 3130 | VehiclePropertyType:STRING 3131 | VehicleArea:GLOBAL), 3132 3133 /** 3134 * Notifies the current power policy to VHAL layer. 3135 * 3136 * Car power policy service sets this property when the current power policy is changed. 3137 * 3138 * string: "sample_policy_id" // power policy ID 3139 * 3140 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3141 * @access VehiclePropertyAccess:READ_WRITE 3142 */ 3143 CURRENT_POWER_POLICY = ( 3144 0x0F23 3145 | VehiclePropertyGroup:SYSTEM 3146 | VehiclePropertyType:STRING 3147 | VehicleArea:GLOBAL), 3148 3149 /** 3150 * Defines an event that car watchdog updates to tell it's alive. 3151 * 3152 * Car watchdog sets this property to system uptime in milliseconds at every 3 second. 3153 * During the boot, the update may take longer time. 3154 * 3155 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3156 * @access VehiclePropertyAccess:WRITE 3157 */ 3158 WATCHDOG_ALIVE = ( 3159 0xF31 3160 | VehiclePropertyGroup:SYSTEM 3161 | VehiclePropertyType:INT64 3162 | VehicleArea:GLOBAL), 3163 3164 /** 3165 * Defines a process terminated by car watchdog and the reason of termination. 3166 * 3167 * int32Values[0]: 1 // ProcessTerminationReason showing why a process is terminated. 3168 * string: "/system/bin/log" // Process execution command. 3169 * 3170 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3171 * @access VehiclePropertyAccess:WRITE 3172 */ 3173 WATCHDOG_TERMINATED_PROCESS = ( 3174 0x0F32 3175 | VehiclePropertyGroup:SYSTEM 3176 | VehiclePropertyType:MIXED 3177 | VehicleArea:GLOBAL), 3178 3179 /** 3180 * Defines an event that VHAL signals to car watchdog as a heartbeat. 3181 * 3182 * If VHAL supports this property, VHAL should write system uptime to this property at every 3 3183 * second. Car watchdog subscribes to this property and checks if the property is updated at 3184 * every 3 second. With the buffer time of 3 second, car watchdog waits for a heart beat to be 3185 * signaled up to 6 seconds from the last heart beat. If it isn’t, car watchdog considers 3186 * VHAL unhealthy and terminates it. 3187 * If this property is not supported by VHAL, car watchdog doesn't check VHAL health status. 3188 * 3189 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3190 * @access VehiclePropertyAccess:READ 3191 */ 3192 VHAL_HEARTBEAT = ( 3193 0x0F33 3194 | VehiclePropertyGroup:SYSTEM 3195 | VehiclePropertyType:INT64 3196 | VehicleArea:GLOBAL), 3197 3198 /** 3199 * Starts the ClusterUI in cluster display. 3200 * 3201 * int32: the type of ClusterUI to show 3202 * 0 indicates ClusterHome, that is a home screen of cluster display, and provides 3203 * the default UI and a kind of launcher functionality for cluster display. 3204 * the other values are followed by OEM's definition. 3205 * 3206 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3207 * @access VehiclePropertyAccess:READ 3208 */ 3209 CLUSTER_SWITCH_UI = ( 3210 0x0F34 3211 | VehiclePropertyGroup:SYSTEM 3212 | VehiclePropertyType:INT32 3213 | VehicleArea:GLOBAL), 3214 3215 /** 3216 * Changes the state of the cluster display. 3217 * 3218 * Bounds: the area to render the cluster Activity. 3219 * Inset: the area which Activity should avoid from placing any important 3220 * information. 3221 * 3222 * int32[0]: on/off: 0 - off, 1 - on, -1 - don't care 3223 * int32[1]: Bounds - left: positive number - left position in pixels 3224 -1 - don't care (should set all Bounds fields) 3225 * int32[2]: Bounds - top: same format with 'left' 3226 * int32[3]: Bounds - right: same format with 'left' 3227 * int32[4]: Bounds - bottom: same format with 'left' 3228 * int32[5]: Inset - left: positive number - actual left inset value in pixels 3229 -1 - don't care (should set "don't care" all Inset fields) 3230 * int32[6]: Inset - top: same format with 'left' 3231 * int32[7]: Inset - right: same format with 'left' 3232 * int32[8]: Inset - bottom: same format with 'left' 3233 * 3234 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3235 * @access VehiclePropertyAccess:READ 3236 */ 3237 CLUSTER_DISPLAY_STATE = ( 3238 0x0F35 3239 | VehiclePropertyGroup:SYSTEM 3240 | VehiclePropertyType:INT32_VEC 3241 | VehicleArea:GLOBAL), 3242 3243 /** 3244 * Reports the current display state and ClusterUI state. 3245 * 3246 * ClusterHome will send this message when it handles CLUSTER_SWITCH_UI, CLUSTER_DISPLAY_STATE. 3247 * 3248 * In addition, ClusterHome should send this message when it starts for the first time. 3249 * When ClusterOS receives this message and if the internal expectation is different with the 3250 * received message, then it should send CLUSTER_SWITCH_UI, CLUSTER_DISPLAY_STATE again to 3251 * match the state. 3252 * 3253 * int32[0]: on/off: 0 - off, 1 - on 3254 * int32[1]: Bounds - left 3255 * int32[2]: Bounds - top 3256 * int32[3]: Bounds - right 3257 * int32[4]: Bounds - bottom 3258 * int32[5]: Inset - left 3259 * int32[6]: Inset - top 3260 * int32[7]: Inset - right 3261 * int32[8]: Inset - bottom 3262 * int32[9]: the type of ClusterUI in the fullscreen or main screen. 3263 * 0 indicates ClusterHome. 3264 * the other values are followed by OEM's definition. 3265 * int32[10]: the type of ClusterUI in sub screen if the currently two UIs are shown. 3266 * -1 indicates the area isn't used any more. 3267 * bytes: the array to represent the availability of ClusterUI. 3268 * 0 indicates non-available and 1 indicates available. 3269 * For example, let's assume a car supports 3 OEM defined ClusterUI like HOME, MAPS, CALL, 3270 * and it only supports CALL UI only when the cellular network is available. Then, if the 3271 * nework is avaibale, it'll send [1 1 1], and if it's out of network, it'll send [1 1 0]. 3272 * 3273 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3274 * @access VehiclePropertyAccess:WRITE 3275 */ 3276 CLUSTER_REPORT_STATE = ( 3277 0x0F36 3278 | VehiclePropertyGroup:SYSTEM 3279 | VehiclePropertyType:MIXED 3280 | VehicleArea:GLOBAL), 3281 3282 /** 3283 * Requests to change the cluster display state to show some ClusterUI. 3284 * 3285 * When the current display state is off and ClusterHome sends this message to ClusterOS to 3286 * request to turn the display on to show some specific ClusterUI. 3287 * ClusterOS should response this with CLUSTER_DISPLAY_STATE. 3288 * 3289 * int32: the type of ClusterUI to show 3290 * 3291 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3292 * @access VehiclePropertyAccess:WRITE 3293 */ 3294 CLUSTER_REQUEST_DISPLAY = ( 3295 0x0F37 3296 | VehiclePropertyGroup:SYSTEM 3297 | VehiclePropertyType:INT32 3298 | VehicleArea:GLOBAL), 3299 3300 /** 3301 * Informs the current navigation state. 3302 * 3303 * bytes: the serialized message of NavigationStateProto. 3304 * 3305 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3306 * @access VehiclePropertyAccess:WRITE 3307 */ 3308 CLUSTER_NAVIGATION_STATE = ( 3309 0x0F38 3310 | VehiclePropertyGroup:SYSTEM 3311 | VehiclePropertyType:BYTES 3312 | VehicleArea:GLOBAL), 3313 3314 /** 3315 * Electronic Toll Collection card type. 3316 * 3317 * This property indicates the type of ETC card in this vehicle. 3318 * If the head unit is aware of an ETC card attached to the vehicle, this property should 3319 * return the type of card attached; otherwise, this property should be UNAVAILABLE. 3320 * 3321 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3322 * @access VehiclePropertyAccess:READ 3323 * @data_enum ElectronicTollCollectionCardType 3324 */ 3325 ELECTRONIC_TOLL_COLLECTION_CARD_TYPE = ( 3326 0x0F39 3327 | VehiclePropertyGroup:SYSTEM 3328 | VehiclePropertyType:INT32 3329 | VehicleArea:GLOBAL), 3330 3331 /** 3332 * Electronic Toll Collection card status. 3333 * 3334 * This property indicates the status of ETC card in this vehicle. 3335 * If the head unit is aware of an ETC card attached to the vehicle, 3336 * ELECTRONIC_TOLL_COLLECTION_CARD_TYPE gives that status of the card; otherwise, 3337 * this property should be UNAVAILABLE. 3338 * 3339 * @change_mode VehiclePropertyChangeMode:ON_CHANGE 3340 * @access VehiclePropertyAccess:READ 3341 * @data_enum ElectronicTollCollectionCardStatus 3342 */ 3343 ELECTRONIC_TOLL_COLLECTION_CARD_STATUS = ( 3344 0x0F3A 3345 | VehiclePropertyGroup:SYSTEM 3346 | VehiclePropertyType:INT32 3347 | VehicleArea:GLOBAL), 3348}; 3349 3350/** 3351 * Used by ELECTRONIC_TOLL_COLLECTION_CARD_TYPE. 3352 */ 3353enum ElectronicTollCollectionCardType : int32_t { 3354 // Type is unknown or not in the list below. 3355 UNKNOWN = 0, 3356 // A Japanese ETC card reader that does not support ETC 2.0. 3357 JP_ELECTRONIC_TOLL_COLLECTION_CARD = 1, 3358 // A Japanese ETC 2.0 card reader. 3359 JP_ELECTRONIC_TOLL_COLLECTION_CARD_V2 = 2, 3360}; 3361 3362/** 3363 * Used by ELECTRONIC_TOLL_COLLECTION_CARD_STATUS. 3364 */ 3365enum ElectronicTollCollectionCardStatus : int32_t { 3366 // Status could not be determined 3367 UNKNOWN = 0, 3368 // A valid ETC card is present 3369 ELECTRONIC_TOLL_COLLECTION_CARD_VALID = 1, 3370 // An ETC card is present, but it is expired or otherwise invalid 3371 ELECTRONIC_TOLL_COLLECTION_CARD_INVALID = 2, 3372 // No ETC card is inserted in the reader. 3373 ELECTRONIC_TOLL_COLLECTION_CARD_NOT_INSERTED = 3, 3374}; 3375 3376/** 3377 * Used by SUPPORT_CUSTOMIZE_VENDOR_PERMISSION to indicate the permission of vendor properties. 3378 */ 3379enum VehicleVendorPermission : int32_t { 3380 PERMISSION_DEFAULT = 0x00000000, 3381 3382 // permissions for the property related with window 3383 PERMISSION_SET_VENDOR_CATEGORY_WINDOW= 0X00000001, 3384 PERMISSION_GET_VENDOR_CATEGORY_WINDOW = 0x00000002, 3385 // permissions for the property related with door 3386 PERMISSION_SET_VENDOR_CATEGORY_DOOR = 0x00000003, 3387 PERMISSION_GET_VENDOR_CATEGORY_DOOR = 0x00000004, 3388 // permissions for the property related with seat 3389 PERMISSION_SET_VENDOR_CATEGORY_SEAT = 0x00000005, 3390 PERMISSION_GET_VENDOR_CATEGORY_SEAT = 0x00000006, 3391 // permissions for the property related with mirror 3392 PERMISSION_SET_VENDOR_CATEGORY_MIRROR= 0x00000007, 3393 PERMISSION_GET_VENDOR_CATEGORY_MIRROR = 0x00000008, 3394 3395 // permissions for the property related with car's information 3396 PERMISSION_SET_VENDOR_CATEGORY_INFO = 0x00000009, 3397 PERMISSION_GET_VENDOR_CATEGORY_INFO = 0x0000000A, 3398 // permissions for the property related with car's engine 3399 PERMISSION_SET_VENDOR_CATEGORY_ENGINE= 0x0000000B, 3400 PERMISSION_GET_VENDOR_CATEGORY_ENGINE = 0x0000000C, 3401 // permissions for the property related with car's HVAC 3402 PERMISSION_SET_VENDOR_CATEGORY_HVAC = 0x0000000D, 3403 PERMISSION_GET_VENDOR_CATEGORY_HVAC = 0x0000000E, 3404 // permissions for the property related with car's light 3405 PERMISSION_SET_VENDOR_CATEGORY_LIGHT = 0x0000000F, 3406 PERMISSION_GET_VENDOR_CATEGORY_LIGHT = 0x00000010, 3407 3408 // permissions reserved for other vendor permission 3409 PERMISSION_SET_VENDOR_CATEGORY_1 = 0x00010000, 3410 PERMISSION_GET_VENDOR_CATEGORY_1 = 0x00011000, 3411 PERMISSION_SET_VENDOR_CATEGORY_2 = 0x00020000, 3412 PERMISSION_GET_VENDOR_CATEGORY_2 = 0x00021000, 3413 PERMISSION_SET_VENDOR_CATEGORY_3 = 0x00030000, 3414 PERMISSION_GET_VENDOR_CATEGORY_3 = 0x00031000, 3415 PERMISSION_SET_VENDOR_CATEGORY_4 = 0x00040000, 3416 PERMISSION_GET_VENDOR_CATEGORY_4 = 0x00041000, 3417 PERMISSION_SET_VENDOR_CATEGORY_5 = 0x00050000, 3418 PERMISSION_GET_VENDOR_CATEGORY_5 = 0x00051000, 3419 PERMISSION_SET_VENDOR_CATEGORY_6 = 0x00060000, 3420 PERMISSION_GET_VENDOR_CATEGORY_6 = 0x00061000, 3421 PERMISSION_SET_VENDOR_CATEGORY_7 = 0x00070000, 3422 PERMISSION_GET_VENDOR_CATEGORY_7 = 0x00071000, 3423 PERMISSION_SET_VENDOR_CATEGORY_8 = 0x00080000, 3424 PERMISSION_GET_VENDOR_CATEGORY_8 = 0x00081000, 3425 PERMISSION_SET_VENDOR_CATEGORY_9 = 0x00090000, 3426 PERMISSION_GET_VENDOR_CATEGORY_9 = 0x00091000, 3427 PERMISSION_SET_VENDOR_CATEGORY_10 = 0x000A0000, 3428 PERMISSION_GET_VENDOR_CATEGORY_10 = 0x000A1000, 3429 3430 // Indicate not available for android to access. 3431 PERMISSION_NOT_ACCESSIBLE = 0xF0000000 3432}; 3433 3434/** 3435 * Used by seat occupancy to enumerate the current occupancy state of the seat. 3436 */ 3437enum VehicleSeatOccupancyState : int32_t { 3438 3439 UNKNOWN = 0, 3440 VACANT = 1, 3441 OCCUPIED = 2 3442}; 3443 3444/** 3445 * Used by EVS_SERVICE_REQUEST to enumerate the service's type. 3446 */ 3447enum EvsServiceType : int32_t { 3448 3449 REARVIEW = 0, 3450 SURROUNDVIEW = 1, 3451}; 3452 3453/** 3454 * Used by EVS_SERVICE_REQUEST to enumerate the service's state. 3455 */ 3456enum EvsServiceState : int32_t { 3457 3458 OFF = 0, 3459 ON = 1, 3460}; 3461 3462/** 3463 * Index in int32VAlues for VehicleProperty#EVS_SERVICE_REQUEST property. 3464 */ 3465enum EvsServiceRequestIndex : int32_t { 3466 3467 TYPE = 0, 3468 STATE = 1, 3469}; 3470 3471/** 3472 * Used by lights state properties to enumerate the current state of the lights. 3473 * 3474 * Most XXX_LIGHTS_STATE properties will only report ON and OFF states. Only 3475 * the HEADLIGHTS_STATE property will report DAYTIME_RUNNING. 3476 */ 3477enum VehicleLightState : int32_t { 3478 3479 OFF = 0, 3480 ON = 1, 3481 DAYTIME_RUNNING = 2 3482}; 3483 3484/** 3485 * Used by lights switch properties to enumerate user selected switch setting. 3486 * 3487 * XXX_LIGHTS_SWITCH properties report the switch settings that the user 3488 * selects. The switch setting may be decoupled from the state reported if the 3489 * user selects AUTOMATIC. 3490 */ 3491enum VehicleLightSwitch : int32_t { 3492 OFF = 0, 3493 ON = 1, 3494 /** 3495 * Daytime running lights mode. Most cars automatically use DRL but some 3496 * cars allow the user to activate them manually. 3497 */ 3498 DAYTIME_RUNNING = 2, 3499 /** 3500 * Allows the vehicle ECU to set the lights automatically 3501 */ 3502 AUTOMATIC = 0x100, 3503}; 3504 3505/** 3506 * Used by INFO_EV_CONNECTOR_TYPE to enumerate the type of connectors 3507 * available to charge the vehicle. 3508 */ 3509enum EvConnectorType : int32_t { 3510 /** 3511 * Default type if the vehicle does not know or report the EV connector 3512 * type. 3513 */ 3514 UNKNOWN = 0, 3515 IEC_TYPE_1_AC = 1, // aka Yazaki 3516 IEC_TYPE_2_AC = 2, // aka Mennekes 3517 IEC_TYPE_3_AC = 3, // aka Scame 3518 IEC_TYPE_4_DC = 4, // aka CHAdeMO 3519 IEC_TYPE_1_CCS_DC = 5, // aka Combo 1 3520 IEC_TYPE_2_CCS_DC = 6, // aka Combo 2 3521 TESLA_ROADSTER = 7, 3522 TESLA_HPWC = 8, 3523 TESLA_SUPERCHARGER = 9, 3524 GBT_AC = 10, 3525 GBT_DC = 11, 3526 3527 /** 3528 * Connector type to use when no other types apply. Before using this 3529 * value, work with Google to see if the EvConnectorType enum can be 3530 * extended with an appropriate value. 3531 */ 3532 OTHER = 101, 3533}; 3534 3535/** 3536 * Used by INFO_FUEL_DOOR_LOCATION/INFO_CHARGE_PORT_LOCATION to enumerate fuel door or 3537 * ev port location. 3538 */ 3539enum PortLocationType : int32_t { 3540 /** 3541 * Default type if the vehicle does not know or report the Fuel door 3542 * and ev port location. 3543 */ 3544 UNKNOWN = 0, 3545 FRONT_LEFT = 1, 3546 FRONT_RIGHT = 2, 3547 REAR_RIGHT = 3, 3548 REAR_LEFT = 4, 3549 FRONT = 5, 3550 REAR = 6, 3551}; 3552 3553/** 3554 * Used by INFO_FUEL_TYPE to enumerate the type of fuels this vehicle uses. 3555 * Consistent with projection protocol. 3556 */ 3557enum FuelType : int32_t { 3558 /** 3559 * Fuel type to use if the HU does not know on which types of fuel the vehicle 3560 * runs. The use of this value is generally discouraged outside of aftermarket units. 3561 */ 3562 FUEL_TYPE_UNKNOWN = 0, 3563 /** Unleaded gasoline */ 3564 FUEL_TYPE_UNLEADED = 1, 3565 /** Leaded gasoline */ 3566 FUEL_TYPE_LEADED = 2, 3567 /** Diesel #1 */ 3568 FUEL_TYPE_DIESEL_1 = 3, 3569 /** Diesel #2 */ 3570 FUEL_TYPE_DIESEL_2 = 4, 3571 /** Biodiesel */ 3572 FUEL_TYPE_BIODIESEL = 5, 3573 /** 85% ethanol/gasoline blend */ 3574 FUEL_TYPE_E85 = 6, 3575 /** Liquified petroleum gas */ 3576 FUEL_TYPE_LPG = 7, 3577 /** Compressed natural gas */ 3578 FUEL_TYPE_CNG = 8, 3579 /** Liquified natural gas */ 3580 FUEL_TYPE_LNG = 9, 3581 /** Electric */ 3582 FUEL_TYPE_ELECTRIC = 10, 3583 /** Hydrogen fuel cell */ 3584 FUEL_TYPE_HYDROGEN = 11, 3585 /** 3586 * Fuel type to use when no other types apply. Before using this value, work with 3587 * Google to see if the FuelType enum can be extended with an appropriate value. 3588 */ 3589 FUEL_TYPE_OTHER = 12, 3590}; 3591 3592/** 3593 * Bit flags for fan direction 3594 */ 3595enum VehicleHvacFanDirection : int32_t { 3596 UNKNOWN = 0x0, 3597 3598 FACE = 0x1, 3599 FLOOR = 0x2, 3600 /** 3601 * FACE_AND_FLOOR = FACE | FLOOR 3602 */ 3603 FACE_AND_FLOOR = 0x3, 3604 DEFROST = 0x4, 3605 /** 3606 * DEFROST_AND_FLOOR = DEFROST | FLOOR 3607 */ 3608 DEFROST_AND_FLOOR = 0x06, 3609}; 3610 3611enum VehicleOilLevel : int32_t { 3612 /** 3613 * Oil level values 3614 */ 3615 CRITICALLY_LOW = 0, 3616 LOW = 1, 3617 NORMAL = 2, 3618 HIGH = 3, 3619 ERROR = 4, 3620}; 3621 3622enum VehicleApPowerStateConfigFlag : int32_t { 3623 /** 3624 * AP can enter deep sleep state. If not set, AP will always shutdown from 3625 * VehicleApPowerState#SHUTDOWN_PREPARE power state. 3626 */ 3627 ENABLE_DEEP_SLEEP_FLAG = 0x1, 3628 3629 /** 3630 * The power controller can power on AP from off state after timeout 3631 * specified in VehicleApPowerSet VEHICLE_AP_POWER_SET_SHUTDOWN_READY message. 3632 */ 3633 CONFIG_SUPPORT_TIMER_POWER_ON_FLAG = 0x2, 3634}; 3635 3636enum VehicleApPowerStateReq : int32_t { 3637 /** 3638 * This requests Android to enter its normal operating state. 3639 * This may be sent after the AP has reported 3640 * VehicleApPowerStateReport#DEEP_SLEEP_EXIT, 3641 * VehicleApPowerStateReport#SHUTDOWN_CANCELLED, or 3642 * VehicleApPowerStateReport#WAIT_FOR_VHAL. 3643 */ 3644 ON = 0, 3645 3646 /** 3647 * The power controller issues this request to shutdown the system. 3648 * This may be sent after the AP has reported 3649 * VehicleApPowerStateReport#DEEP_SLEEP_EXIT, 3650 * VehicleApPowerStateReport#ON, 3651 * VehicleApPowerStateReport#SHUTDOWN_CANCELLED, 3652 * VehicleApPowerStateReport#SHUTDOWN_POSTPONE, 3653 * VehicleApPowerStateReport#SHUTDOWN_PREPARE, or 3654 * VehicleApPowerStateReport#WAIT_FOR_VHAL. 3655 * 3656 * int32Values[1] : One of VehicleApPowerStateShutdownParam. 3657 * This parameter indicates if the AP should shut 3658 * down fully or sleep. This parameter also 3659 * indicates if the shutdown should be immediate 3660 * or if it can be postponed. If the shutdown can 3661 * be postponed, AP requests postponing by sending 3662 * VehicleApPowerStateReport#SHUTDOWN_POSTPONE. 3663 */ 3664 SHUTDOWN_PREPARE = 1, 3665 3666 /** 3667 * Cancel the shutdown. 3668 * This may be sent after the AP has reported 3669 * VehicleApPowerStateReport#SHUTDOWN_POSTPONE or 3670 * VehicleApPowerStateReport#SHUTDOWN_PREPARE. 3671 * After receiving this request, the AP will report 3672 * VehicleApPowerStateReport#WAIT_FOR_VHAL in preparation to going ON. 3673 */ 3674 CANCEL_SHUTDOWN = 2, 3675 3676 /** 3677 * Completes the shutdown process. 3678 * This may be sent after the AP has reported 3679 * VehicleApPowerStateReport#DEEP_SLEEP_ENTRY or 3680 * VehicleApPowerStateReport#SHUTDOWN_START. The AP will not report new 3681 * state information after receiving this request. 3682 */ 3683 FINISHED = 3, 3684}; 3685 3686/** 3687 * Index in int32Values for VehicleProperty#AP_POWER_STATE_REQ property. 3688 */ 3689enum VehicleApPowerStateReqIndex : int32_t { 3690 STATE = 0, 3691 ADDITIONAL = 1, 3692}; 3693 3694 3695 3696enum VehicleApPowerStateShutdownParam : int32_t { 3697 /** AP must shutdown immediately. Postponing is not allowed. */ 3698 SHUTDOWN_IMMEDIATELY = 1, 3699 3700 /** AP can enter deep sleep instead of shutting down completely. */ 3701 CAN_SLEEP = 2, 3702 3703 /** AP can only shutdown with postponing allowed. */ 3704 SHUTDOWN_ONLY = 3, 3705 3706 /** 3707 * AP may enter deep sleep, but must either sleep or shut down immediately. 3708 * Postponing is not allowed. */ 3709 SLEEP_IMMEDIATELY = 4, 3710}; 3711 3712enum VehicleApPowerStateReport : int32_t { 3713 /** 3714 * The device has booted. CarService has initialized and is ready to accept commands 3715 * from VHAL. The user is not logged in, and vendor apps and services are expected to 3716 * control the display and audio. 3717 * After reporting this state, AP will accept VehicleApPowerStateReq#ON or 3718 * VehicleApPowerStateReq#SHUTDOWN_PREPARE. Other power state requests are ignored. 3719 */ 3720 WAIT_FOR_VHAL = 0x1, 3721 3722 /** 3723 * AP is ready to suspend. 3724 * The AP will not send any more state reports after this. 3725 * After reporting this state, AP will accept VehicleApPowerStateReq#FINISHED. 3726 * Other power state requests are ignored. 3727 * 3728 * int32Values[1]: Time to turn AP back on, in seconds. Power controller should turn on 3729 * AP after the specified time has elapsed, so AP can run tasks like 3730 * update. If this value is 0, no wake up is requested. The power 3731 * controller may not necessarily support timed wake-up. 3732 */ 3733 DEEP_SLEEP_ENTRY = 0x2, 3734 3735 /** 3736 * AP is exiting from deep sleep state. 3737 * After reporting this state, AP will accept VehicleApPowerStateReq#ON or 3738 * VehicleApPowerStateReq#SHUTDOWN_PREPARE. Other power state requests are ignored. 3739 */ 3740 DEEP_SLEEP_EXIT = 0x3, 3741 3742 /** 3743 * AP sends this message repeatedly while cleanup and idle tasks execute. 3744 * After reporting this state, AP will accept VehicleApPowerStateReq#SHUTDOWN_PREPARE 3745 * requesting immediate shutdown or VehicleApPowerStateReq#CANCEL_SHUTDOWN. Other 3746 * power state requests are ignored. 3747 * 3748 * int32Values[1]: Time to postpone shutdown in ms. Maximum value is 3749 * 5000 ms. 3750 * If AP needs more time, it will send another SHUTDOWN_POSTPONE 3751 * message before the previous one expires. 3752 */ 3753 SHUTDOWN_POSTPONE = 0x4, 3754 3755 /** 3756 * AP is ready to shutdown. 3757 * The AP will not send any more state reports after this. 3758 * After reporting this state, AP will accept VehicleApPowerStateReq#FINISHED. 3759 * Other power state requests are ignored. 3760 * 3761 * int32Values[1]: Time to turn AP back on, in seconds. Power controller should turn on 3762 * AP after the specified time has elapsed so AP can run tasks like 3763 * update. If this value is 0, no wake up is specified. The power 3764 * controller may not necessarily support timed wake-up. 3765 */ 3766 SHUTDOWN_START = 0x5, 3767 3768 /** 3769 * AP is entering its normal operating state. 3770 * After reporting this state, AP will accept VehicleApPowerStateReq#SHUTDOWN_PREPARE. 3771 * Other power state requests are ignored. 3772 */ 3773 ON = 0x6, 3774 3775 /** 3776 * AP is preparing to shut down. In this state, Garage Mode is active and idle 3777 * tasks are allowed to run. 3778 * After reporting this state, AP will accept VehicleApPowerStateReq#SHUTDOWN_PREPARE 3779 * requesting immediate shutdown or VehicleApPowerStateReq#CANCEL_SHUTDOWN. Other 3780 * power state requests are ignored. 3781 */ 3782 SHUTDOWN_PREPARE = 0x7, 3783 3784 /** 3785 * AP has stopped preparing to shut down. 3786 * After reporting this state, AP will accept VehicleApPowerStateReq#ON or 3787 * VehicleApPowerStateReq#SHUTDOWN_PREPARE. Other power state requests are ignored. 3788 */ 3789 SHUTDOWN_CANCELLED = 0x8, 3790}; 3791 3792enum VehicleHwKeyInputAction : int32_t { 3793 /** Key down */ 3794 ACTION_DOWN = 0, 3795 3796 /** Key up */ 3797 ACTION_UP = 1, 3798}; 3799 3800enum VehicleDisplay : int32_t { 3801 /** The primary Android display (for example, center console) */ 3802 MAIN = 0, 3803 3804 INSTRUMENT_CLUSTER = 1, 3805}; 3806 3807/** 3808 * Units used for int or float type with no attached enum types. 3809 */ 3810enum VehicleUnit : int32_t { 3811 SHOULD_NOT_USE = 0x000, 3812 3813 METER_PER_SEC = 0x01, 3814 RPM = 0x02, 3815 HERTZ = 0x03, 3816 PERCENTILE = 0x10, 3817 MILLIMETER = 0x20, 3818 METER = 0x21, 3819 KILOMETER = 0x23, 3820 MILE = 0x24, 3821 CELSIUS = 0x30, 3822 FAHRENHEIT = 0x31, 3823 KELVIN = 0x32, 3824 MILLILITER = 0x40, 3825 LITER = 0x41, 3826 3827 /** deprecated. Use US_GALLON instead. */ 3828 GALLON = 0x42, 3829 US_GALLON = 0x42, 3830 IMPERIAL_GALLON = 0x43, 3831 NANO_SECS = 0x50, 3832 MILLI_SECS = 0x51, 3833 SECS = 0x53, 3834 YEAR = 0x59, 3835 3836 // Electrical Units 3837 WATT_HOUR = 0x60, 3838 MILLIAMPERE = 0x61, 3839 MILLIVOLT = 0x62, 3840 MILLIWATTS = 0x63, 3841 AMPERE_HOURS = 0x64, 3842 KILOWATT_HOUR = 0x65, 3843 3844 KILOPASCAL = 0x70, 3845 PSI = 0x71, 3846 BAR = 0x72, 3847 DEGREES = 0x80, 3848 3849 MILES_PER_HOUR = 0x90, 3850 KILOMETERS_PER_HOUR = 0x91, 3851}; 3852 3853/** 3854 * This describes how value of property can change. 3855 */ 3856enum VehiclePropertyChangeMode : int32_t { 3857 /** 3858 * Property of this type must never be changed. Subscription is not supported 3859 * for these properties. 3860 */ 3861 STATIC = 0x00, 3862 3863 /** 3864 * Properties of this type must report when there is a change. 3865 * IVehicle#get call must return the current value. 3866 * Set operation for this property is assumed to be asynchronous. When the 3867 * property is read (using IVehicle#get) after IVehicle#set, it may still 3868 * return old value until underlying H/W backing this property has actually 3869 * changed the state. Once state is changed, the property must dispatch 3870 * changed value as event. 3871 */ 3872 ON_CHANGE = 0x01, 3873 3874 /** 3875 * Properties of this type change continuously and require a fixed rate of 3876 * sampling to retrieve the data. Implementers may choose to send extra 3877 * notifications on significant value changes. 3878 */ 3879 CONTINUOUS = 0x02, 3880}; 3881 3882/** 3883 * Property config defines the capabilities of it. User of the API 3884 * must first get the property config to understand the output from get() 3885 * commands and also to ensure that set() or events commands are in sync with 3886 * the expected output. 3887 */ 3888enum VehiclePropertyAccess : int32_t { 3889 NONE = 0x00, 3890 3891 READ = 0x01, 3892 WRITE = 0x02, 3893 READ_WRITE = 0x03, 3894}; 3895 3896/** 3897 * Property status is a dynamic value that may change based on the vehicle state. 3898 */ 3899enum VehiclePropertyStatus : int32_t { 3900 /** Property is available and behaving normally */ 3901 AVAILABLE = 0x00, 3902 /** 3903 * A property in this state is not available for reading and writing. This 3904 * is a transient state that depends on the availability of the underlying 3905 * implementation (e.g. hardware or driver). It MUST NOT be used to 3906 * represent features that this vehicle is always incapable of. A get() of 3907 * a property in this state MAY return an undefined value, but MUST 3908 * correctly describe its status as UNAVAILABLE A set() of a property in 3909 * this state MAY return NOT_AVAILABLE. The HAL implementation MUST ignore 3910 * the value of the status field when writing a property value coming from 3911 * Android. 3912 */ 3913 UNAVAILABLE = 0x01, 3914 /** There is an error with this property. */ 3915 ERROR = 0x02, 3916}; 3917 3918/** 3919 * Various gears which can be selected by user and chosen in system. 3920 */ 3921enum VehicleGear : int32_t { 3922 GEAR_UNKNOWN = 0x0000, 3923 3924 GEAR_NEUTRAL = 0x0001, 3925 GEAR_REVERSE = 0x0002, 3926 GEAR_PARK = 0x0004, 3927 GEAR_DRIVE = 0x0008, 3928 GEAR_1 = 0x0010, 3929 GEAR_2 = 0x0020, 3930 GEAR_3 = 0x0040, 3931 GEAR_4 = 0x0080, 3932 GEAR_5 = 0x0100, 3933 GEAR_6 = 0x0200, 3934 GEAR_7 = 0x0400, 3935 GEAR_8 = 0x0800, 3936 GEAR_9 = 0x1000, 3937}; 3938 3939/** 3940 * Various Seats in the car. 3941 */ 3942enum VehicleAreaSeat : int32_t { 3943 ROW_1_LEFT = 0x0001, 3944 ROW_1_CENTER = 0x0002, 3945 ROW_1_RIGHT = 0x0004, 3946 ROW_2_LEFT = 0x0010, 3947 ROW_2_CENTER = 0x0020, 3948 ROW_2_RIGHT = 0x0040, 3949 ROW_3_LEFT = 0x0100, 3950 ROW_3_CENTER = 0x0200, 3951 ROW_3_RIGHT = 0x0400 3952}; 3953 3954/** 3955 * Various windshields/windows in the car. 3956 */ 3957enum VehicleAreaWindow : int32_t { 3958 FRONT_WINDSHIELD = 0x00000001, 3959 REAR_WINDSHIELD = 0x00000002, 3960 ROW_1_LEFT = 0x00000010, 3961 ROW_1_RIGHT = 0x00000040, 3962 ROW_2_LEFT = 0x00000100, 3963 ROW_2_RIGHT = 0x00000400, 3964 ROW_3_LEFT = 0x00001000, 3965 ROW_3_RIGHT = 0x00004000, 3966 3967 ROOF_TOP_1 = 0x00010000, 3968 ROOF_TOP_2 = 0x00020000, 3969 3970}; 3971 3972enum VehicleAreaDoor : int32_t { 3973 ROW_1_LEFT = 0x00000001, 3974 ROW_1_RIGHT = 0x00000004, 3975 ROW_2_LEFT = 0x00000010, 3976 ROW_2_RIGHT = 0x00000040, 3977 ROW_3_LEFT = 0x00000100, 3978 ROW_3_RIGHT = 0x00000400, 3979 HOOD = 0x10000000, 3980 REAR = 0x20000000, 3981}; 3982 3983enum VehicleAreaMirror : int32_t { 3984 DRIVER_LEFT = 0x00000001, 3985 DRIVER_RIGHT = 0x00000002, 3986 DRIVER_CENTER = 0x00000004, 3987}; 3988 3989enum VehicleTurnSignal : int32_t { 3990 NONE = 0x00, 3991 RIGHT = 0x01, 3992 LEFT = 0x02, 3993}; 3994 3995struct VehicleAreaConfig { 3996 /** 3997 * Area id is ignored for VehiclePropertyGroup:GLOBAL properties. 3998 */ 3999 int32_t areaId; 4000 4001 /** 4002 * If the property has @data_enum, leave the range to zero. 4003 * 4004 * Range will be ignored in the following cases: 4005 * - The VehiclePropertyType is not INT32, INT64 or FLOAT. 4006 * - Both of min value and max value are zero. 4007 */ 4008 4009 int32_t minInt32Value; 4010 int32_t maxInt32Value; 4011 4012 int64_t minInt64Value; 4013 int64_t maxInt64Value; 4014 4015 float minFloatValue; 4016 float maxFloatValue; 4017}; 4018 4019struct VehiclePropConfig { 4020 /** Property identifier */ 4021 int32_t prop; 4022 4023 /** 4024 * Defines if the property is read or write or both. 4025 */ 4026 VehiclePropertyAccess access; 4027 4028 /** 4029 * Defines the change mode of the property. 4030 */ 4031 VehiclePropertyChangeMode changeMode; 4032 4033 /** 4034 * Contains per-area configuration. 4035 */ 4036 vec<VehicleAreaConfig> areaConfigs; 4037 4038 /** Contains additional configuration parameters */ 4039 vec<int32_t> configArray; 4040 4041 /** 4042 * Some properties may require additional information passed over this 4043 * string. Most properties do not need to set this. 4044 */ 4045 string configString; 4046 4047 /** 4048 * Min sample rate in Hz. 4049 * Must be defined for VehiclePropertyChangeMode::CONTINUOUS 4050 */ 4051 float minSampleRate; 4052 4053 /** 4054 * Must be defined for VehiclePropertyChangeMode::CONTINUOUS 4055 * Max sample rate in Hz. 4056 */ 4057 float maxSampleRate; 4058}; 4059 4060/** 4061 * Encapsulates the property name and the associated value. It 4062 * is used across various API calls to set values, get values or to register for 4063 * events. 4064 */ 4065struct VehiclePropValue { 4066 /** 4067 * Time is elapsed nanoseconds since boot. It's equivalent to 4068 * {@code SystemClock.elapsedRealtimeNano()}. 4069 */ 4070 int64_t timestamp; 4071 4072 /** 4073 * Area type(s) for non-global property it must be one of the value from 4074 * VehicleArea* enums or 0 for global properties. 4075 */ 4076 int32_t areaId; 4077 4078 /** Property identifier */ 4079 int32_t prop; 4080 4081 /** Status of the property */ 4082 VehiclePropertyStatus status; 4083 4084 /** 4085 * Contains value for a single property. Depending on property data type of 4086 * this property (VehiclePropetyType) one field of this structure must be filled in. 4087 */ 4088 struct RawValue { 4089 /** 4090 * This is used for properties of types VehiclePropertyType#INT 4091 * and VehiclePropertyType#INT_VEC 4092 */ 4093 vec<int32_t> int32Values; 4094 4095 /** 4096 * This is used for properties of types VehiclePropertyType#FLOAT 4097 * and VehiclePropertyType#FLOAT_VEC 4098 */ 4099 vec<float> floatValues; 4100 4101 /** This is used for properties of type VehiclePropertyType#INT64 */ 4102 vec<int64_t> int64Values; 4103 4104 /** This is used for properties of type VehiclePropertyType#BYTES */ 4105 vec<uint8_t> bytes; 4106 4107 /** This is used for properties of type VehiclePropertyType#STRING */ 4108 string stringValue; 4109 }; 4110 4111 RawValue value; 4112}; 4113 4114enum VehicleIgnitionState : int32_t { 4115 UNDEFINED = 0, 4116 4117 /** Steering wheel is locked */ 4118 LOCK = 1, 4119 4120 /** 4121 * Steering wheel is not locked, engine and all accessories are OFF. If 4122 * car can be in LOCK and OFF state at the same time than HAL must report 4123 * LOCK state. 4124 */ 4125 OFF, 4126 4127 /** 4128 * Typically in this state accessories become available (e.g. radio). 4129 * Instrument cluster and engine are turned off 4130 */ 4131 ACC, 4132 4133 /** 4134 * Ignition is in state ON. Accessories and instrument cluster available, 4135 * engine might be running or ready to be started. 4136 */ 4137 ON, 4138 4139 /** Typically in this state engine is starting (cranking). */ 4140 START 4141}; 4142 4143enum SubscribeFlags : int32_t { 4144 UNDEFINED = 0x0, 4145 4146 /** 4147 * Subscribe to event that was originated in vehicle HAL 4148 * (most likely this event came from the vehicle itself). 4149 */ 4150 EVENTS_FROM_CAR = 0x1, 4151 4152 /** 4153 * Use this flag to subscribe on events when IVehicle#set(...) was called by 4154 * vehicle HAL's client (e.g. Car Service). 4155 */ 4156 EVENTS_FROM_ANDROID = 0x2, 4157}; 4158 4159/** 4160 * Encapsulates information about subscription to vehicle property events. 4161 */ 4162struct SubscribeOptions { 4163 /** Property to subscribe */ 4164 int32_t propId; 4165 4166 /** 4167 * Sample rate in Hz. 4168 * 4169 * Must be provided for properties with 4170 * VehiclePropertyChangeMode::CONTINUOUS. The value must be within 4171 * VehiclePropConfig#minSamplingRate .. VehiclePropConfig#maxSamplingRate 4172 * for a given property. 4173 * This value indicates how many updates per second client wants to receive. 4174 */ 4175 float sampleRate; 4176 4177 /** Flags that indicate to which event sources to listen. */ 4178 SubscribeFlags flags; 4179}; 4180 4181/** Error codes used in vehicle HAL interface. */ 4182enum StatusCode : int32_t { 4183 OK = 0, 4184 4185 /** Try again. */ 4186 TRY_AGAIN = 1, 4187 4188 /** Invalid argument provided. */ 4189 INVALID_ARG = 2, 4190 4191 /** 4192 * This code must be returned when device that associated with the vehicle 4193 * property is not available. For example, when client tries to set HVAC 4194 * temperature when the whole HVAC unit is turned OFF. 4195 */ 4196 NOT_AVAILABLE = 3, 4197 4198 /** Access denied */ 4199 ACCESS_DENIED = 4, 4200 4201 /** Something unexpected has happened in Vehicle HAL */ 4202 INTERNAL_ERROR = 5, 4203}; 4204 4205enum VehicleAreaWheel : int32_t { 4206 UNKNOWN = 0x0, 4207 4208 LEFT_FRONT = 0x1, 4209 RIGHT_FRONT = 0x2, 4210 LEFT_REAR = 0x4, 4211 RIGHT_REAR = 0x8, 4212}; 4213 4214/** 4215 * The status of the vehicle's fuel system. 4216 * These values come from the SAE J1979 standard. 4217 */ 4218enum Obd2FuelSystemStatus : int32_t { 4219 OPEN_INSUFFICIENT_ENGINE_TEMPERATURE = 1, 4220 CLOSED_LOOP = 2, 4221 OPEN_ENGINE_LOAD_OR_DECELERATION = 4, 4222 OPEN_SYSTEM_FAILURE = 8, 4223 CLOSED_LOOP_BUT_FEEDBACK_FAULT = 16, 4224}; 4225 4226/** Defines which ignition monitors are available to be read. */ 4227enum Obd2IgnitionMonitorKind : int32_t { 4228 SPARK = 0, 4229 COMPRESSION = 1, 4230}; 4231 4232/** 4233 * Ignition monitors common to both SPARK and COMPRESSION. 4234 * These values come from the SAE J1979 standard. 4235 */ 4236enum Obd2CommonIgnitionMonitors : int32_t { 4237 COMPONENTS_AVAILABLE = 0x1 << 0, 4238 COMPONENTS_INCOMPLETE = 0x1 << 1, 4239 4240 FUEL_SYSTEM_AVAILABLE = 0x1 << 2, 4241 FUEL_SYSTEM_INCOMPLETE = 0x1 << 3, 4242 4243 MISFIRE_AVAILABLE = 0x1 << 4, 4244 MISFIRE_INCOMPLETE = 0x1 << 5, 4245}; 4246 4247/** 4248 * Ignition monitors available for SPARK vehicles. 4249 * These values come from the SAE J1979 standard. 4250 */ 4251enum Obd2SparkIgnitionMonitors : Obd2CommonIgnitionMonitors { 4252 EGR_AVAILABLE = 0x1 << 6, 4253 EGR_INCOMPLETE = 0x1 << 7, 4254 4255 OXYGEN_SENSOR_HEATER_AVAILABLE = 0x1 << 8, 4256 OXYGEN_SENSOR_HEATER_INCOMPLETE = 0x1 << 9, 4257 4258 OXYGEN_SENSOR_AVAILABLE = 0x1 << 10, 4259 OXYGEN_SENSOR_INCOMPLETE = 0x1 << 11, 4260 4261 AC_REFRIGERANT_AVAILABLE = 0x1 << 12, 4262 AC_REFRIGERANT_INCOMPLETE = 0x1 << 13, 4263 4264 SECONDARY_AIR_SYSTEM_AVAILABLE = 0x1 << 14, 4265 SECONDARY_AIR_SYSTEM_INCOMPLETE = 0x1 << 15, 4266 4267 EVAPORATIVE_SYSTEM_AVAILABLE = 0x1 << 16, 4268 EVAPORATIVE_SYSTEM_INCOMPLETE = 0x1 << 17, 4269 4270 HEATED_CATALYST_AVAILABLE = 0x1 << 18, 4271 HEATED_CATALYST_INCOMPLETE = 0x1 << 19, 4272 4273 CATALYST_AVAILABLE = 0x1 << 20, 4274 CATALYST_INCOMPLETE = 0x1 << 21, 4275}; 4276 4277/** 4278 * Ignition monitors only available for COMPRESSION vehicles. 4279 * These values come from the SAE J1979 standard. 4280 */ 4281enum Obd2CompressionIgnitionMonitors : Obd2CommonIgnitionMonitors { 4282 EGR_OR_VVT_AVAILABLE = 0x1 << 6, 4283 EGR_OR_VVT_INCOMPLETE = 0x1 << 7, 4284 4285 PM_FILTER_AVAILABLE = 0x1 << 8, 4286 PM_FILTER_INCOMPLETE = 0x1 << 9, 4287 4288 EXHAUST_GAS_SENSOR_AVAILABLE = 0x1 << 10, 4289 EXHAUST_GAS_SENSOR_INCOMPLETE = 0x1 << 11, 4290 4291 BOOST_PRESSURE_AVAILABLE = 0x1 << 12, 4292 BOOST_PRESSURE_INCOMPLETE = 0x1 << 13, 4293 4294 NOx_SCR_AVAILABLE = 0x1 << 14, 4295 NOx_SCR_INCOMPLETE = 0x1 << 15, 4296 4297 NMHC_CATALYST_AVAILABLE = 0x1 << 16, 4298 NMHC_CATALYST_INCOMPLETE = 0x1 << 17, 4299}; 4300 4301/** 4302 * The status of the vehicle's secondary air system. 4303 * These values come from the SAE J1979 standard. 4304 */ 4305enum Obd2SecondaryAirStatus : int32_t { 4306 UPSTREAM = 1, 4307 DOWNSTREAM_OF_CATALYCIC_CONVERTER = 2, 4308 FROM_OUTSIDE_OR_OFF = 4, 4309 PUMP_ON_FOR_DIAGNOSTICS = 8, 4310}; 4311 4312/** 4313 * The fuel type(s) supported by a vehicle. 4314 * These values come from the SAE J1979 standard. 4315 */ 4316enum Obd2FuelType : int32_t { 4317 NOT_AVAILABLE = 0, 4318 GASOLINE = 1, 4319 METHANOL = 2, 4320 ETHANOL = 3, 4321 DIESEL = 4, 4322 LPG = 5, 4323 CNG = 6, 4324 PROPANE = 7, 4325 ELECTRIC = 8, 4326 BIFUEL_RUNNING_GASOLINE = 9, 4327 BIFUEL_RUNNING_METHANOL = 10, 4328 BIFUEL_RUNNING_ETHANOL = 11, 4329 BIFUEL_RUNNING_LPG = 12, 4330 BIFUEL_RUNNING_CNG = 13, 4331 BIFUEL_RUNNING_PROPANE = 14, 4332 BIFUEL_RUNNING_ELECTRIC = 15, 4333 BIFUEL_RUNNING_ELECTRIC_AND_COMBUSTION = 16, 4334 HYBRID_GASOLINE = 17, 4335 HYBRID_ETHANOL = 18, 4336 HYBRID_DIESEL = 19, 4337 HYBRID_ELECTRIC = 20, 4338 HYBRID_RUNNING_ELECTRIC_AND_COMBUSTION = 21, 4339 HYBRID_REGENERATIVE = 22, 4340 BIFUEL_RUNNING_DIESEL = 23, 4341}; 4342 4343/** 4344 * This enum provides the canonical mapping for sensor properties that have an integer value. 4345 * The ordering of the values is taken from the OBD2 specification. 4346 * Some of the properties are represented as an integer mapping to another enum. In those cases 4347 * expect a comment by the property definition describing the enum to look at for the mapping. 4348 * Any value greater than the last reserved index is available to vendors to map their extensions. 4349 * While these values do not directly map to SAE J1979 PIDs, an equivalence is listed next 4350 * to each one to aid implementors. 4351 */ 4352enum DiagnosticIntegerSensorIndex : int32_t { 4353 /** refer to FuelSystemStatus for a description of this value. */ 4354 FUEL_SYSTEM_STATUS = 0, /* PID 0x03 */ 4355 MALFUNCTION_INDICATOR_LIGHT_ON = 1, /* PID 0x01 */ 4356 4357 /** refer to IgnitionMonitorKind for a description of this value. */ 4358 IGNITION_MONITORS_SUPPORTED = 2, /* PID 0x01 */ 4359 4360 /** 4361 * The value of this sensor is a bitmask that specifies whether ignition-specific 4362 * tests are available and whether they are complete. The semantics of the individual 4363 * bits in this value are given by, respectively, SparkIgnitionMonitors and 4364 * CompressionIgnitionMonitors depending on the value of IGNITION_MONITORS_SUPPORTED. 4365 */ 4366 IGNITION_SPECIFIC_MONITORS = 3, /* PID 0x01 */ 4367 INTAKE_AIR_TEMPERATURE = 4, /* PID 0x0F */ 4368 4369 /** refer to SecondaryAirStatus for a description of this value. */ 4370 COMMANDED_SECONDARY_AIR_STATUS = 5, /* PID 0x12 */ 4371 NUM_OXYGEN_SENSORS_PRESENT = 6, /* PID 0x13 */ 4372 RUNTIME_SINCE_ENGINE_START = 7, /* PID 0x1F */ 4373 DISTANCE_TRAVELED_WITH_MALFUNCTION_INDICATOR_LIGHT_ON = 8, /* PID 0x21 */ 4374 WARMUPS_SINCE_CODES_CLEARED = 9, /* PID 0x30 */ 4375 DISTANCE_TRAVELED_SINCE_CODES_CLEARED = 10, /* PID 0x31 */ 4376 ABSOLUTE_BAROMETRIC_PRESSURE = 11, /* PID 0x33 */ 4377 CONTROL_MODULE_VOLTAGE = 12, /* PID 0x42 */ 4378 AMBIENT_AIR_TEMPERATURE = 13, /* PID 0x46 */ 4379 TIME_WITH_MALFUNCTION_LIGHT_ON = 14, /* PID 0x4D */ 4380 TIME_SINCE_TROUBLE_CODES_CLEARED = 15, /* PID 0x4E */ 4381 MAX_FUEL_AIR_EQUIVALENCE_RATIO = 16, /* PID 0x4F */ 4382 MAX_OXYGEN_SENSOR_VOLTAGE = 17, /* PID 0x4F */ 4383 MAX_OXYGEN_SENSOR_CURRENT = 18, /* PID 0x4F */ 4384 MAX_INTAKE_MANIFOLD_ABSOLUTE_PRESSURE = 19, /* PID 0x4F */ 4385 MAX_AIR_FLOW_RATE_FROM_MASS_AIR_FLOW_SENSOR = 20, /* PID 0x50 */ 4386 4387 /** refer to FuelType for a description of this value. */ 4388 FUEL_TYPE = 21, /* PID 0x51 */ 4389 FUEL_RAIL_ABSOLUTE_PRESSURE = 22, /* PID 0x59 */ 4390 ENGINE_OIL_TEMPERATURE = 23, /* PID 0x5C */ 4391 DRIVER_DEMAND_PERCENT_TORQUE = 24, /* PID 0x61 */ 4392 ENGINE_ACTUAL_PERCENT_TORQUE = 25, /* PID 0x62 */ 4393 ENGINE_REFERENCE_PERCENT_TORQUE = 26, /* PID 0x63 */ 4394 ENGINE_PERCENT_TORQUE_DATA_IDLE = 27, /* PID 0x64 */ 4395 ENGINE_PERCENT_TORQUE_DATA_POINT1 = 28, /* PID 0x64 */ 4396 ENGINE_PERCENT_TORQUE_DATA_POINT2 = 29, /* PID 0x64 */ 4397 ENGINE_PERCENT_TORQUE_DATA_POINT3 = 30, /* PID 0x64 */ 4398 ENGINE_PERCENT_TORQUE_DATA_POINT4 = 31, /* PID 0x64 */ 4399 LAST_SYSTEM_INDEX = ENGINE_PERCENT_TORQUE_DATA_POINT4, 4400}; 4401 4402/** 4403 * This enum provides the canonical mapping for sensor properties that have a floating-point value. 4404 * The ordering of the values is taken from the OBD2 specification. 4405 * Any value greater than the last reserved index is available to vendors to map their extensions. 4406 * While these values do not directly map to SAE J1979 PIDs, an equivalence is listed next 4407 * to each one to aid implementors. 4408 */ 4409enum DiagnosticFloatSensorIndex : int32_t { 4410 CALCULATED_ENGINE_LOAD = 0, /* PID 0x04 */ 4411 ENGINE_COOLANT_TEMPERATURE = 1, /* PID 0x05 */ 4412 SHORT_TERM_FUEL_TRIM_BANK1 = 2, /* PID 0x06 */ 4413 LONG_TERM_FUEL_TRIM_BANK1 = 3, /* PID 0x07 */ 4414 SHORT_TERM_FUEL_TRIM_BANK2 = 4, /* PID 0x08 */ 4415 LONG_TERM_FUEL_TRIM_BANK2 = 5, /* PID 0x09 */ 4416 FUEL_PRESSURE = 6, /* PID 0x0A */ 4417 INTAKE_MANIFOLD_ABSOLUTE_PRESSURE = 7, /* PID 0x0B */ 4418 ENGINE_RPM = 8, /* PID 0x0C */ 4419 VEHICLE_SPEED = 9, /* PID 0x0D */ 4420 TIMING_ADVANCE = 10, /* PID 0x0E */ 4421 MAF_AIR_FLOW_RATE = 11, /* PID 0x10 */ 4422 THROTTLE_POSITION = 12, /* PID 0x11 */ 4423 OXYGEN_SENSOR1_VOLTAGE = 13, /* PID 0x14 */ 4424 OXYGEN_SENSOR1_SHORT_TERM_FUEL_TRIM = 14, /* PID 0x14 */ 4425 OXYGEN_SENSOR1_FUEL_AIR_EQUIVALENCE_RATIO = 15, /* PID 0x24 */ 4426 OXYGEN_SENSOR2_VOLTAGE = 16, /* PID 0x15 */ 4427 OXYGEN_SENSOR2_SHORT_TERM_FUEL_TRIM = 17, /* PID 0x15 */ 4428 OXYGEN_SENSOR2_FUEL_AIR_EQUIVALENCE_RATIO = 18, /* PID 0x25 */ 4429 OXYGEN_SENSOR3_VOLTAGE = 19, /* PID 0x16 */ 4430 OXYGEN_SENSOR3_SHORT_TERM_FUEL_TRIM = 20, /* PID 0x16 */ 4431 OXYGEN_SENSOR3_FUEL_AIR_EQUIVALENCE_RATIO = 21, /* PID 0x26 */ 4432 OXYGEN_SENSOR4_VOLTAGE = 22, /* PID 0x17 */ 4433 OXYGEN_SENSOR4_SHORT_TERM_FUEL_TRIM = 23, /* PID 0x17 */ 4434 OXYGEN_SENSOR4_FUEL_AIR_EQUIVALENCE_RATIO = 24, /* PID 0x27 */ 4435 OXYGEN_SENSOR5_VOLTAGE = 25, /* PID 0x18 */ 4436 OXYGEN_SENSOR5_SHORT_TERM_FUEL_TRIM = 26, /* PID 0x18 */ 4437 OXYGEN_SENSOR5_FUEL_AIR_EQUIVALENCE_RATIO = 27, /* PID 0x28 */ 4438 OXYGEN_SENSOR6_VOLTAGE = 28, /* PID 0x19 */ 4439 OXYGEN_SENSOR6_SHORT_TERM_FUEL_TRIM = 29, /* PID 0x19 */ 4440 OXYGEN_SENSOR6_FUEL_AIR_EQUIVALENCE_RATIO = 30, /* PID 0x29 */ 4441 OXYGEN_SENSOR7_VOLTAGE = 31, /* PID 0x1A */ 4442 OXYGEN_SENSOR7_SHORT_TERM_FUEL_TRIM = 32, /* PID 0x1A */ 4443 OXYGEN_SENSOR7_FUEL_AIR_EQUIVALENCE_RATIO = 33, /* PID 0x2A */ 4444 OXYGEN_SENSOR8_VOLTAGE = 34, /* PID 0x1B */ 4445 OXYGEN_SENSOR8_SHORT_TERM_FUEL_TRIM = 35, /* PID 0x1B */ 4446 OXYGEN_SENSOR8_FUEL_AIR_EQUIVALENCE_RATIO = 36, /* PID 0x2B */ 4447 FUEL_RAIL_PRESSURE = 37, /* PID 0x22 */ 4448 FUEL_RAIL_GAUGE_PRESSURE = 38, /* PID 0x23 */ 4449 COMMANDED_EXHAUST_GAS_RECIRCULATION = 39, /* PID 0x2C */ 4450 EXHAUST_GAS_RECIRCULATION_ERROR = 40, /* PID 0x2D */ 4451 COMMANDED_EVAPORATIVE_PURGE = 41, /* PID 0x2E */ 4452 FUEL_TANK_LEVEL_INPUT = 42, /* PID 0x2F */ 4453 EVAPORATION_SYSTEM_VAPOR_PRESSURE = 43, /* PID 0x32 */ 4454 CATALYST_TEMPERATURE_BANK1_SENSOR1 = 44, /* PID 0x3C */ 4455 CATALYST_TEMPERATURE_BANK2_SENSOR1 = 45, /* PID 0x3D */ 4456 CATALYST_TEMPERATURE_BANK1_SENSOR2 = 46, /* PID 0x3E */ 4457 CATALYST_TEMPERATURE_BANK2_SENSOR2 = 47, /* PID 0x3F */ 4458 ABSOLUTE_LOAD_VALUE = 48, /* PID 0x43 */ 4459 FUEL_AIR_COMMANDED_EQUIVALENCE_RATIO = 49, /* PID 0x44 */ 4460 RELATIVE_THROTTLE_POSITION = 50, /* PID 0x45 */ 4461 ABSOLUTE_THROTTLE_POSITION_B = 51, /* PID 0x47 */ 4462 ABSOLUTE_THROTTLE_POSITION_C = 52, /* PID 0x48 */ 4463 ACCELERATOR_PEDAL_POSITION_D = 53, /* PID 0x49 */ 4464 ACCELERATOR_PEDAL_POSITION_E = 54, /* PID 0x4A */ 4465 ACCELERATOR_PEDAL_POSITION_F = 55, /* PID 0x4B */ 4466 COMMANDED_THROTTLE_ACTUATOR = 56, /* PID 0x4C */ 4467 ETHANOL_FUEL_PERCENTAGE = 57, /* PID 0x52 */ 4468 ABSOLUTE_EVAPORATION_SYSTEM_VAPOR_PRESSURE = 58, /* PID 0x53 */ 4469 SHORT_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK1 = 59, /* PID 0x55 */ 4470 SHORT_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK2 = 60, /* PID 0x57 */ 4471 SHORT_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK3 = 61, /* PID 0x55 */ 4472 SHORT_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK4 = 62, /* PID 0x57 */ 4473 LONG_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK1 = 63, /* PID 0x56 */ 4474 LONG_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK2 = 64, /* PID 0x58 */ 4475 LONG_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK3 = 65, /* PID 0x56 */ 4476 LONG_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK4 = 66, /* PID 0x58 */ 4477 RELATIVE_ACCELERATOR_PEDAL_POSITION = 67, /* PID 0x5A */ 4478 HYBRID_BATTERY_PACK_REMAINING_LIFE = 68, /* PID 0x5B */ 4479 FUEL_INJECTION_TIMING = 69, /* PID 0x5D */ 4480 ENGINE_FUEL_RATE = 70, /* PID 0x5E */ 4481 LAST_SYSTEM_INDEX = ENGINE_FUEL_RATE, 4482}; 4483 4484/** 4485 * This enum lists the types of supported VMS messages. It is used as the first 4486 * integer in the vehicle property integers array and determines how the rest of 4487 * the message is decoded. 4488 */ 4489enum VmsMessageType : int32_t { 4490 /** 4491 * A request from the subscribers to the VMS service to subscribe to a layer. 4492 * 4493 * This message type uses enum VmsMessageWithLayerIntegerValuesIndex. 4494 */ 4495 SUBSCRIBE = 1, 4496 4497 /** 4498 * A request from the subscribers to the VMS service to subscribe to a layer from a specific publisher. 4499 * 4500 * This message type uses enum VmsMessageWithLayerAndPublisherIdIntegerValuesIndex. 4501 */ 4502 SUBSCRIBE_TO_PUBLISHER = 2, 4503 4504 /** 4505 * A request from the subscribers to the VMS service to unsubscribes from a layer. 4506 * 4507 * This message type uses enum VmsMessageWithLayerIntegerValuesIndex. 4508 */ 4509 UNSUBSCRIBE = 3, 4510 4511 /** 4512 * A request from the subscribers to the VMS service to unsubscribes from a layer from a specific publisher. 4513 * 4514 * This message type uses enum VmsMessageWithLayerAndPublisherIdIntegerValuesIndex. 4515 */ 4516 UNSUBSCRIBE_TO_PUBLISHER = 4, 4517 4518 /** 4519 * Information from the publishers to the VMS service about the layers which the client can publish. 4520 * 4521 * This message type uses enum VmsOfferingMessageIntegerValuesIndex. 4522 */ 4523 OFFERING = 5, 4524 4525 /** 4526 * A request from the subscribers to the VMS service to get the available layers. 4527 * 4528 * This message type uses enum VmsBaseMessageIntegerValuesIndex. 4529 */ 4530 AVAILABILITY_REQUEST = 6, 4531 4532 /** 4533 * A request from the publishers to the VMS service to get the layers with subscribers. 4534 * 4535 * This message type uses enum VmsBaseMessageIntegerValuesIndex. 4536 */ 4537 SUBSCRIPTIONS_REQUEST = 7, 4538 4539 /** 4540 * A response from the VMS service to the subscribers to a VmsMessageType.AVAILABILITY_REQUEST 4541 * 4542 * This message type uses enum VmsAvailabilityStateIntegerValuesIndex. 4543 */ 4544 AVAILABILITY_RESPONSE = 8, 4545 4546 /** 4547 * A notification from the VMS service to the subscribers on a change in the available layers. 4548 * 4549 * This message type uses enum VmsAvailabilityStateIntegerValuesIndex. 4550 */ 4551 AVAILABILITY_CHANGE = 9, 4552 4553 /** 4554 * A response from the VMS service to the publishers to a VmsMessageType.SUBSCRIPTIONS_REQUEST 4555 * 4556 * This message type uses enum VmsSubscriptionsStateIntegerValuesIndex. 4557 */ 4558 SUBSCRIPTIONS_RESPONSE = 10, 4559 4560 /** 4561 * A notification from the VMS service to the publishers on a change in the layers with subscribers. 4562 * 4563 * This message type uses enum VmsSubscriptionsStateIntegerValuesIndex. 4564 */ 4565 SUBSCRIPTIONS_CHANGE = 11, 4566 4567 /** 4568 * A message from the VMS service to the subscribers or from the publishers to the VMS service 4569 * with a serialized VMS data packet as defined in the VMS protocol. 4570 * 4571 * This message type uses enum VmsMessageWithLayerAndPublisherIdIntegerValuesIndex. 4572 */ 4573 DATA = 12, 4574 4575 /** 4576 * A request from the publishers to the VMS service to get a Publisher ID for a serialized VMS 4577 * provider description packet as defined in the VMS protocol. 4578 * 4579 * This message type uses enum VmsBaseMessageIntegerValuesIndex. 4580 */ 4581 PUBLISHER_ID_REQUEST = 13, 4582 4583 /** 4584 * A response from the VMS service to the publisher that contains a provider description packet 4585 * and the publisher ID assigned to it. 4586 * 4587 * This message type uses enum VmsPublisherInformationIntegerValuesIndex. 4588 */ 4589 PUBLISHER_ID_RESPONSE = 14, 4590 4591 /** 4592 * A request from the subscribers to the VMS service to get information for a Publisher ID. 4593 * 4594 * This message type uses enum VmsPublisherInformationIntegerValuesIndex. 4595 */ 4596 PUBLISHER_INFORMATION_REQUEST = 15, 4597 4598 /** 4599 * A response from the VMS service to the subscribers that contains a provider description packet 4600 * and the publisher ID assigned to it. 4601 * 4602 * This message type uses enum VmsPublisherInformationIntegerValuesIndex. 4603 */ 4604 PUBLISHER_INFORMATION_RESPONSE = 16, 4605 4606 /** 4607 * A notification indicating that the sender has been reset. 4608 * 4609 * The receiving party must reset its internal state and respond to the 4610 * sender with a START_SESSION message as acknowledgement. 4611 * 4612 * This message type uses enum VmsStartSessionMessageIntegerValuesIndex. 4613 */ 4614 START_SESSION = 17, 4615 4616 LAST_VMS_MESSAGE_TYPE = START_SESSION, 4617}; 4618 4619/** 4620 * Every VMS message starts with the type of the message from the VmsMessageType enum. 4621 * Messages with no parameters such as VmsMessageType.AVAILABILITY_REQUEST, 4622 * VmsMessageType.SUBSCRIPTIONS_REQUEST and VmsMessageType.DATA are also based on this enum. 4623 */ 4624enum VmsBaseMessageIntegerValuesIndex : int32_t { 4625 /* The message type as enumerated by VmsMessageType enum. */ 4626 MESSAGE_TYPE = 0, 4627}; 4628 4629/* 4630 * Handshake data sent as part of a VmsMessageType.START_SESSION message. 4631 * 4632 * A new session is initiated by sending a START_SESSION message with the 4633 * sender's identifier populated and the receiver's identifier set to -1. 4634 * 4635 * Identifier values are independently generated, but must be non-negative, and 4636 * increase monotonically between reboots. 4637 * 4638 * Upon receiving a START_SESSION with a mis-matching identifier, the receiver 4639 * must clear any cached VMS offering or subscription state and acknowledge the 4640 * new session by responding with a START_SESSION message that populates both 4641 * identifier fields. 4642 * 4643 * Any VMS messages received between initiation and completion of the handshake 4644 * must be discarded. 4645 */ 4646enum VmsStartSessionMessageIntegerValuesIndex : VmsBaseMessageIntegerValuesIndex { 4647 /* Identifier field for the Android system service. */ 4648 SERVICE_ID = 1, 4649 /* Identifier field for the HAL client process. */ 4650 CLIENT_ID = 2, 4651}; 4652 4653/* 4654 * A VMS message with a layer is sent as part of a VmsMessageType.SUBSCRIBE or 4655 * VmsMessageType.UNSUBSCRIBE messages. 4656 * 4657 * The layer type is defined in the VMS protocol, and the subtype and version are 4658 * controlled by the implementer of the publisher. 4659 */ 4660enum VmsMessageWithLayerIntegerValuesIndex : VmsBaseMessageIntegerValuesIndex { 4661 LAYER_TYPE = 1, 4662 LAYER_SUBTYPE = 2, 4663 LAYER_VERSION = 3, 4664}; 4665 4666/* 4667 * A VMS message with a layer and publisher ID is sent as part of a 4668 * VmsMessageType.SUBSCRIBE_TO_PUBLISHER, VmsMessageType.UNSUBSCRIBE_TO_PUBLISHER messages and 4669 * VmsMessageType.DATA . 4670 */ 4671enum VmsMessageWithLayerAndPublisherIdIntegerValuesIndex : VmsMessageWithLayerIntegerValuesIndex { 4672 PUBLISHER_ID = 4, 4673}; 4674 4675/* 4676 * An offering can be sent by publishers as part of VmsMessageType.OFFERING in order to 4677 * advertise which layers they can publish and under which constraints: e.g., I can publish Layer X 4678 * if someone else will publish Layer Y. 4679 * The offering contains the publisher ID which was assigned to the publisher by the VMS service. 4680 * A single offering is represented as: 4681 * - Layer type 4682 * - Layer subtype 4683 * - Layer version 4684 * - Number of dependencies (N) 4685 * - N x (Layer type, Layer subtype, Layer version) 4686 */ 4687enum VmsOfferingMessageIntegerValuesIndex : VmsBaseMessageIntegerValuesIndex { 4688 PUBLISHER_ID = 1, 4689 NUMBER_OF_OFFERS = 2, 4690 OFFERING_START = 3, 4691}; 4692 4693/** 4694 * A subscriptions state is sent to the publishers in response to a change in the subscriptions 4695 * as part of a VmsMessageType.SUBSCRIPTIONS_CHANGE, or in response to a 4696 * VmsMessageType.SUBSCRIPTIONS_REQUEST message as part of VmsMessageType.SUBSCRIPTIONS_RESPONSE. 4697 * The VMS service issues monotonically increasing sequence numbers, and in case a subscriber receives 4698 * a smaller sequnce number it should ignore the message. 4699 * The subscriptions are sent as a list of layers followed by a list of associated layers: 4700 * {Sequence number, N, M, N x layer, M x associated layer} 4701 * A subscribed layer is represented as three integers: 4702 * - Layer type 4703 * - Layer subtype 4704 * - Layer version 4705 * A subscribed associated layer is a layer with a list of publisher IDs. It is represented as: 4706 * - Layer type 4707 * - Layer subtype 4708 * - Layer version 4709 * - Number of publisher IDs (N) 4710 * - N x publisher ID 4711 */ 4712enum VmsSubscriptionsStateIntegerValuesIndex : VmsBaseMessageIntegerValuesIndex { 4713 SEQUENCE_NUMBER = 1, 4714 NUMBER_OF_LAYERS = 2, 4715 NUMBER_OF_ASSOCIATED_LAYERS = 3, 4716 SUBSCRIPTIONS_START = 4, 4717}; 4718 4719/** 4720 * An availability state is sent to the subscribers in response to a change in the available 4721 * layers as part of a VmsMessageType.AVAILABILITY_CHANGE message, or in response to a 4722 * VmsMessageType.AVAILABILITY_REQUEST message as part of a VmsMessageType.AVAILABILITY_RESPONSE. 4723 * The VMS service issues monotonically increasing sequence numbers, and in case a subscriber receives 4724 * a smaller sequnce number, it should ignore the message. 4725 * An available associated layer is a layer with a list of publisher IDs: 4726 * - Layer type 4727 * - Layer subtype 4728 * - Layer version 4729 * - Number of publisher IDs (N) 4730 * - N x publisher ID 4731 */ 4732enum VmsAvailabilityStateIntegerValuesIndex : VmsBaseMessageIntegerValuesIndex { 4733 SEQUENCE_NUMBER = 1, 4734 NUMBER_OF_ASSOCIATED_LAYERS = 2, 4735 LAYERS_START = 3, 4736}; 4737 4738/* 4739 * Publishers send the VMS service their information and assigned in response a publisher ID. 4740 * Subscribers can request the publisher information for a publisher ID they received in other messages. 4741 */ 4742enum VmsPublisherInformationIntegerValuesIndex : VmsBaseMessageIntegerValuesIndex { 4743 PUBLISHER_ID = 1, 4744}; 4745 4746/** 4747 * Information about a specific Android user. 4748 */ 4749struct UserInfo { 4750 4751 UserId userId; 4752 4753 UserFlags flags; 4754}; 4755 4756/** 4757 * Id of an Android user. 4758 * 4759 * Must be > 0 for valid ids, or -10000 (which is the same as Android.UserHandle.USER_NULL) when 4760 * it's not used. 4761 */ 4762typedef int32_t UserId; 4763 4764/** 4765 * Flags used to define the characteristics of an Android user. 4766 */ 4767enum UserFlags: int32_t { 4768 /** 4769 * No flags. 4770 */ 4771 NONE = 0x0, 4772 4773 /** 4774 * System user. 4775 * On automotive, that user is always running, although never on foreground (except during 4776 * boot or exceptional circumstances). 4777 */ 4778 SYSTEM = 0x01, 4779 4780 /** 4781 * Guest users have restrictions. 4782 */ 4783 GUEST = 0x02, 4784 4785 /** 4786 * Ephemeral users have non-persistent state. 4787 */ 4788 EPHEMERAL = 0x04, 4789 4790 /** 4791 * Admin users have additional privileges such as permission to create other users. 4792 */ 4793 ADMIN = 0x08, 4794 4795 /** 4796 * Disabled users are marked for deletion. 4797 */ 4798 DISABLED = 0x10, 4799 4800 /** 4801 * Profile user is a profile of another user. 4802 */ 4803 PROFILE = 0x20, 4804}; 4805 4806/** 4807 * Information about all Android users. 4808 * 4809 * NOTE: this struct is not used in the HAL properties directly, it's part of other structs, which 4810 * in turn are converted to a VehiclePropValue.RawValue through libraries provided by the default 4811 * Vehicle HAL implementation. 4812 */ 4813struct UsersInfo { 4814 4815 /** The current foreground user. */ 4816 UserInfo currentUser; 4817 4818 /** 4819 * Number of existing users; includes the current user, recently removed users (with DISABLED 4820 * flag), and profile users (with PROFILE flag). 4821 */ 4822 int32_t numberUsers; 4823 4824 /** 4825 * List of existing users; includes the current user, recently removed users (with DISABLED 4826 * flag), and profile users (with PROFILE flag). 4827 */ 4828 vec<UserInfo> existingUsers; 4829 }; 4830 4831/** 4832 * Id of a request related to user management. 4833 * 4834 * This id can be used by the Android system to map responses sent by the HAL, and vice-versa. 4835 * 4836 * For requests originated by Android, the value is positive (> 0), while for requests originated by 4837 * the HAL it must be negative (< 0). 4838 */ 4839typedef int32_t UserRequestId; 4840 4841/** 4842 * Defines the format of a INITIAL_USER_INFO request made by the Android system. 4843 * 4844 * NOTE: this struct is not used in the HAL properties directly, it must be converted to 4845 * VehiclePropValue.RawValue through libraries provided by the default Vehicle HAL implementation. 4846 */ 4847struct InitialUserInfoRequest { 4848 /** 4849 * Arbitrary id used to map the HAL response to the request. 4850 */ 4851 UserRequestId requestId; 4852 4853 /** 4854 * Type of request. 4855 */ 4856 InitialUserInfoRequestType requestType; 4857 4858 /** 4859 * Information about the current state of the Android system. 4860 */ 4861 UsersInfo usersInfo; 4862}; 4863 4864/** 4865 * Defines when a INITIAL_USER_INFO request was made. 4866 */ 4867enum InitialUserInfoRequestType : int32_t { 4868 /** At the first time Android was booted (or after a factory reset). */ 4869 FIRST_BOOT = 1, 4870 4871 /** At the first time Android was booted after the system was updated. */ 4872 FIRST_BOOT_AFTER_OTA = 2, 4873 4874 /** When Android was booted "from scratch". */ 4875 COLD_BOOT = 3, 4876 4877 /** When Android was resumed after the system was suspended to memory. */ 4878 RESUME = 4, 4879}; 4880 4881/** 4882 * Defines the format of a HAL response to a INITIAL_USER_INFO request. 4883 * 4884 * NOTE: this struct is not used in the HAL properties directly, it must be converted to 4885 * VehiclePropValue.RawValue through libraries provided by the default Vehicle HAL implementation. 4886 */ 4887struct InitialUserInfoResponse { 4888 /** 4889 * Id of the request being responded. 4890 */ 4891 UserRequestId requestId; 4892 4893 /** 4894 * which action the Android system should take. 4895 */ 4896 InitialUserInfoResponseAction action; 4897 4898 /** 4899 * Information about the user that should be switched to or created. 4900 */ 4901 UserInfo userToSwitchOrCreate; 4902 4903 /** 4904 * System locales of the initial user (value will be passed as-is to 4905 * android.provider.Settings.System.SYSTEM_LOCALES) 4906 */ 4907 string userLocales; 4908 4909 /** 4910 * Name of the user that should be created. 4911 */ 4912 string userNameToCreate; 4913}; 4914 4915/** 4916 * Defines which action the Android system should take in an INITIAL_USER_INFO request. 4917 */ 4918enum InitialUserInfoResponseAction : int32_t { 4919 /** 4920 * Let the Android System decide what to do. 4921 * 4922 * For example, it might create a new user on first boot, and switch to the last 4923 * active user afterwards. 4924 */ 4925 DEFAULT = 0, 4926 4927 /** 4928 * Switch to an existing Android user. 4929 */ 4930 SWITCH = 1, 4931 4932 /** 4933 * Create a new Android user (and switch to it). 4934 */ 4935 CREATE = 2, 4936}; 4937 4938/** 4939 * Defines the format of a SWITCH_USER property. 4940 * 4941 * NOTE: this struct is not used in the HAL properties directly, it must be converted to 4942 * VehiclePropValue.RawValue through libraries provided by the default Vehicle HAL implementation. 4943 */ 4944struct SwitchUserRequest { 4945 /** 4946 * Arbitrary id used to map the response to the request. 4947 */ 4948 UserRequestId requestId; 4949 4950 /** 4951 * Type of message. 4952 */ 4953 SwitchUserMessageType messageType; 4954 4955 /** 4956 * Information about the Android user being switched to. 4957 * 4958 * Only the user id (but not the flags) should be set when the request is made by HAL. 4959 */ 4960 UserInfo targetUser; 4961 4962 /** 4963 * Information about the current state of the Android system. 4964 * 4965 * Should not be set when the request is made by HAL. 4966 */ 4967 UsersInfo usersInfo; 4968}; 4969 4970/** 4971 * Defines the reason a SWITCH_USER call was made. 4972 * 4973 * The meaning of each constant is explained in that property. 4974 */ 4975enum SwitchUserMessageType: int32_t { 4976 LEGACY_ANDROID_SWITCH = 1, 4977 ANDROID_SWITCH = 2, 4978 VEHICLE_RESPONSE = 3, 4979 VEHICLE_REQUEST = 4, 4980 ANDROID_POST_SWITCH = 5, 4981}; 4982 4983/** 4984 * Defines the result of a SwitchUserRequest. 4985 * 4986 * NOTE: this struct is not used in the HAL properties directly, it must be converted to 4987 * VehiclePropValue.RawValue through libraries provided by the default Vehicle HAL implementation. 4988 */ 4989struct SwitchUserResponse { 4990 /** 4991 * Id of the request being responded. 4992 */ 4993 UserRequestId requestId; 4994 4995 /** 4996 * Type of message. 4997 */ 4998 SwitchUserMessageType messageType; 4999 5000 /** 5001 * Status of the request. 5002 */ 5003 SwitchUserStatus status; 5004 5005 /** 5006 * HAL-specific error message. 5007 * 5008 * This argument is optional, and when defined, it's passed "as-is" to the caller. It could be 5009 * used to show custom error messages to the end user. 5010 */ 5011 string errorMessage; 5012}; 5013 5014/** 5015 * Status of the response to a SwitchUserRequest. 5016 */ 5017enum SwitchUserStatus : int32_t { 5018 /** The request succeeded and the HAL user was switched. */ 5019 SUCCESS = 1, 5020 /** The request failed and the HAL user remained the same. */ 5021 FAILURE = 2, 5022}; 5023 5024/** 5025 * Defines the format of a CREATE_USER property. 5026 * 5027 * NOTE: this struct is not used in the HAL properties directly, it must be converted to 5028 * VehiclePropValue.RawValue through libraries provided by the default Vehicle HAL implementation. 5029 */ 5030struct CreateUserRequest { 5031 /** 5032 * Arbitrary id used to map the response to the request. 5033 */ 5034 UserRequestId requestId; 5035 5036 /** 5037 * Basic information about Android user that was created. 5038 */ 5039 UserInfo newUserInfo; 5040 5041 /** 5042 * Name of the new Android user. 5043 */ 5044 string newUserName; 5045 5046 /** 5047 * Information about the current state of the Android system. 5048 */ 5049 UsersInfo usersInfo; 5050}; 5051 5052/** 5053 * Defines the result of a CreateUserRequest. 5054 * 5055 * NOTE: this struct is not used in the HAL properties directly, it must be converted to 5056 * VehiclePropValue.RawValue through libraries provided by the default Vehicle HAL implementation. 5057 */ 5058struct CreateUserResponse { 5059 /** 5060 * Id of the request being responded. 5061 */ 5062 UserRequestId requestId; 5063 5064 /** 5065 * Status of the request. 5066 */ 5067 CreateUserStatus status; 5068 5069 /** 5070 * HAL-specific error message. 5071 * 5072 * This argument is optional, and when defined, it's passed "as-is" to the caller. It could be 5073 * used to show custom error messages to the end user. 5074 */ 5075 string errorMessage; 5076}; 5077 5078/** 5079 * Status of the response to a CreateUserRequest. 5080 */ 5081enum CreateUserStatus : int32_t { 5082 /** 5083 * The request succeeded (for example, HAL created a new internal user, or associated the 5084 * Android user to an existing internal user). 5085 */ 5086 SUCCESS = 1, 5087 5088 /** 5089 * The request failed (and Android will remove the Android user). 5090 */ 5091 FAILURE = 2, 5092}; 5093 5094/** 5095 * Defines the format of a REMOVE_USER property. 5096 * 5097 * NOTE: this struct is not used in the HAL properties directly, it must be converted to 5098 * VehiclePropValue.RawValue through libraries provided by the default Vehicle HAL implementation. 5099 */ 5100struct RemoveUserRequest { 5101 /** 5102 * Arbitrary id used to map the response to the request. 5103 */ 5104 UserRequestId requestId; 5105 5106 /** 5107 * Information about the Android user that was removed. 5108 */ 5109 UserInfo removedUserInfo; 5110 5111 /** 5112 * Information about the current state of the Android system. 5113 */ 5114 UsersInfo usersInfo; 5115}; 5116 5117/** 5118 * Types of mechanisms used to identify an Android user. 5119 * 5120 * See USER_IDENTIFICATION_ASSOCIATION for more details and example. 5121 */ 5122enum UserIdentificationAssociationType: int32_t { 5123 /** Key used to unlock the car. */ 5124 KEY_FOB = 1, 5125 /** Custom mechanism defined by the OEM. */ 5126 CUSTOM_1 = 101, 5127 /** Custom mechanism defined by the OEM. */ 5128 CUSTOM_2 = 102, 5129 /** Custom mechanism defined by the OEM. */ 5130 CUSTOM_3 = 103, 5131 /** Custom mechanism defined by the OEM. */ 5132 CUSTOM_4 = 104, 5133}; 5134 5135/** 5136 * Whether a UserIdentificationAssociationType is associate with an Android user. 5137 */ 5138enum UserIdentificationAssociationValue : int32_t { 5139 /** 5140 * Used when the status of an association could not be determined. 5141 * 5142 * For example, in a set() request, it would indicate a failure to set the given type. 5143 */ 5144 UNKNOWN = 1, 5145 5146 /** 5147 * The identification type is associated with the current foreground Android user. 5148 */ 5149 ASSOCIATED_CURRENT_USER = 2, 5150 5151 /** 5152 * The identification type is associated with another Android user. 5153 */ 5154 ASSOCIATED_ANOTHER_USER = 3, 5155 5156 /** 5157 * The identification type is not associated with any Android user. 5158 */ 5159 NOT_ASSOCIATED_ANY_USER = 4, 5160}; 5161 5162/** 5163 * Used to set a UserIdentificationAssociationType with an Android user. 5164 */ 5165enum UserIdentificationAssociationSetValue : int32_t { 5166 /** 5167 * Associate the identification type with the current foreground Android user. 5168 */ 5169 ASSOCIATE_CURRENT_USER = 1, 5170 5171 /** 5172 * Disassociate the identification type from the current foreground Android user. 5173 */ 5174 DISASSOCIATE_CURRENT_USER = 2, 5175 5176 /** 5177 * Disassociate the identification type from all Android users. 5178 */ 5179 DISASSOCIATE_ALL_USERS = 3, 5180}; 5181 5182/** 5183 * Defines the format of a get() call to USER_IDENTIFICATION_ASSOCIATION. 5184 * 5185 * NOTE: this struct is not used in the HAL properties directly, it must be converted to 5186 * VehiclePropValue.RawValue through libraries provided by the default Vehicle HAL implementation. 5187 */ 5188struct UserIdentificationGetRequest { 5189 /** 5190 * Id of the request being responded. 5191 */ 5192 UserRequestId requestId; 5193 5194 /** 5195 * Information about the current foreground Android user. 5196 */ 5197 UserInfo userInfo; 5198 5199 /** 5200 * Number of association being queried. 5201 */ 5202 int32_t numberAssociationTypes; 5203 5204 /** 5205 * Types of association being queried. 5206 */ 5207 vec<UserIdentificationAssociationType> associationTypes; 5208}; 5209 5210/** 5211 * Defines the format of a set() call to USER_IDENTIFICATION_ASSOCIATION. 5212 * 5213 * NOTE: this struct is not used in the HAL properties directly, it must be converted to 5214 * VehiclePropValue.RawValue through libraries provided by the default Vehicle HAL implementation. 5215 */ 5216struct UserIdentificationSetRequest { 5217 /** 5218 * Id of the request being responded. 5219 */ 5220 UserRequestId requestId; 5221 5222 /** 5223 * Information about the current foreground Android user. 5224 */ 5225 UserInfo userInfo; 5226 5227 /** 5228 * Number of association being set. 5229 */ 5230 int32_t numberAssociations; 5231 5232 /** 5233 * Associations being set. 5234 */ 5235 vec<UserIdentificationSetAssociation> associations; 5236}; 5237 5238/** 5239 * Defines the result of a USER_IDENTIFICATION_ASSOCIATION - both for get() and set(). 5240 * 5241 * NOTE: this struct is not used in the HAL properties directly, it must be converted to 5242 * VehiclePropValue.RawValue through libraries provided by the default Vehicle HAL implementation. 5243 */ 5244struct UserIdentificationResponse { 5245 /** 5246 * Id of the request being responded. 5247 */ 5248 UserRequestId requestId; 5249 5250 /** 5251 * Number of associations being returned. 5252 */ 5253 int32_t numberAssociation; 5254 5255 /** 5256 * Values associated with the user. 5257 */ 5258 vec<UserIdentificationAssociation> associations; 5259 5260 /** 5261 * HAL-specific error message. 5262 * 5263 * This argument is optional, and when defined, it's passed "as-is" to the caller. It could be 5264 * used to show custom error messages to the end user. 5265 */ 5266 string errorMessage; 5267}; 5268 5269/** 5270 * Helper struct used when getting a user/identification association type. 5271 */ 5272struct UserIdentificationAssociation { 5273 5274 UserIdentificationAssociationType type; 5275 5276 UserIdentificationAssociationValue value; 5277}; 5278 5279/** 5280 * Helper struct used when setting a user/identification association type. 5281 */ 5282struct UserIdentificationSetAssociation { 5283 5284 UserIdentificationAssociationType type; 5285 5286 UserIdentificationAssociationSetValue value; 5287}; 5288 5289/** 5290 * A rotary control which can rotate without limits. These controls use HW_ROTARY_INPUT to report 5291 * relative clockwise or counterclockwise motion. They have no absolute position. 5292 */ 5293enum RotaryInputType : int32_t { 5294 /** 5295 * Main rotary control, typically in the center console, used to navigate the user interface. 5296 */ 5297 ROTARY_INPUT_TYPE_SYSTEM_NAVIGATION = 0, 5298 5299 /** Volume control for adjusting audio volume. */ 5300 ROTARY_INPUT_TYPE_AUDIO_VOLUME = 1, 5301}; 5302 5303/** 5304 * The reason why a process is terminated by car watchdog. 5305 * This is used with WATCHDOG_TERMINATED_PROCESS property. 5306 */ 5307enum ProcessTerminationReason : int32_t { 5308 /** 5309 * A process doesn't respond to car watchdog within the timeout. 5310 */ 5311 NOT_RESPONDING = 1, 5312 5313 /** 5314 * A process uses more IO operations than what is allowed. 5315 */ 5316 IO_OVERUSE = 2, 5317 5318 /** 5319 * A process uses more memory space than what is allowed. 5320 */ 5321 MEMORY_OVERUSE = 3, 5322}; 5323 5324/** 5325 * Input code values for HW_CUSTOM_INPUT. 5326 */ 5327enum CustomInputType : int32_t { 5328 /** 5329 * Ten functions representing the custom input code to be defined and implemented by OEM 5330 * partners. 5331 * 5332 * OEMs need to formally contact Android team if more than 10 functions are required. 5333 */ 5334 CUSTOM_EVENT_F1 = 1001, 5335 CUSTOM_EVENT_F2 = 1002, 5336 CUSTOM_EVENT_F3 = 1003, 5337 CUSTOM_EVENT_F4 = 1004, 5338 CUSTOM_EVENT_F5 = 1005, 5339 CUSTOM_EVENT_F6 = 1006, 5340 CUSTOM_EVENT_F7 = 1007, 5341 CUSTOM_EVENT_F8 = 1008, 5342 CUSTOM_EVENT_F9 = 1009, 5343 CUSTOM_EVENT_F10 = 1010, 5344}; 5345 5346