1 /* 2 * Copyright (C) 2018 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.car; 18 19 import static android.car.feature.Flags.FLAG_ANDROID_B_VEHICLE_PROPERTIES; 20 import static android.car.feature.Flags.FLAG_ANDROID_VIC_VEHICLE_PROPERTIES; 21 import static android.car.feature.Flags.FLAG_VEHICLE_PROPERTY_25Q2_3P_PERMISSIONS; 22 import static android.car.feature.Flags.FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS; 23 import static android.Manifest.permission.ACCESS_FINE_LOCATION; 24 25 import static com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport.BOILERPLATE_CODE; 26 import static com.android.car.internal.property.VehiclePropertyIdDebugUtils.isDefined; 27 import static com.android.car.internal.property.VehiclePropertyIdDebugUtils.toName; 28 29 import android.annotation.FlaggedApi; 30 import android.annotation.RequiresPermission; 31 import android.car.hardware.CarHvacFanDirection; 32 import android.car.hardware.CarPropertyConfig; 33 import android.car.hardware.CarPropertyValue; 34 import android.car.hardware.property.AutomaticEmergencyBrakingState; 35 import android.car.hardware.property.BlindSpotWarningState; 36 import android.car.hardware.property.CruiseControlCommand; 37 import android.car.hardware.property.CruiseControlState; 38 import android.car.hardware.property.CruiseControlType; 39 import android.car.hardware.property.DriverDistractionState; 40 import android.car.hardware.property.DriverDistractionWarning; 41 import android.car.hardware.property.DriverDrowsinessAttentionState; 42 import android.car.hardware.property.DriverDrowsinessAttentionWarning; 43 import android.car.hardware.property.EmergencyLaneKeepAssistState; 44 import android.car.hardware.property.ErrorState; 45 import android.car.hardware.property.EvChargeState; 46 import android.car.hardware.property.EvChargingConnectorType; 47 import android.car.hardware.property.EvRegenerativeBrakingState; 48 import android.car.hardware.property.EvStoppingMode; 49 import android.car.hardware.property.ForwardCollisionWarningState; 50 import android.car.hardware.property.HandsOnDetectionDriverState; 51 import android.car.hardware.property.HandsOnDetectionWarning; 52 import android.car.hardware.property.LaneCenteringAssistCommand; 53 import android.car.hardware.property.LaneCenteringAssistState; 54 import android.car.hardware.property.LaneDepartureWarningState; 55 import android.car.hardware.property.LaneKeepAssistState; 56 import android.car.hardware.property.LocationCharacterization; 57 import android.car.hardware.property.TrailerState; 58 import android.car.hardware.property.VehicleElectronicTollCollectionCardStatus; 59 import android.car.hardware.property.VehicleElectronicTollCollectionCardType; 60 import android.car.hardware.property.VehicleLightState; 61 import android.car.hardware.property.VehicleLightSwitch; 62 import android.car.hardware.property.VehicleOilLevel; 63 import android.car.hardware.property.VehicleTurnSignal; 64 import android.car.hardware.property.WindshieldWipersState; 65 import android.car.hardware.property.WindshieldWipersSwitch; 66 67 import com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport; 68 69 /** 70 * List of vehicle property IDs. 71 * 72 * <p> Property IDs are used with the {@link android.car.hardware.property.CarPropertyManager} APIs 73 * (e.g. {@link android.car.hardware.property.CarPropertyManager#getProperty(int, int)} or {@link 74 * android.car.hardware.property.CarPropertyManager#setProperty(Class, int, int, Object)}). 75 */ 76 public final class VehiclePropertyIds { 77 78 /** 79 * Undefined property. 80 * 81 * <p>This property should never be used/will never be supported. 82 */ 83 public static final int INVALID = 0; 84 /** 85 * VIN of vehicle 86 * 87 * <p>Property Config: 88 * <ul> 89 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 90 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 91 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 92 * <li>{@code String} property type 93 * </ul> 94 * 95 * <p>Required Permission: 96 * <ul> 97 * <li>Signature|Privileged permission {@link Car#PERMISSION_IDENTIFICATION} to read 98 * property. 99 * <li>Property is not writable. 100 * </ul> 101 */ 102 @RequiresPermission(Car.PERMISSION_IDENTIFICATION) 103 public static final int INFO_VIN = 286261504; 104 /** 105 * Manufacturer of vehicle. 106 * 107 * <p>This property communicates the vehicle's public brand name. 108 * 109 * <p>Property Config: 110 * <ul> 111 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 112 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 113 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 114 * <li>{@code String} property type 115 * </ul> 116 * 117 * <p>Required Permission: 118 * <ul> 119 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 120 * <li>Property is not writable. 121 * </ul> 122 */ 123 @RequiresPermission(Car.PERMISSION_CAR_INFO) 124 public static final int INFO_MAKE = 286261505; 125 /** 126 * Model of vehicle. 127 * 128 * <p>This property communicates the vehicle's public model name. 129 * 130 * <p>Property Config: 131 * <ul> 132 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 133 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 134 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 135 * <li>{@code String} property type 136 * </ul> 137 * 138 * <p>Required Permission: 139 * <ul> 140 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 141 * <li>Property is not writable. 142 * </ul> 143 */ 144 @RequiresPermission(Car.PERMISSION_CAR_INFO) 145 public static final int INFO_MODEL = 286261506; 146 /** 147 * Model year of vehicle in YYYY format based on Gregorian calendar. 148 * 149 * <p>Property Config: 150 * <ul> 151 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 152 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 153 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 154 * <li>{@code Integer} property type 155 * </ul> 156 * 157 * <p>Required Permission: 158 * <ul> 159 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 160 * <li>Property is not writable. 161 * </ul> 162 */ 163 @RequiresPermission(Car.PERMISSION_CAR_INFO) 164 public static final int INFO_MODEL_YEAR = 289407235; 165 /** 166 * Fuel capacity of the vehicle in milliliters. 167 * 168 * <p>This property communicates the maximum amount of the fuel that can be stored in the 169 * vehicle in milliliters. This property will not be implemented for electric vehicles. That is, 170 * if {@link #INFO_FUEL_TYPE} only contains {@link FuelType#ELECTRIC}, this property will not be 171 * implemented. For EVs, see {@link #INFO_EV_BATTERY_CAPACITY}. 172 * 173 * <p>Property Config: 174 * <ul> 175 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 176 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 177 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 178 * <li>{@code Float} property type 179 * </ul> 180 * 181 * <p>Required Permission: 182 * <ul> 183 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 184 * <li>Property is not writable. 185 * </ul> 186 */ 187 @RequiresPermission(Car.PERMISSION_CAR_INFO) 188 public static final int INFO_FUEL_CAPACITY = 291504388; 189 /** 190 * List the {@link FuelType}s the vehicle may use. 191 * 192 * <p>{@link FuelType#ELECTRIC} will only be included if the vehicle is plug in rechargeable. 193 * Note that for this reason, even though {@link FuelType#ELECTRIC} is not listed as a fuel 194 * type, other EV properties such as {@link #INFO_EV_BATTERY_CAPACITY} can still be supported on 195 * the vehicle. 196 * 197 * <p>For example: 198 * <ul> 199 * <li>FHEVs (Fully Hybrid Electric Vehicles) will not include {@link FuelType#ELECTRIC} in its 200 * {@code Integer[]} value. So {@code INFO_FUEL_TYPE} will be populated as such: 201 * { {@link FuelType#UNLEADED} }. 202 * <li>On the other hand, PHEVs (Plug-in Hybrid Electric Vehicles) are plug in rechargeable, 203 * and hence will include {@link FuelType#ELECTRIC} in {@code INFO_FUEL_TYPE}'s {@code 204 * Integer[]} value. So {@code INFO_FUEL_TYPE} will be populated as such: 205 * { {@link FuelType#UNLEADED}, {@link FuelType#ELECTRIC} }. 206 * </ul> 207 * 208 * <p>Property Config: 209 * <ul> 210 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 211 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 212 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 213 * <li>{@code Integer[]} property type 214 * </ul> 215 * 216 * <p>Required Permission: 217 * <ul> 218 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 219 * <li>Property is not writable. 220 * </ul> 221 * 222 * @data_enum {@link FuelType} 223 */ 224 @RequiresPermission(Car.PERMISSION_CAR_INFO) 225 public static final int INFO_FUEL_TYPE = 289472773; 226 /** 227 * Nominal usable battery capacity for EV or hybrid vehicle. 228 * 229 * <p>Returns the nominal battery capacity in {@link android.car.VehicleUnit#WATT_HOUR}, if EV 230 * or hybrid. This is the usable battery capacity when the vehicle is new. This value might be 231 * different from {@link #EV_CURRENT_BATTERY_CAPACITY} because {@link 232 * #EV_CURRENT_BATTERY_CAPACITY} returns the real-time usable battery capacity taking into 233 * account factors such as battery aging and temperature dependency. 234 * 235 * <p>Property Config: 236 * <ul> 237 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 238 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 239 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 240 * <li>{@code Float} property type 241 * </ul> 242 * 243 * <p>Required Permission: 244 * <ul> 245 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 246 * <li>Property is not writable. 247 * </ul> 248 */ 249 @RequiresPermission(Car.PERMISSION_CAR_INFO) 250 public static final int INFO_EV_BATTERY_CAPACITY = 291504390; 251 /** 252 * List of {@link android.car.hardware.property.EvChargingConnectorType}s this vehicle may use. 253 * 254 * <p>If the vehicle has multiple charging ports, this property will return all possible 255 * connector types that can be used by at least one charging port on the vehicle. 256 * 257 * <p>Property Config: 258 * <ul> 259 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 260 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 261 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 262 * <li>{@code Integer[]} property type 263 * </ul> 264 * 265 * <p>Required Permission: 266 * <ul> 267 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 268 * <li>Property is not writable. 269 * </ul> 270 * 271 * @data_enum {@link EvChargingConnectorType} 272 */ 273 @RequiresPermission(Car.PERMISSION_CAR_INFO) 274 public static final int INFO_EV_CONNECTOR_TYPE = 289472775; 275 /** 276 * {@link PortLocationType} for the fuel door location. 277 * 278 * <p>This property communicates the location of the fuel door on the vehicle. This property 279 * will not be implemented for electric vehicles. That is, if {@link #INFO_FUEL_TYPE} only 280 * contains {@link FuelType#ELECTRIC}, this property will not be implemented. For EVs, see 281 * {@link #INFO_EV_PORT_LOCATION} or {@link #INFO_MULTI_EV_PORT_LOCATIONS}. 282 * 283 * <p>Property Config: 284 * <ul> 285 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 286 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 287 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 288 * <li>{@code Integer} property type 289 * </ul> 290 * 291 * <p>Required Permission: 292 * <ul> 293 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 294 * <li>Property is not writable. 295 * </ul> 296 * 297 * @data_enum {@link PortLocationType} 298 */ 299 @RequiresPermission(Car.PERMISSION_CAR_INFO) 300 public static final int INFO_FUEL_DOOR_LOCATION = 289407240; 301 /** 302 * {@link PortLocationType} for the EV port location. 303 * 304 * <p>This property communicates the location of the charging port on the EV. If there are 305 * multiple ports on the vehicle, this will communicate the port that enables the fastest 306 * charging on the vehicle. See {@link #INFO_MULTI_EV_PORT_LOCATIONS} to get information on all 307 * port locations. 308 * 309 * <p>Property Config: 310 * <ul> 311 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 312 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 313 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 314 * <li>{@code Integer} property type 315 * </ul> 316 * 317 * <p>Required Permission: 318 * <ul> 319 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 320 * <li>Property is not writable. 321 * </ul> 322 * 323 * @data_enum {@link PortLocationType} 324 */ 325 @RequiresPermission(Car.PERMISSION_CAR_INFO) 326 public static final int INFO_EV_PORT_LOCATION = 289407241; 327 /** 328 * List {@link PortLocationType}s for Multiple EV port locations. 329 * 330 * <p>Property Config: 331 * <ul> 332 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 333 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 334 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 335 * <li>{@code Integer[]} property type 336 * </ul> 337 * 338 * <p>Required Permission: 339 * <ul> 340 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 341 * <li>Property is not writable. 342 * </ul> 343 * 344 * @data_enum {@link PortLocationType} 345 */ 346 @RequiresPermission(Car.PERMISSION_CAR_INFO) 347 public static final int INFO_MULTI_EV_PORT_LOCATIONS = 289472780; 348 /** 349 * Driver's seat location. 350 * 351 * <p>The only area ID listed in {@link android.car.hardware.CarPropertyConfig#getAreaIds} for 352 * {@code INFO_DRIVER_SEAT} will be {@code 0}. 353 * 354 * <p>Property Config: 355 * <ul> 356 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 357 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 358 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 359 * <li>{@code Integer} property type 360 * </ul> 361 * 362 * <p>Required Permission: 363 * <ul> 364 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 365 * <li>Property is not writable. 366 * </ul> 367 * 368 * @data_enum {@link VehicleAreaSeat} 369 */ 370 @RequiresPermission(Car.PERMISSION_CAR_INFO) 371 public static final int INFO_DRIVER_SEAT = 356516106; 372 /** 373 * Vehicle's exterior dimensions in millimeters. 374 * 375 * <p>Exterior dimensions defined in the {@link CarPropertyValue#getValue()} {@code Integer[]}: 376 * <ul> 377 * <li>Integer[0] = height 378 * <li>Integer[1] = length 379 * <li>Integer[2] = width 380 * <li>Integer[3] = width including mirrors 381 * <li>Integer[4] = wheel base 382 * <li>Integer[5] = track width front 383 * <li>Integer[6] = track width rear 384 * <li>Integer[7] = curb to curb turning diameter 385 * </ul> 386 * 387 * <p>Property Config: 388 * <ul> 389 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 390 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 391 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 392 * <li>{@code Integer[]} property type 393 * </ul> 394 * 395 * <p>Required Permission: 396 * <ul> 397 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 398 * <li>Property is not writable. 399 * </ul> 400 */ 401 @RequiresPermission(Car.PERMISSION_CAR_INFO) 402 public static final int INFO_EXTERIOR_DIMENSIONS = 289472779; 403 /** 404 * Public trim name of the vehicle. 405 * 406 * <p>This property communicates the vehicle's public trim name. 407 * 408 * <p>For example, say an OEM manufactures two different versions of a vehicle model: 409 * <ul> 410 * <li>"makeName modelName" and 411 * <li>"makeName modelName Sport" 412 * </ul> 413 * <p>This property will be empty for the first vehicle (i.e. base model), and set to "Sport" 414 * for the second vehicle. 415 * 416 * <p>Property Config: 417 * <ul> 418 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 419 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 420 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 421 * <li>{@code String} property type 422 * </ul> 423 * 424 * <p>Required Permission: 425 * <ul> 426 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 427 * <li>Property is not writable. 428 * </ul> 429 */ 430 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 431 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_CAR_INFO)) 432 public static final int INFO_MODEL_TRIM = 286261517; 433 /** 434 * Vehicle Size Class. 435 * 436 * <p>This property communicates the list of size classifications that the vehicle follows 437 * according to the multiple standards that are defined in {@link 438 * android.car.hardware.property.VehicleSizeClass} 439 * 440 * <p>For example, suppose a vehicle model follows the {@link 441 * android.car.hardware.property.VehicleSizeClass#EU_A_SEGMENT} standard in the EU and the 442 * {@link android.car.hardware.property.VehicleSizeClass#JPN_KEI} standard in Japan. In this 443 * scenario this property must return an intArray = [{@link 444 * android.car.hardware.property.VehicleSizeClass#EU_A_SEGMENT}, {@link 445 * android.car.hardware.property.VehicleSizeClass#JPN_KEI}]. If this vehicle only follows 446 * the EU {@link android.car.hardware.property.VehicleSizeClass#EU_A_SEGMENT} standard, then we 447 * expect intArray = [{@link android.car.hardware.property.VehicleSizeClass#EU_A_SEGMENT}]. 448 * 449 * <p>Property Config: 450 * <ul> 451 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 452 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 453 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 454 * <li>{@code Integer[]} property type 455 * </ul> 456 * 457 * <p>Required Permission: 458 * <ul> 459 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 460 * <li>Property is not writable. 461 * </ul> 462 * 463 * @data_enum {@link android.car.hardware.property.VehicleSizeClass} 464 */ 465 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 466 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_CAR_INFO)) 467 public static final int INFO_VEHICLE_SIZE_CLASS = 289472782; 468 /** 469 * Current odometer value of the vehicle in kilometers. 470 * 471 * <p>Property Config: 472 * <ul> 473 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 474 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 475 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 476 * <li>{@code Float} property type 477 * </ul> 478 * 479 * <p>Required Permission: 480 * <ul> 481 * <li>Dangerous permission {@link Car#PERMISSION_MILEAGE_3P} or Signature|Privileged 482 * permission {@link Car#PERMISSION_MILEAGE} to read property. 483 * <li>Property is not writable. 484 * </ul> 485 */ 486 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 487 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_MILEAGE_3P, 488 Car.PERMISSION_MILEAGE})) 489 public static final int PERF_ODOMETER = 291504644; 490 /** 491 * Speed of the vehicle in meters per second. 492 * 493 * <p>When the vehicle is moving forward, {@code PERF_VEHICLE_SPEED} is positive and negative 494 * when the vehicle is moving backward. Also, this value is independent of gear value ({@link 495 * #CURRENT_GEAR} or {@link #GEAR_SELECTION}). For example, if {@link #GEAR_SELECTION} is 496 * {@link VehicleGear#GEAR_NEUTRAL}, {@code PERF_VEHICLE_SPEED} is positive when the vehicle is 497 * moving forward, negative when moving backward, and zero when not moving. 498 * 499 * <p>Property Config: 500 * <ul> 501 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 502 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 503 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 504 * <li>{@code Float} property type 505 * </ul> 506 * 507 * <p>Required Permission: 508 * <ul> 509 * <li>Dangerous permission {@link Car#PERMISSION_SPEED} to read property. 510 * <li>Property is not writable. 511 * </ul> 512 */ 513 @RequiresPermission(Car.PERMISSION_SPEED) 514 public static final int PERF_VEHICLE_SPEED = 291504647; 515 /** 516 * Speed of the vehicle in meters per second for displays. 517 * 518 * <p>Some cars display a slightly slower speed than the actual speed. This is 519 * usually displayed on the speedometer. 520 * 521 * <p>Property Config: 522 * <ul> 523 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 524 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 525 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 526 * <li>{@code Float} property type 527 * </ul> 528 * 529 * <p>Required Permission: 530 * <ul> 531 * <li>Dangerous permission {@link Car#PERMISSION_SPEED} to read property. 532 * <li>Property is not writable. 533 * </ul> 534 */ 535 @RequiresPermission(Car.PERMISSION_SPEED) 536 public static final int PERF_VEHICLE_SPEED_DISPLAY = 291504648; 537 /** 538 * Front bicycle model steering angle for vehicle in degrees. 539 * 540 * <p>Left is negative. 541 * 542 * <p>This property is independent of the angle of the steering wheel. This property 543 * communicates the angle of the front wheels with respect to the vehicle, not the angle of the 544 * steering wheel. 545 * 546 * <p>Property Config: 547 * <ul> 548 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 549 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 550 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 551 * <li>{@code Float} property type 552 * </ul> 553 * 554 * <p>Required Permission: 555 * <ul> 556 * <li>Dangerous permission {@link Car#PERMISSION_READ_STEERING_STATE_3P} or 557 * Signature|Privileged permission {@link Car#PERMISSION_READ_STEERING_STATE} to read property. 558 * <li>Property is not writable. 559 * </ul> 560 */ 561 @FlaggedApi(FLAG_VEHICLE_PROPERTY_25Q2_3P_PERMISSIONS) 562 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_STEERING_STATE_3P, 563 Car.PERMISSION_READ_STEERING_STATE})) 564 public static final int PERF_STEERING_ANGLE = 291504649; 565 /** 566 * Rear bicycle model steering angle for vehicle in degrees. 567 * 568 * <p>Left is negative. 569 * 570 * <p>This property is independent of the angle of the steering wheel. This property 571 * communicates the angle of the rear wheels with respect to the vehicle, not the angle of the 572 * steering wheel. 573 * 574 * <p>Property Config: 575 * <ul> 576 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 577 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 578 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 579 * <li>{@code Float} property type 580 * </ul> 581 * 582 * <p>Required Permission: 583 * <ul> 584 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_STEERING_STATE} to read 585 * property. 586 * <li>Property is not writable. 587 * </ul> 588 */ 589 @RequiresPermission(Car.PERMISSION_READ_STEERING_STATE) 590 public static final int PERF_REAR_STEERING_ANGLE = 291504656; 591 /** 592 * Instantaneous Fuel Economy in L/100km. 593 * 594 * <p>This property communicates the instantaneous fuel economy of the vehicle in units of 595 * L/100km. Clients can reference the value of {@link #DISTANCE_DISPLAY_UNITS}, {@link 596 * #FUEL_VOLUME_DISPLAY_UNITS}, and {@link #FUEL_CONSUMPTION_UNITS_DISTANCE_OVER_VOLUME} before 597 * displaying this property to the user to match the display units used by rest of the system. 598 * 599 * <p>For the EV version of this property, see {@link #INSTANTANEOUS_EV_EFFICIENCY}. 600 * 601 * <p>Property Config: 602 * <ul> 603 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 604 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 605 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 606 * <li>{@code Float} property type 607 * </ul> 608 * 609 * <p>Required Permission: 610 * <ul> 611 * <li>Dangerous permission {@link Car#PERMISSION_MILEAGE_3P} to read 612 property. 613 * <li>Property is not writable. 614 * </ul> 615 */ 616 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 617 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_MILEAGE_3P)) 618 public static final int INSTANTANEOUS_FUEL_ECONOMY = 291504657; 619 /** 620 * Instantaneous EV efficiency in km/kWh. 621 * 622 * <p>This property communicates the instantaneous EV battery efficiency of the vehicle in units 623 * of km/kWh. Clients can reference the value of {@link #DISTANCE_DISPLAY_UNITS} and {@link 624 * #EV_BATTERY_DISPLAY_UNITS} before displaying this property to the user to match the display 625 * units used by rest of the system. 626 * 627 * <p>For the fuel version of this property, see {@link 628 * #INSTANTANEOUS_FUEL_ECONOMY}. 629 * 630 * <p>Property Config: 631 * <ul> 632 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 633 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 634 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 635 * <li>{@code Float} property type 636 * </ul> 637 * 638 * <p>Required Permission: 639 * <ul> 640 * <li>Dangerous permission {@link Car#PERMISSION_MILEAGE_3P} to read 641 property. 642 * <li>Property is not writable. 643 * </ul> 644 */ 645 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 646 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_MILEAGE_3P)) 647 public static final int INSTANTANEOUS_EV_EFFICIENCY = 291504658; 648 /** 649 * Temperature of engine coolant in celsius. 650 * 651 * <p>Property Config: 652 * <ul> 653 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 654 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 655 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 656 * <li>{@code Float} property type 657 * </ul> 658 * 659 * <p>Required Permission: 660 * <ul> 661 * <li>Signature|Privileged permission {@link Car#PERMISSION_CAR_ENGINE_DETAILED} to read 662 * property. 663 * <li>Property is not writable. 664 * </ul> 665 */ 666 @RequiresPermission(Car.PERMISSION_CAR_ENGINE_DETAILED) 667 public static final int ENGINE_COOLANT_TEMP = 291504897; 668 /** 669 * Engine oil level. 670 * 671 * <p>Returns the status of the oil level for the vehicle. See {@code VehicleOilLevel} for 672 * possible values for {@code ENGINE_OIL_LEVEL}. 673 * 674 * <p>Property Config: 675 * <ul> 676 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 677 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 678 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 679 * <li>{@code Integer} property type 680 * </ul> 681 * 682 * <p>Required Permission: 683 * <ul> 684 * <li>Signature|Privileged permission {@link Car#PERMISSION_CAR_ENGINE_DETAILED} to read 685 * property. 686 * <li>Property is not writable. 687 * </ul> 688 * 689 * @data_enum {@link VehicleOilLevel} 690 */ 691 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_CAR_ENGINE_DETAILED)) 692 public static final int ENGINE_OIL_LEVEL = 289407747; 693 /** 694 * Temperature of engine oil in celsius. 695 * 696 * <p>Property Config: 697 * <ul> 698 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 699 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 700 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 701 * <li>{@code Float} property type 702 * </ul> 703 * 704 * <p>Required Permission: 705 * <ul> 706 * <li>Signature|Privileged permission {@link Car#PERMISSION_CAR_ENGINE_DETAILED} to read 707 * property. 708 * <li>Property is not writable. 709 * </ul> 710 */ 711 @RequiresPermission(Car.PERMISSION_CAR_ENGINE_DETAILED) 712 public static final int ENGINE_OIL_TEMP = 291504900; 713 /** 714 * Engine rpm. 715 * 716 * <p>Property Config: 717 * <ul> 718 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 719 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 720 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 721 * <li>{@code Float} property type 722 * </ul> 723 * 724 * <p>Required Permission: 725 * <ul> 726 * <li>Dangerous permission {@link Car#PERMISSION_CAR_ENGINE_DETAILED_3P} or 727 * Signature|Privileged permission {@link Car#PERMISSION_CAR_ENGINE_DETAILED} to read property. 728 * <li>Property is not writable. 729 * </ul> 730 */ 731 @FlaggedApi(FLAG_VEHICLE_PROPERTY_25Q2_3P_PERMISSIONS) 732 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_CAR_ENGINE_DETAILED_3P, 733 Car.PERMISSION_CAR_ENGINE_DETAILED})) 734 public static final int ENGINE_RPM = 291504901; 735 /** 736 * Represents feature for engine idle automatic stop. 737 * 738 * <p>If true, the vehicle may automatically shut off the engine when it is not needed and then 739 * automatically restart it when needed. 740 * 741 * <p>Property Config: 742 * <ul> 743 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 744 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 745 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 746 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 747 * <li>{@code Boolean} property type 748 * </ul> 749 * 750 * <p>Required Permission: 751 * <ul> 752 * <li>Signature|Privileged permission {@link Car#PERMISSION_CAR_ENGINE_DETAILED} to read and 753 * write property. 754 * </ul> 755 */ 756 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 757 @RequiresPermission(Car.PERMISSION_CAR_ENGINE_DETAILED) 758 public static final int ENGINE_IDLE_AUTO_STOP_ENABLED = 287310624; 759 /** 760 * Impact detected. 761 * 762 * <p>Bit flag property to relay information on whether an impact has occurred on a particular 763 * side of the vehicle as described through the {@link 764 * android.car.hardware.property.ImpactSensorLocation} enum. As a bit flag property, this 765 * property can be set to multiple ORed together values of the enum when necessary. 766 * 767 * <p>For the global area ID (0), the {@link 768 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 769 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which bit flags 770 * from {@link android.car.hardware.property.ImpactSensorLocation} are supported. 771 * 772 * <p>Property Config: 773 * <ul> 774 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 775 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 776 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 777 * <li>{@code Integer} property type 778 * </ul> 779 * 780 * <p>Required Permission: 781 * <ul> 782 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_IMPACT_SENSORS} to read 783 * property. 784 * <li>Property is not writable. 785 * </ul> 786 * 787 * @data_enum {@link android.car.hardware.property.ImpactSensorLocation} 788 * 789 */ 790 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 791 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_IMPACT_SENSORS)) 792 public static final int IMPACT_DETECTED = 289407792; 793 /** 794 * Vehicle horn engaged. 795 * 796 * <p>This property communicates if the vehicle's horn is currently engaged or not. If true, the 797 * horn is engaged. If false, the horn is disengaged. 798 * 799 * <p>Property Config: 800 * <ul> 801 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 802 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 803 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 804 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 805 * <li>{@code Boolean} property type 806 * </ul> 807 * 808 * <p>Required Permissions: 809 * <ul> 810 * <li>Dangerous permission {@link Car#PERMISSION_READ_CAR_HORN} or Signature|Privileged 811 * permission {@link Car#PERMISSION_CONTROL_CAR_HORN} to read property. 812 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_HORN} to write 813 * property. 814 * </ul> 815 */ 816 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 817 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_CAR_HORN, 818 Car.PERMISSION_CONTROL_CAR_HORN})) 819 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_CAR_HORN)) 820 public static final int VEHICLE_HORN_ENGAGED = 287310656; 821 /** 822 * Reports wheel ticks. 823 * 824 * <p>The first element in the array is a reset count. A reset indicates 825 * previous tick counts are not comparable with this and future ones. Some 826 * sort of discontinuity in tick counting has occurred. 827 * 828 * <p>The next four elements represent ticks for individual wheels in the 829 * following order: front left, front right, rear right, rear left. All 830 * tick counts are cumulative. Tick counts increment when the vehicle 831 * moves forward, and decrement when vehicles moves in reverse. The ticks 832 * should be reset to 0 when the vehicle is started by the user. 833 * 834 * <ul> 835 * <li>Long[0] = reset count 836 * <li>Long[1] = front left ticks 837 * <li>Long[2] = front right ticks 838 * <li>Long[3] = rear right ticks 839 * <li>Long[4] = rear left ticks 840 * </ul> 841 * 842 * <p>configArray is used to indicate the micrometers-per-wheel-tick values and 843 * which wheels are supported. Each micrometers-per-wheel-tick value is static (i.e. will not 844 * update based on wheel's status) and a best approximation. For example, if a vehicle has 845 * multiple rim/tire size options, the micrometers-per-wheel-tick values are set to those for 846 * the typically expected rim/tire size. configArray is set as follows: 847 * 848 * <ul> 849 * <li>configArray[0], bits [0:3] = supported wheels. Uses {@link VehicleAreaWheel}. For 850 * example, if all wheels are supported, then configArray[0] = {@link 851 * VehicleAreaWheel#WHEEL_LEFT_FRONT} | {@link VehicleAreaWheel#WHEEL_RIGHT_FRONT} | {@link 852 * VehicleAreaWheel#WHEEL_LEFT_REAR} | {@link VehicleAreaWheel#WHEEL_RIGHT_REAR} 853 * <li>configArray[1] = micrometers per front left wheel tick 854 * <li>configArray[2] = micrometers per front right wheel tick 855 * <li>configArray[3] = micrometers per rear right wheel tick 856 * <li>configArray[4] = micrometers per rear left wheel tick 857 * </ul> 858 * 859 * <p>NOTE: If a wheel is not supported, its value is always 0. 860 * 861 * <p>Property Config: 862 * <ul> 863 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 864 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 865 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 866 * <li>{@code Long[]} property type 867 * </ul> 868 * 869 * <p>Required Permission: 870 * <ul> 871 * <li>Dangerous permission {@link Car#PERMISSION_SPEED} to read property. 872 * <li>Property is not writable. 873 * </ul> 874 */ 875 @RequiresPermission(Car.PERMISSION_SPEED) 876 public static final int WHEEL_TICK = 290521862; 877 /** 878 * Fuel level in milliliters. 879 * 880 * <p>This property communicates the current amount of fuel remaining in the vehicle in 881 * milliliters. This property will not be implemented for electric vehicles. That is, if {@link 882 * #INFO_FUEL_TYPE} only contains {@link FuelType#ELECTRIC}, this property will not be 883 * implemented. For EVs, see {@link #EV_BATTERY_LEVEL}. 884 * 885 * <p>This property's value will not exceed {@link #INFO_FUEL_CAPACITY}. 886 * 887 * <p>Property Config: 888 * <ul> 889 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 890 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 891 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 892 * <li>{@code Float} property type 893 * </ul> 894 * 895 * <p>Required Permission: 896 * <ul> 897 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} to read property. 898 * <li>Property is not writable. 899 * </ul> 900 */ 901 @RequiresPermission(Car.PERMISSION_ENERGY) 902 public static final int FUEL_LEVEL = 291504903; 903 /** 904 * Fuel door open. 905 * 906 * <p>This property communicates whether the fuel door on the vehicle is open or not. This 907 * property will not be implemented for electric vehicles. That is, if {@link #INFO_FUEL_TYPE} 908 * only contains {@link FuelType#ELECTRIC}, this property will not be implemented. For EVs, see 909 * {@link #EV_CHARGE_PORT_OPEN}. 910 * 911 * <p>Property Config: 912 * <ul> 913 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 914 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 915 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 916 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 917 * <li>{@code Boolean} property type 918 * </ul> 919 * 920 * <p>Required Permissions: 921 * <ul> 922 * <li>Normal permission {@link Car#PERMISSION_ENERGY_PORTS} or Signature|Privileged permission 923 * {@link Car#PERMISSION_CONTROL_ENERGY_PORTS} to read property. 924 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ENERGY_PORTS} to 925 * write property. 926 * </ul> 927 */ 928 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_ENERGY_PORTS, 929 Car.PERMISSION_CONTROL_ENERGY_PORTS})) 930 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ENERGY_PORTS)) 931 public static final int FUEL_DOOR_OPEN = 287310600; 932 /** 933 * EV battery level. 934 * 935 * <p>Returns the current battery level in {@link android.car.VehicleUnit#WATT_HOUR}, if EV or 936 * hybrid. This value will not exceed {@link #EV_CURRENT_BATTERY_CAPACITY}. To calculate the 937 * battery percentage, use: 938 * ({@link #EV_BATTERY_LEVEL}/{@link #EV_CURRENT_BATTERY_CAPACITY})*100. 939 * 940 * <p>Property Config: 941 * <ul> 942 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 943 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 944 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 945 * <li>{@code Float} property type 946 * </ul> 947 * 948 * <p>Required Permission: 949 * <ul> 950 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} to read property. 951 * <li>Property is not writable. 952 * </ul> 953 */ 954 @RequiresPermission(Car.PERMISSION_ENERGY) 955 public static final int EV_BATTERY_LEVEL = 291504905; 956 /** 957 * Current usable battery capacity for EV or hybrid vehicle. 958 * 959 * <p>Returns the actual value of battery capacity in {@link android.car.VehicleUnit#WATT_HOUR}, 960 * if EV or hybrid. This property captures the real-time usable battery capacity taking into 961 * account factors such as battery aging and temperature dependency. Therefore, this value might 962 * be different from {@link #INFO_EV_BATTERY_CAPACITY} because {@link #INFO_EV_BATTERY_CAPACITY} 963 * returns the nominal battery capacity from when the vehicle was new. 964 * 965 * <p>Property Config: 966 * <ul> 967 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 968 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 969 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 970 * <li>{@code Float} property type 971 * </ul> 972 * 973 * <p>Required Permission: 974 * <ul> 975 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} to read property. 976 * <li>Property is not writable. 977 * </ul> 978 */ 979 @RequiresPermission(Car.PERMISSION_ENERGY) 980 public static final int EV_CURRENT_BATTERY_CAPACITY = 291504909; 981 /** 982 * EV charge port open. 983 * 984 * <p>If the vehicle has multiple charging ports, this property will return true if any of the 985 * charge ports are open. 986 * 987 * <p>Property Config: 988 * <ul> 989 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 990 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 991 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 992 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 993 * <li>{@code Boolean} property type 994 * </ul> 995 * 996 * <p>Required Permissions: 997 * <ul> 998 * <li>Normal permission {@link Car#PERMISSION_ENERGY_PORTS} or Signature|Privileged permission 999 * {@link Car#PERMISSION_CONTROL_ENERGY_PORTS} to read property. 1000 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ENERGY_PORTS} to 1001 * write property. 1002 * </ul> 1003 */ 1004 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_ENERGY_PORTS, 1005 Car.PERMISSION_CONTROL_ENERGY_PORTS})) 1006 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ENERGY_PORTS)) 1007 public static final int EV_CHARGE_PORT_OPEN = 287310602; 1008 /** 1009 * EV charge port connected. 1010 * 1011 * <p>If the vehicle has multiple charging ports, this property will return true if any of the 1012 * charge ports are connected. 1013 * 1014 * <p>Property Config: 1015 * <ul> 1016 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1017 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1018 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1019 * <li>{@code Boolean} property type 1020 * </ul> 1021 * 1022 * <p>Required Permission: 1023 * <ul> 1024 * <li>Normal permission {@link Car#PERMISSION_ENERGY_PORTS} to read property. 1025 * <li>Property is not writable. 1026 * </ul> 1027 */ 1028 @RequiresPermission(Car.PERMISSION_ENERGY_PORTS) 1029 public static final int EV_CHARGE_PORT_CONNECTED = 287310603; 1030 /** 1031 * EV instantaneous charge rate in milliwatts. 1032 * 1033 * <p>Positive rate indicates battery is being charged, and Negative rate indicates battery 1034 * being discharged. 1035 * 1036 * <p>Property Config: 1037 * <ul> 1038 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1039 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1040 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 1041 * <li>{@code Float} property type 1042 * </ul> 1043 * 1044 * <p>Required Permission: 1045 * <ul> 1046 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} to read property. 1047 * <li>Property is not writable. 1048 * </ul> 1049 */ 1050 @RequiresPermission(Car.PERMISSION_ENERGY) 1051 public static final int EV_BATTERY_INSTANTANEOUS_CHARGE_RATE = 291504908; 1052 /** 1053 * Range remaining in meters. 1054 * 1055 * <p>Range remaining accounts for all energy sources in a vehicle. For example, a hybrid car's 1056 * range will be the sum of the ranges based on fuel and battery. 1057 * 1058 * <p>Property Config: 1059 * <ul> 1060 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 1061 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1062 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1063 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 1064 * <li>{@code Float} property type 1065 * </ul> 1066 * 1067 * <p>Required Permissions: 1068 * <ul> 1069 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} or Signature|Privileged permission 1070 * {@link Car#PERMISSION_ADJUST_RANGE_REMAINING} to read property. 1071 * <li>Signature|Privileged permission {@link Car#PERMISSION_ADJUST_RANGE_REMAINING} to write 1072 * property. 1073 * </ul> 1074 */ 1075 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_ENERGY, 1076 Car.PERMISSION_ADJUST_RANGE_REMAINING})) 1077 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_ADJUST_RANGE_REMAINING)) 1078 public static final int RANGE_REMAINING = 291504904; 1079 /** 1080 * EV battery average temperature 1081 * 1082 * <p>Exposes the temperature of the battery in an EV. If multiple batteries exist in the EV, or 1083 * multiple temperature sensors exist, this property will be set to a meaningful weighted 1084 * average that best represents the overall temperature of the battery system. 1085 * 1086 * <p>Property Config: 1087 * <ul> 1088 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1089 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1090 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 1091 * <li>{@code Float} property type 1092 * </ul> 1093 * 1094 * <p>Required Permissions: 1095 * <ul> 1096 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} to read property. 1097 * <li>Property is not writable. 1098 * </ul> 1099 */ 1100 @FlaggedApi(FLAG_ANDROID_VIC_VEHICLE_PROPERTIES) 1101 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_ENERGY)) 1102 public static final int EV_BATTERY_AVERAGE_TEMPERATURE = 291504910; 1103 /** 1104 * Tire pressure in kilopascals. 1105 * 1106 * <p>Each areaId represents one tire. The 1107 * {@link android.car.hardware.CarPropertyConfig#getAreaIds} for {@code TIRE_PRESSURE} will be a 1108 * list of {@link VehicleAreaWheel}s. 1109 * 1110 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 1111 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 1112 * all areaIds. 1113 * 1114 * <p>For each areaId, the result for {@code getMinMaxSupportedValue} indicates the OEM 1115 * recommended tire pressure range for that tire. 1116 * 1117 * <p>Property Config: 1118 * <ul> 1119 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1120 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WHEEL} 1121 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 1122 * <li>{@code Float} property type 1123 * </ul> 1124 * 1125 * <p>Required Permission: 1126 * <ul> 1127 * <li>Dangerous permission {@link Car#PERMISSION_TIRES_3P} or Signature|Privileged permission 1128 * {@link Car#PERMISSION_TIRES} to read property. 1129 * <li>Property is not writable. 1130 * </ul> 1131 */ 1132 @FlaggedApi(FLAG_VEHICLE_PROPERTY_25Q2_3P_PERMISSIONS) 1133 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_TIRES_3P, 1134 Car.PERMISSION_TIRES})) 1135 public static final int TIRE_PRESSURE = 392168201; 1136 /** 1137 * Critically low tire pressure. 1138 * 1139 * <p>For each area ID listed in {@link android.car.hardware.CarPropertyConfig#getAreaIds}, the 1140 * corresponding {@code CRITICALLY_LOW_TIRE_PRESSURE} will be less than or equal the {@link 1141 * android.car.hardware.property.AreaIdConfig#getMinValue()} of {@link #TIRE_PRESSURE} for the 1142 * same area ID. 1143 * 1144 * <p>Property Config: 1145 * <ul> 1146 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1147 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WHEEL} 1148 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 1149 * <li>{@code Float} property type 1150 * </ul> 1151 * 1152 * <p>Required Permission: 1153 * <ul> 1154 * <li>Signature|Privileged permission {@link Car#PERMISSION_TIRES} to read property. 1155 * <li>Property is not writable. 1156 * </ul> 1157 */ 1158 @RequiresPermission(Car.PERMISSION_TIRES) 1159 public static final int CRITICALLY_LOW_TIRE_PRESSURE = 392168202; 1160 /** 1161 * Accelerator pedal compression percentage. 1162 * 1163 * <p>This property communicates the percentage that the physical accelerator 1164 * pedal in the vehicle is compressed. This property returns a float value from 1165 * 0 to 100. 1166 * 1167 * <p>0 indicates the pedal's uncompressed position. 1168 * <p>100 indicates the pedal's maximally compressed position. 1169 * 1170 * <p>Property Config: 1171 * <ul> 1172 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1173 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1174 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 1175 * <li>{@code Float} property type 1176 * </ul> 1177 * 1178 * <p>Required Permissions: 1179 * <ul> 1180 * <li>Dangerous permission {@link Car#PERMISSION_READ_CAR_PEDALS} to read property. 1181 * <li>Property is not writable 1182 * </ul> 1183 */ 1184 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 1185 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_CAR_PEDALS)) 1186 public static final int ACCELERATOR_PEDAL_COMPRESSION_PERCENTAGE = 291504911; 1187 /** 1188 * Brake pedal compression percentage. 1189 * 1190 * <p>This property communicates the percentage that the physical brake pedal 1191 * in the vehicle is compressed. This property returns a float value from 0 to 1192 * 100. 1193 * 1194 * <p>0 indicates the pedal's uncompressed position. 1195 * <p>100 indicates the pedal's maximally compressed position. 1196 * 1197 * <p>Property Config: 1198 * <ul> 1199 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1200 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1201 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 1202 * <li>{@code Float} property type 1203 * </ul> 1204 * 1205 * <p>Required Permissions: 1206 * <ul> 1207 * <li>Dangerous permission {@link Car#PERMISSION_READ_CAR_PEDALS} to read property. 1208 * <li>Property is not writable 1209 * </ul> 1210 */ 1211 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 1212 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_CAR_PEDALS)) 1213 public static final int BRAKE_PEDAL_COMPRESSION_PERCENTAGE = 291504912; 1214 /** 1215 * Brake pad wear percentage. 1216 * 1217 * <p>This property communicates the amount of brake pad wear accumulated by 1218 * the vehicle as a percentage. This property returns a float value from 0 1219 * to 100. 1220 * 1221 * <p>0 indicates the brake pad has no wear. 1222 * <p>100 indicates the brake pad is maximally worn. 1223 * 1224 * <p>Property Config: 1225 * <ul> 1226 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1227 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WHEEL} 1228 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1229 * <li>{@code Float} property type 1230 * </ul> 1231 * 1232 * <p>Required Permissions: 1233 * <ul> 1234 * <li>Dangerous permission {@link Car#PERMISSION_READ_BRAKE_INFO} to read property. 1235 * <li>Property is not writable 1236 * </ul> 1237 */ 1238 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 1239 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_BRAKE_INFO)) 1240 public static final int BRAKE_PAD_WEAR_PERCENTAGE = 392168209; 1241 /** 1242 * Brake fluid level low. 1243 * 1244 * <p>This property communicates that the brake fluid level in the vehicle is low according to 1245 * the OEM. This value will match the vehicle's brake fluid level status as displayed on the 1246 * instrument cluster. If the brake fluid level is low, this property will be set to {@code 1247 * true}. If not, it will be set to {@code false}. 1248 * 1249 * <p>Property Config: 1250 * <ul> 1251 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1252 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1253 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1254 * <li>{@code Boolean} property type 1255 * </ul> 1256 * 1257 * <p>Required Permissions: 1258 * <ul> 1259 * <li>Dangerous permission {@link Car#PERMISSION_READ_BRAKE_INFO} to read property. 1260 * <li>Property is not writable 1261 * </ul> 1262 */ 1263 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 1264 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_BRAKE_INFO)) 1265 public static final int BRAKE_FLUID_LEVEL_LOW = 287310610; 1266 /** 1267 * Vehicle Passive Suspension Height in mm. 1268 * 1269 * <p>This property communicates the real-time suspension displacement of the vehicle relative 1270 * to its neutral position, given in mm. In other words, the displacement of the suspension at 1271 * any given point in time relative to the suspension's position when the vehicle is on a flat 1272 * surface with no passengers or cargo. When the suspension is compressed in comparison to the 1273 * neutral position, the value should be negative. When the suspension is decompressed in 1274 * comparison to the neutral position, the value should be positive. 1275 * 1276 * <p>Examples for further clarity: 1277 * <ul> 1278 * <li>1) Suppose the user is driving on a smooth flat surface, and all wheels are currently 1279 * compressed by 2 cm in comparison to the default suspension height. In this scenario, this 1280 * property will be set to -20 for all wheels. 1281 * <li>2) Suppose the user drives over a pothole. While the front left wheel is over the 1282 * pothole, it's decompressed by 3 cm in comparison to the rest of the wheels, or 1 cm in 1283 * comparison to the default suspension height. All the others are still compressed by 2 cm. 1284 * In this scenario, this property will be set to -20 for all wheels except for the front 1285 * left, which will be set to 10. 1286 * </ul> 1287 * 1288 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 1289 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 1290 * all areas. 1291 * 1292 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} represents the 1293 * lower bound of the suspension height for the wheel at the specified area ID. 1294 * 1295 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 1296 * upper bound of the suspension height for the wheel at the specified area ID. 1297 * 1298 * <p>Property Config: 1299 * <ul> 1300 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1301 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WHEEL} 1302 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 1303 * <li>{@code Integer} property type 1304 * </ul> 1305 * 1306 * <p>Required Permissions: 1307 * <ul> 1308 * <li>Signature|Privileged permission {@link Car#PERMISSION_CAR_DYNAMICS_STATE} to read 1309 * property. 1310 * <li>Property is not writable 1311 * </ul> 1312 */ 1313 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 1314 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_CAR_DYNAMICS_STATE)) 1315 public static final int VEHICLE_PASSIVE_SUSPENSION_HEIGHT = 390071059; 1316 /** 1317 * Currently selected gear by user. 1318 * 1319 * <p> See {@link VehicleGear} for gear value enum. 1320 * 1321 * <p>configArray represents the list of supported gears for the vehicle. For example, 1322 * configArray for an EV vehicle is set as follows: 1323 * 1324 * <ul> 1325 * <li>configArray[0] = {@link VehicleGear#GEAR_REVERSE} 1326 * <li>configArray[1] = {@link VehicleGear#GEAR_PARK} 1327 * <li>configArray[2] = {@link VehicleGear#GEAR_DRIVE} 1328 * </ul> 1329 * 1330 * <p>Example automatic transmission configArray: 1331 * 1332 * <ul> 1333 * <li>configArray[0] = {@link VehicleGear#GEAR_NEUTRAL} 1334 * <li>configArray[1] = {@link VehicleGear#GEAR_REVERSE} 1335 * <li>configArray[2] = {@link VehicleGear#GEAR_PARK} 1336 * <li>configArray[3] = {@link VehicleGear#GEAR_DRIVE} 1337 * <li>configArray[4] = {@link VehicleGear#GEAR_FIRST} 1338 * <li>configArray[5] = {@link VehicleGear#GEAR_SECOND} 1339 * <li>... 1340 * </ul> 1341 * 1342 * <p>Example manual transmission configArray: 1343 * 1344 * <ul> 1345 * <li>configArray[0] = {@link VehicleGear#GEAR_NEUTRAL} 1346 * <li>configArray[1] = {@link VehicleGear#GEAR_REVERSE} 1347 * <li>configArray[4] = {@link VehicleGear#GEAR_FIRST} 1348 * <li>configArray[5] = {@link VehicleGear#GEAR_SECOND} 1349 * <li>... 1350 * </ul> 1351 * 1352 * <p>Property Config: 1353 * <ul> 1354 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1355 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1356 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1357 * <li>{@code Integer} property type 1358 * </ul> 1359 * 1360 * <p>Required Permission: 1361 * <ul> 1362 * <li>Normal permission {@link Car#PERMISSION_POWERTRAIN} to read property. 1363 * <li>Property is not writable. 1364 * </ul> 1365 * 1366 * @data_enum {@link VehicleGear} 1367 */ 1368 @RequiresPermission(Car.PERMISSION_POWERTRAIN) 1369 public static final int GEAR_SELECTION = 289408000; 1370 /** 1371 * Vehicle transmission's current {@link VehicleGear}. 1372 * 1373 * <p>{@code CURRENT_GEAR}'s value may not match that of {@link 1374 * VehiclePropertyIds#GEAR_SELECTION}. For example, if the {@link 1375 * VehiclePropertyIds#GEAR_SELECTION} is {@link VehicleGear#GEAR_DRIVE} in a vehicle with an 1376 * automatic transmission, the {@code CURRENT_GEAR} will be one of {@link 1377 * VehicleGear#GEAR_FIRST}, {@link VehicleGear#GEAR_SECOND}, etc, which reflects the actual gear 1378 * the transmission is currently running in. 1379 * 1380 * <p>configArray represents the list of supported {@link VehicleGear}s for {@code 1381 * CURRENT_GEAR}. For example, the configArray for an EV vehicle is set as follows: 1382 * 1383 * <ul> 1384 * <li>configArray[0] = {@link VehicleGear#GEAR_REVERSE} 1385 * <li>configArray[1] = {@link VehicleGear#GEAR_PARK} 1386 * <li>configArray[2] = {@link VehicleGear#GEAR_DRIVE} 1387 * </ul> 1388 * 1389 * <p>Example automatic transmission configArray: 1390 * 1391 * <ul> 1392 * <li>configArray[0] = {@link VehicleGear#GEAR_NEUTRAL} 1393 * <li>configArray[1] = {@link VehicleGear#GEAR_REVERSE} 1394 * <li>configArray[2] = {@link VehicleGear#GEAR_PARK} 1395 * <li>configArray[4] = {@link VehicleGear#GEAR_FIRST} 1396 * <li>configArray[5] = {@link VehicleGear#GEAR_SECOND} 1397 * <li>... 1398 * </ul> 1399 * 1400 * <p>Example manual transmission configArray: 1401 * 1402 * <ul> 1403 * <li>configArray[0] = {@link VehicleGear#GEAR_NEUTRAL} 1404 * <li>configArray[1] = {@link VehicleGear#GEAR_REVERSE} 1405 * <li>configArray[4] = {@link VehicleGear#GEAR_FIRST} 1406 * <li>configArray[5] = {@link VehicleGear#GEAR_SECOND} 1407 * <li>... 1408 * </ul> 1409 * 1410 * <p>Property Config: 1411 * <ul> 1412 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1413 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1414 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1415 * <li>{@code Integer} property type 1416 * </ul> 1417 * 1418 * <p>Required Permission: 1419 * <ul> 1420 * <li>Normal permission {@link Car#PERMISSION_POWERTRAIN} to read property. 1421 * <li>Property is not writable. 1422 * </ul> 1423 * 1424 * @data_enum {@link VehicleGear} 1425 */ 1426 @RequiresPermission(Car.PERMISSION_POWERTRAIN) 1427 public static final int CURRENT_GEAR = 289408001; 1428 /** 1429 * Parking brake state. 1430 * 1431 * <p>{@code PARKING_BRAKE_ON} is true indicates that the car's parking brake is currently 1432 * engaged. False implies that the car's parking brake is currently disengaged. 1433 * 1434 * <p>Property Config: 1435 * <ul> 1436 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1437 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1438 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1439 * <li>{@code Boolean} property type 1440 * </ul> 1441 * 1442 * <p>Required Permission: 1443 * <ul> 1444 * <li>Normal permission {@link Car#PERMISSION_POWERTRAIN} to read property. 1445 * <li>Property is not writable. 1446 * </ul> 1447 */ 1448 @RequiresPermission(Car.PERMISSION_POWERTRAIN) 1449 public static final int PARKING_BRAKE_ON = 287310850; 1450 /** 1451 * Auto-apply parking brake. 1452 * 1453 * <p>{@code PARKING_BRAKE_AUTO_APPLY} is true indicates that the car's automatic parking brake 1454 * feature is currently enabled. False indicates that the car's automatic parking brake feature 1455 * is currently disabled. 1456 * 1457 * <p>This property is often confused with {@link #PARKING_BRAKE_ON}. The difference is that 1458 * {@link #PARKING_BRAKE_ON} describes whether the actual parking brake is currently on/off, 1459 * whereas {@code PARKING_BRAKE_AUTO_APPLY} describes whether the feature of automatic parking 1460 * brake is enabled/disabled, and does not describe the current state of the actual parking 1461 * brake. 1462 * 1463 * <p>Property Config: 1464 * <ul> 1465 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1466 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1467 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1468 * <li>{@code Boolean} property type 1469 * </ul> 1470 * 1471 * <p>Required Permission: 1472 * <ul> 1473 * <li>Normal permission {@link Car#PERMISSION_POWERTRAIN} to read property. 1474 * <li>Property is not writable. 1475 * </ul> 1476 */ 1477 @RequiresPermission(Car.PERMISSION_POWERTRAIN) 1478 public static final int PARKING_BRAKE_AUTO_APPLY = 287310851; 1479 /** 1480 * Regenerative braking level of an electronic vehicle. 1481 * 1482 * <p>Returns the current setting for the regenerative braking level. Larger setting values mean 1483 * more energy regenerated from braking while smaller setting values mean less energy 1484 * regenerated from braking. 0 means the setting for no regenerative braking. 1485 * 1486 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 1487 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 1488 * the global areaId. 1489 * 1490 * <p>the result for {@code getMinMaxSupportedValue} indicates the range of possible values. 1491 * 1492 * <p>Property Config: 1493 * <ul> 1494 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 1495 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1496 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1497 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1498 * <li>{@code Integer} property type 1499 * </ul> 1500 * 1501 * <p>Required Permissions: 1502 * <ul> 1503 * <li>Normal permission {@link Car#PERMISSION_POWERTRAIN} or Signature|Privileged permission 1504 * {@link Car#PERMISSION_CONTROL_POWERTRAIN} to read property. 1505 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_POWERTRAIN} to write 1506 * property. 1507 * </ul> 1508 */ 1509 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_POWERTRAIN, 1510 Car.PERMISSION_CONTROL_POWERTRAIN})) 1511 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_POWERTRAIN)) 1512 public static final int EV_BRAKE_REGENERATION_LEVEL = 289408012; 1513 /** 1514 * Represents property for the current stopping mode of the vehicle. 1515 * 1516 * <p>For the global area ID, the {@link 1517 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} obtained from {@link 1518 * android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which enum values from 1519 * {@code EvStoppingMode} are supported. {@code EvStoppingMode} may be extended to include more 1520 * states in the future. 1521 * 1522 * <p>Property Config: 1523 * <ul> 1524 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 1525 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1526 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1527 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1528 * <li>{@code Integer} property type 1529 * </ul> 1530 * 1531 * <p>Required Permissions: 1532 * <ul> 1533 * <li>Normal permission {@link Car#PERMISSION_POWERTRAIN} or Signature|Privileged permission 1534 * {@link Car#PERMISSION_CONTROL_POWERTRAIN} to read property. 1535 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_POWERTRAIN} to write 1536 * property. 1537 * </ul> 1538 * 1539 * @data_enum {@link EvStoppingMode} 1540 */ 1541 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_POWERTRAIN, 1542 Car.PERMISSION_CONTROL_POWERTRAIN})) 1543 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_POWERTRAIN)) 1544 public static final int EV_STOPPING_MODE = 289408013; 1545 /** 1546 * Warning for fuel low level. 1547 * 1548 * <p>{@code FUEL_LEVEL_LOW} corresponds to the low fuel warning on the dashboard. Once {@code 1549 * FUEL_LEVEL_LOW} is set, it should not be cleared until more fuel is added to the vehicle. 1550 * This property may take into account all fuel sources for a vehicle - for example: 1551 * <ul> 1552 * <li>For a gas powered vehicle, this property is based solely on gas level. 1553 * <li>For a battery powered vehicle, this property is based solely on battery level. 1554 * <li>For a hybrid vehicle, this property may be based on the combination of gas and 1555 * battery levels, at the OEM's discretion. 1556 * </ul> 1557 * 1558 * <p>Property Config: 1559 * <ul> 1560 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1561 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1562 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1563 * <li>{@code Boolean} property type 1564 * </ul> 1565 * 1566 * <p>Required Permission: 1567 * <ul> 1568 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} to read property. 1569 * <li>Property is not writable. 1570 * </ul> 1571 */ 1572 @RequiresPermission(Car.PERMISSION_ENERGY) 1573 public static final int FUEL_LEVEL_LOW = 287310853; 1574 /** 1575 * Night mode. 1576 * 1577 * <p>True indicates that the night mode sensor has detected that the car cabin environment has 1578 * low light. 1579 * 1580 * <p>Property Config: 1581 * <ul> 1582 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1583 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1584 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1585 * <li>{@code Boolean} property type 1586 * </ul> 1587 * 1588 * <p>Required Permission: 1589 * <ul> 1590 * <li>Normal permission {@link Car#PERMISSION_EXTERIOR_ENVIRONMENT} to read property. 1591 * <li>Property is not writable. 1592 * </ul> 1593 */ 1594 @RequiresPermission(Car.PERMISSION_EXTERIOR_ENVIRONMENT) 1595 public static final int NIGHT_MODE = 287310855; 1596 /** 1597 * State of the vehicles turn signals 1598 * 1599 * @deprecated because it ambiguously defines the state of the vehicle turn signals without 1600 * making clear if it means the state of the turn signal lights or the state of the turn signal 1601 * switch. {@link #TURN_SIGNAL_LIGHT_STATE} and {@link #TURN_SIGNAL_SWITCH} rectify this 1602 * problem. 1603 * 1604 * <p>See {@code VehicleTurnSignal} for possible values for {@code TURN_SIGNAL_STATE}. 1605 * 1606 * <p>Property Config: 1607 * <ul> 1608 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1609 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1610 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1611 * <li>{@code Integer} property type 1612 * </ul> 1613 * 1614 * <p>Required Permission: 1615 * <ul> 1616 * <li>Signature|Privileged permission {@link Car#PERMISSION_EXTERIOR_LIGHTS} to read 1617 * property. 1618 * <li>Property is not writable. 1619 * </ul> 1620 * 1621 * @data_enum {@link VehicleTurnSignal} 1622 */ 1623 @Deprecated 1624 @RequiresPermission(Car.PERMISSION_EXTERIOR_LIGHTS) 1625 public static final int TURN_SIGNAL_STATE = 289408008; 1626 /** 1627 * Vehicle's ignition state. 1628 * 1629 * <p>See {@link VehicleIgnitionState} for possible values for {@code IGNITION_STATE}. 1630 * 1631 * <p>Property Config: 1632 * <ul> 1633 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1634 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1635 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1636 * <li>{@code Integer} property type 1637 * </ul> 1638 * 1639 * <p>Required Permission: 1640 * <ul> 1641 * <li>Normal permission {@link Car#PERMISSION_POWERTRAIN} to read property. 1642 * <li>Property is not writable. 1643 * </ul> 1644 * 1645 * @data_enum {@link VehicleIgnitionState} 1646 */ 1647 @RequiresPermission(Car.PERMISSION_POWERTRAIN) 1648 public static final int IGNITION_STATE = 289408009; 1649 /** 1650 * ABS is active. 1651 * 1652 * <p>Property Config: 1653 * <ul> 1654 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1655 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1656 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1657 * <li>{@code Boolean} property type 1658 * </ul> 1659 * 1660 * <p>Required Permission: 1661 * <ul> 1662 * <li>Signature|Privileged permission {@link Car#PERMISSION_CAR_DYNAMICS_STATE} to read 1663 * property. 1664 * <li>Property is not writable. 1665 * </ul> 1666 */ 1667 @RequiresPermission(Car.PERMISSION_CAR_DYNAMICS_STATE) 1668 public static final int ABS_ACTIVE = 287310858; 1669 /** 1670 * Traction Control is active. 1671 * 1672 * <p>Property Config: 1673 * <ul> 1674 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1675 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1676 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1677 * <li>{@code Boolean} property type 1678 * </ul> 1679 * 1680 * <p>Required Permission: 1681 * <ul> 1682 * <li>Signature|Privileged permission {@link Car#PERMISSION_CAR_DYNAMICS_STATE} to read 1683 * property. 1684 * <li>Property is not writable. 1685 * </ul> 1686 */ 1687 @RequiresPermission(Car.PERMISSION_CAR_DYNAMICS_STATE) 1688 public static final int TRACTION_CONTROL_ACTIVE = 287310859; 1689 /** 1690 * Enable or disable Electronic Stability Control (ESC). 1691 * 1692 * <p>Returns true if ESC is enabled and false if ESC is disabled. When ESC is enabled, a system 1693 * in the vehicle should be controlling the tires during instances with high risk of skidding to 1694 * actively prevent the same from happening. 1695 * 1696 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 1697 * only. 1698 * 1699 * <p>Property Config: 1700 * <ul> 1701 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 1702 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1703 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1704 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1705 * <li>{@code Boolean} property type 1706 * </ul> 1707 * 1708 * <p>Required Permissions: 1709 * <ul> 1710 * <li>Signature|Privileged permission {@link Car#PERMISSION_CAR_DYNAMICS_STATE} or 1711 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_DYNAMICS_STATE} to read 1712 * property. 1713 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_DYNAMICS_STATE} to 1714 * write property. 1715 * </ul> 1716 */ 1717 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 1718 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_CAR_DYNAMICS_STATE, 1719 Car.PERMISSION_CONTROL_CAR_DYNAMICS_STATE})) 1720 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_CAR_DYNAMICS_STATE)) 1721 public static final int ELECTRONIC_STABILITY_CONTROL_ENABLED = 287310862; 1722 /** 1723 * Electronic Stability Control (ESC) state. 1724 * 1725 * <p>Returns the current state of ESC. This property will always return a valid state defined 1726 * in {@link android.car.hardware.property.ElectronicStabilityControlState} or {@link 1727 * android.car.hardware.property.ErrorState}. 1728 * 1729 * <p>For the global area ID (0), the {@link 1730 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 1731 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 1732 * from {@link android.car.hardware.property.ElectronicStabilityControlState} and {@link 1733 * android.car.hardware.property.ErrorState} are supported. 1734 * 1735 * <p>Property Config: 1736 * <ul> 1737 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1738 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1739 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1740 * <li>{@code Integer} property type 1741 * </ul> 1742 * 1743 * <p>Required Permission: 1744 * <ul> 1745 * <li>Signature|Privileged permission {@link Car#PERMISSION_CAR_DYNAMICS_STATE} to read 1746 * property. 1747 * <li>Property is not writable. 1748 * </ul> 1749 * 1750 * @data_enum {@link android.car.hardware.property.ElectronicStabilityControlState} 1751 * @data_enum {@link ErrorState} 1752 */ 1753 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 1754 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_CAR_DYNAMICS_STATE)) 1755 public static final int ELECTRONIC_STABILITY_CONTROL_STATE = 289408015; 1756 /** 1757 * Turn signal light state. 1758 * 1759 * <p>This property communicates the actual state of the turn signal lights. It is independent 1760 * from the actual turn signal switch state or the hazard lights button state. 1761 * 1762 * <p>Examples: 1763 * <ul> 1764 * <li>1) Left turn signal light is currently pulsing, right turn signal light is currently 1765 * off. This property will return {@link VehicleTurnSignal#STATE_LEFT} while the light is on 1766 * during the pulse, and {@link VehicleTurnSignal#STATE_NONE} when it is off during the pulse. 1767 * <li>2) Right turn signal light is currently pulsing, left turn signal light is currently 1768 * off. This property will return {@link VehicleTurnSignal#STATE_RIGHT} while the light is on 1769 * during the pulse, and {@link VehicleTurnSignal#STATE_NONE} when it is off during the pulse. 1770 * <li>3) Both turn signal lights are currently pulsing (e.g. when hazard lights switch is 1771 * on). This property will return {@link VehicleTurnSignal#STATE_LEFT} | {@link 1772 * VehicleTurnSignal#STATE_RIGHT} while the lights are on during the pulse, and {@link 1773 * VehicleTurnSignal#STATE_NONE} when they are off during the pulse. 1774 * </ul> 1775 * 1776 * <p>This is different from the function of {@link #TURN_SIGNAL_SWITCH}, which must communicate 1777 * the state of the turn signal lever/switch. 1778 * 1779 * <p>Note that this property uses {@link VehicleTurnSignal} as a bit flag, unlike {@link 1780 * #TURN_SIGNAL_SWITCH}, which uses it like a regular enum. This means this property supports 1781 * ORed together values in {@link VehicleTurnSignal}. 1782 * 1783 * <p>Property Config: 1784 * <ul> 1785 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1786 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1787 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1788 * <li>{@code Integer} property type 1789 * </ul> 1790 * 1791 * <p>Required Permission: 1792 * <ul> 1793 * <li>Dangerous permission {@link Car#PERMISSION_READ_EXTERIOR_LIGHTS} or Signature|Privileged 1794 * permission {@link Car#PERMISSION_CONTROL_EXTERIOR_LIGHTS} to read property. 1795 * <li>Property is not writable. 1796 * </ul> 1797 * 1798 * @data_enum {@link VehicleTurnSignal} 1799 */ 1800 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 1801 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_EXTERIOR_LIGHTS, 1802 Car.PERMISSION_CONTROL_EXTERIOR_LIGHTS})) 1803 public static final int TURN_SIGNAL_LIGHT_STATE = 289408016; 1804 /** 1805 * Turn signal switch. 1806 * 1807 * <p>This property communicates the state of the turn signal lever/switch. This is different 1808 * from the function of {@link #TURN_SIGNAL_LIGHT_STATE}, which must communicate the actual 1809 * state of the turn signal lights. 1810 * 1811 * <p>Note that this property uses {@link VehicleTurnSignal} as a regular enum, unlike {@link 1812 * #TURN_SIGNAL_LIGHT_STATE}, which uses it like a bit flag. This means this property does not 1813 * support ORed together values in {@link VehicleTurnSignal}. 1814 * 1815 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 1816 * only. 1817 * 1818 * <p>Property Config: 1819 * <ul> 1820 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 1821 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1822 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 1823 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1824 * <li>{@code Integer} property type 1825 * </ul> 1826 * 1827 * <p>Required Permission: 1828 * <ul> 1829 * <li>Dangerous permission {@link Car#PERMISSION_READ_EXTERIOR_LIGHTS} or Signature|Privileged 1830 * permission {@link Car#PERMISSION_CONTROL_EXTERIOR_LIGHTS} to read property. 1831 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_EXTERIOR_LIGHTS} to write 1832 * property. 1833 * </ul> 1834 * 1835 * @data_enum {@link VehicleTurnSignal} 1836 */ 1837 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 1838 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_EXTERIOR_LIGHTS, 1839 Car.PERMISSION_CONTROL_EXTERIOR_LIGHTS})) 1840 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_EXTERIOR_LIGHTS)) 1841 public static final int TURN_SIGNAL_SWITCH = 289408017; 1842 /** 1843 * Fan speed setting. 1844 * 1845 * <p>This property is not in any particular unit but in a specified range of relative speeds. 1846 * 0 means the fan is off. The value must be non-negative, larger values mean faster fan speed. 1847 * 1848 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 1849 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 1850 * all areaIds. 1851 * 1852 * <p>For each areaId, the result for {@code getMinMaxSupportedValue} indicates the range 1853 * of possible fan speed. 1854 * 1855 * <p>If 0 is included in the range, then you can use this property to turn off the fan. 1856 * Otherwise, you cannot use this property to turn off the fan, use {@link HVAC_POWER_ON} 1857 * instead. 1858 * 1859 * <p>Property Config: 1860 * <ul> 1861 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 1862 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1863 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 1864 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1865 * <li>{@code Integer} property type 1866 * </ul> 1867 * 1868 * <p>Required Permission: 1869 * <ul> 1870 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 1871 * and write property. 1872 * </ul> 1873 */ 1874 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 1875 public static final int HVAC_FAN_SPEED = 356517120; 1876 /** 1877 * The current {@link CarHvacFanDirection} setting. 1878 * 1879 * <p>The supported values for this property is exposed via 1880 * {@link #HVAC_FAN_DIRECTION_AVAILABLE}. Caller should not call 1881 * {@link CarPropertyManager#getSupportedValuesList} or 1882 * {@link CarPropertyManager#getMinMaxSupportedValue} or 1883 * {@link AreaIdConfig#getSupportedEnumValues}. 1884 * 1885 * <p>This property will be supported if {@link #HVAC_FAN_DIRECTION_AVAILABLE} is supported 1886 * on the vehicle, and vice versa. 1887 * 1888 * <p>Property Config: 1889 * <ul> 1890 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 1891 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1892 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 1893 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1894 * <li>{@code Integer} property type 1895 * </ul> 1896 * 1897 * <p>Required Permission: 1898 * <ul> 1899 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 1900 * and write property. 1901 * </ul> 1902 * 1903 * @data_enum {@link CarHvacFanDirection} 1904 */ 1905 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 1906 public static final int HVAC_FAN_DIRECTION = 356517121; 1907 /** 1908 * HVAC current temperature in celsius. 1909 * 1910 * <p>Property Config: 1911 * <ul> 1912 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 1913 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 1914 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 1915 * <li>{@code Float} property type 1916 * </ul> 1917 * 1918 * <p>Required Permission: 1919 * <ul> 1920 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 1921 * property. 1922 * <li>Property is not writable. 1923 * </ul> 1924 */ 1925 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 1926 public static final int HVAC_TEMPERATURE_CURRENT = 358614274; 1927 /** 1928 * HVAC target temperature set in Celsius. 1929 * 1930 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 1931 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 1932 * all areaIds. 1933 * 1934 * <p>For each areaId, the result for {@code getMinMaxSupportedValue} indicates the range of 1935 * HVAC temperature in Celsius. 1936 * 1937 * <p>The vehicle may not support setting a continuous range of temperature values in between 1938 * the min and max values. 1939 * 1940 * <p>Therefore, if the vehicle supports {@link #HVAC_TEMPERATURE_VALUE_SUGGESTION}, the 1941 * application should use that property to get a supported value before setting {@code 1942 * HVAC_TEMPERATURE_SET}. The application should also use {@link 1943 * #HVAC_TEMPERATURE_VALUE_SUGGESTION} for converting the temperature from Celsius to Fahrenheit 1944 * and vice versa for this vehicle. 1945 * 1946 * <p>Else if the {@link android.car.hardware.CarPropertyConfig#getConfigArray()} is defined, 1947 * then it represents the list of valid temperature values that can be set. It also describes a 1948 * lookup table to convert the temperature from Celsius to Fahrenheit and vice versa for this 1949 * vehicle. 1950 * 1951 * <p>The {@code configArray} is set as follows: 1952 * <ul> 1953 * <li>{@code configArray[0]} is [the lower bound of the supported temperature in Celsius] 1954 * * 10. 1955 * <li>{@code configArray[1]} is [the upper bound of the supported temperature in Celsius] 1956 * * 10. 1957 * <li>{@code configArray[2]} is [the increment in Celsius] * 10. 1958 * <li>{@code configArray[3]} is 1959 * [the lower bound of the supported temperature in Fahrenheit] * 10. 1960 * <li>{@code configArray[4]} is 1961 * [the upper bound of the supported temperature in Fahrenheit] * 10. 1962 * <li>{@code configArray[5]} is [the increment in Fahrenheit] * 10. 1963 * </ul> 1964 * 1965 * <p>For example, if the vehicle supports temperature values as: 1966 * <pre> 1967 * [16.0, 16.5, 17.0 ,..., 28.0] in Celsius 1968 * [60.5, 61.5, 62.5 ,..., 84.5] in Fahrenheit 1969 * </pre> 1970 * 1971 * <p>The {@code configArray} should be: 1972 * <pre> 1973 * {@code configArray = {160, 280, 5, 605, 845, 10}} 1974 * </pre> 1975 * 1976 * <p>If the {@code configArray} is defined, applications should not use any other method for 1977 * converting temperature values besides {@link #HVAC_TEMPERATURE_VALUE_SUGGESTION}, such as the 1978 * standard unit conversion formula of {@code F = (9/5) * C + 32}. Any value set that is not 1979 * contained within the list of valid values is considered undefined behavior and may result in 1980 * inconsistencies in the value set by the application and the value set in the VHAL. 1981 * 1982 * <p>For converting the temperature from Celsius to Fahrenheit use the following: 1983 * <pre> 1984 * {@code 1985 * // Given tempC and configArray 1986 * float minTempC = configArray.get(0) / 10f; 1987 * float temperatureIncrementCelsius = configArray.get(2) / 10f; 1988 * float minTempF = configArray.get(3) / 10f; 1989 * float temperatureIncrementFahrenheit = configArray.get(5) / 10f; 1990 * // Round to the closest increment 1991 * int numIncrements = Math.round((tempC - minTempC) / temperatureIncrementCelsius); 1992 * float tempF = temperatureIncrementFahrenheit * numIncrements + minTempF; 1993 * } 1994 * </pre> 1995 * <p>For converting the temperature from Fahrenheit to Celsius, use the same method as above 1996 * except changing the Celsius values to the relevant Fahrenheit values. 1997 * 1998 * <p>Othwerise, if neither {@link #HVAC_TEMPERATURE_VALUE_SUGGESTION} nor the {@code 1999 * configArray} are defined, the application should use the standard unit conversion formula of 2000 * {@code F = (9/5) * C + 32}. 2001 * 2002 * <p>Property Config: 2003 * <ul> 2004 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2005 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2006 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2007 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2008 * <li>{@code Float} property type 2009 * </ul> 2010 * 2011 * <p>Required Permission: 2012 * <ul> 2013 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2014 * and write property. 2015 * </ul> 2016 */ 2017 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2018 public static final int HVAC_TEMPERATURE_SET = 358614275; 2019 /** 2020 * Suggested values for setting HVAC temperature. 2021 * 2022 * <p>Implement the property to help applications understand the closest supported temperature 2023 * value in Celsius or Fahrenheit. 2024 * <ul> 2025 * <li>{@code floatValues[0]} is the requested value that an application wants to set a 2026 * temperature to. 2027 * <li>{@code floatValues[1]} is the unit for {@code floatValues[0]}. It should be one of 2028 * ({@link VehicleUnit#CELSIUS}, {@link VehicleUnit#FAHRENHEIT}). 2029 * <li>{@code floatValues[2]} is the value OEMs suggested in CELSIUS. This value is not 2030 * included in the request. 2031 * <li>{@code floatValues[3]} is the value OEMs suggested in FAHRENHEIT. This value is not 2032 * included in the request. 2033 * </ul> 2034 * 2035 * <p>An application calls 2036 * {@link android.car.hardware.property.CarPropertyManager#setProperty(Class, int, int, Object)} 2037 * with the requested value and unit for the value. OEMs need to return the suggested values 2038 * in {@code floatValues[2]} and {@code floatValues[3]} by 2039 * {@link android.car.hardware.property.CarPropertyManager.CarPropertyEventCallback}. 2040 * 2041 * <p>For example, when a user uses the voice assistant to set HVAC temperature to 66.2 in 2042 * Fahrenheit. 2043 * 2044 * <p>First, an application will set this property with the value 2045 * [66.2, {@link VehicleUnit#FAHRENHEIT}, 0, 0]. If OEMs suggest to set 19.0 in Celsius 2046 * or 66.5 in Fahrenheit for user's request, then car must generate a callback with property 2047 * value [66.2, {@link VehicleUnit#FAHRENHEIT}, 19.0, 66.5]. After the voice assistant 2048 * gets the callback, it will inform the user and set HVAC temperature to the suggested value. 2049 * 2050 * <p>Another example, an application receives 21 Celsius as the current temperature value by 2051 * querying {@link VehiclePropertyIds#HVAC_TEMPERATURE_SET}. But the application wants to know 2052 * what value is displayed on the car's UI in Fahrenheit. 2053 * 2054 * <p>For this, the application sets the property to 2055 * [21, {@link VehicleUnit#CELSIUS}, 0, 0]. If the suggested value by the OEM for 21 2056 * Celsius is 70 Fahrenheit, then car must generate a callback with property value 2057 * [21, {@link VehicleUnit#CELSIUS}, 21.0, 70.0]. In this case, the application can know 2058 * that the value is 70.0 Fahrenheit in the car’s UI. 2059 * 2060 * <p>Property Config: 2061 * <ul> 2062 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} 2063 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2064 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2065 * <li>{@code Float[]} property type 2066 * </ul> 2067 * 2068 * <p>Required Permission: 2069 * <ul> 2070 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2071 * and write property. 2072 * </ul> 2073 */ 2074 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2075 public static final int HVAC_TEMPERATURE_VALUE_SUGGESTION = 291570965; 2076 /** 2077 * On/off defrost for designated window. 2078 * 2079 * <p>Property Config: 2080 * <ul> 2081 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2082 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2083 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WINDOW} 2084 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2085 * <li>{@code Boolean} property type 2086 * </ul> 2087 * 2088 * <p>Required Permission: 2089 * <ul> 2090 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2091 * and write property. 2092 * </ul> 2093 */ 2094 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2095 public static final int HVAC_DEFROSTER = 320865540; 2096 /** 2097 * On/off AC for designated areaId. 2098 * 2099 * <p>Property Config: 2100 * <ul> 2101 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2102 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2103 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2104 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2105 * <li>{@code Boolean} property type 2106 * </ul> 2107 * 2108 * <p>Required Permission: 2109 * <ul> 2110 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2111 * and write property. 2112 * </ul> 2113 */ 2114 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2115 public static final int HVAC_AC_ON = 354419973; 2116 /** 2117 * On/off max AC. 2118 * 2119 * <p>Property Config: 2120 * <ul> 2121 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2122 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2123 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2124 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2125 * <li>{@code Boolean} property type 2126 * </ul> 2127 * 2128 * <p>Required Permission: 2129 * <ul> 2130 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2131 * and write property. 2132 * </ul> 2133 */ 2134 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2135 public static final int HVAC_MAX_AC_ON = 354419974; 2136 /** 2137 * On/off max defrost. 2138 * 2139 * <p>Property Config: 2140 * <ul> 2141 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2142 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2143 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2144 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2145 * <li>{@code Boolean} property type 2146 * </ul> 2147 * 2148 * <p>Required Permission: 2149 * <ul> 2150 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2151 * and write property. 2152 * </ul> 2153 */ 2154 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2155 public static final int HVAC_MAX_DEFROST_ON = 354419975; 2156 /** 2157 * Recirculation on/off. 2158 * 2159 * <p>Property Config: 2160 * <ul> 2161 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2162 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2163 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2164 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2165 * <li>{@code Boolean} property type 2166 * </ul> 2167 * 2168 * <p>Required Permission: 2169 * <ul> 2170 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2171 * and write property. 2172 * </ul> 2173 */ 2174 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2175 public static final int HVAC_RECIRC_ON = 354419976; 2176 /** 2177 * Enable temperature coupling between areas. 2178 * 2179 * <p>Property Config: 2180 * <ul> 2181 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2182 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2183 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2184 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2185 * <li>{@code Boolean} property type 2186 * </ul> 2187 * 2188 * <p>Required Permission: 2189 * <ul> 2190 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2191 * and write property. 2192 * </ul> 2193 */ 2194 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2195 public static final int HVAC_DUAL_ON = 354419977; 2196 /** 2197 * On/off automatic mode. 2198 * 2199 * <p>Property Config: 2200 * <ul> 2201 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2202 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2203 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2204 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2205 * <li>{@code Boolean} property type 2206 * </ul> 2207 * 2208 * <p>Required Permission: 2209 * <ul> 2210 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2211 * and write property. 2212 * </ul> 2213 */ 2214 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2215 public static final int HVAC_AUTO_ON = 354419978; 2216 /** 2217 * Seat heating/cooling. 2218 * 2219 * <p>This property is not in any particular unit, but in a specified range of relative 2220 * temperature settings. 0 means no heating or cooling. Positive values indicate heating and 2221 * negative values indicate cooling. Larger absolute values indicate stronger heating or 2222 * cooling. 2223 * 2224 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 2225 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 2226 * all areaIds. 2227 * 2228 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} is 0, unless 2229 * the vehicle supports seat cooling as well. In this case, it indicates the maximum seat 2230 * temperature cooling setting in negative number. 2231 * 2232 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 2233 * maximum seat temperature heating setting. 2234 * 2235 * <p>Property Config: 2236 * <ul> 2237 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2238 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2239 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2240 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2241 * <li>{@code Integer} property type 2242 * </ul> 2243 * 2244 * <p>Required Permission: 2245 * <ul> 2246 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2247 * and write property. 2248 * </ul> 2249 */ 2250 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2251 public static final int HVAC_SEAT_TEMPERATURE = 356517131; 2252 /** 2253 * Side Mirror Heat. 2254 * 2255 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 2256 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 2257 * all areaIds. 2258 * 2259 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} is 0 and 2260 * indicates no heating. 2261 * 2262 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 2263 * the maximum heating level. 2264 * 2265 * <p>Property Config: 2266 * <ul> 2267 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2268 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2269 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_MIRROR} 2270 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2271 * <li>{@code Integer} property type 2272 * </ul> 2273 * 2274 * <p>Required Permission: 2275 * <ul> 2276 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2277 * and write property. 2278 * </ul> 2279 */ 2280 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2281 public static final int HVAC_SIDE_MIRROR_HEAT = 339739916; 2282 /** 2283 * Steering Wheel Heating/Cooling. 2284 * 2285 * <p>This property is not in any particular unit but in a specified range of heating settings. 2286 * 0 means no heating or cooling. Positive values indicate heating and negative values indicate 2287 * cooling. Larger absolute values indicate stronger heating or cooling. 2288 * 2289 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 2290 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 2291 * all areaIds. 2292 * 2293 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} is 0, unless the 2294 * vehicle supports steering wheel cooling as well. In such a case, it indicates the maximum 2295 * steering wheel cooling setting in negative number. 2296 * 2297 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 2298 * maximum steering wheel heating setting. 2299 * 2300 * <p>Property Config: 2301 * <ul> 2302 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2303 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2304 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2305 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2306 * <li>{@code Integer} property type 2307 * </ul> 2308 * 2309 * <p>Required Permission: 2310 * <ul> 2311 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2312 * and write property. 2313 * </ul> 2314 */ 2315 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2316 public static final int HVAC_STEERING_WHEEL_HEAT = 289408269; 2317 /** 2318 * Temperature units for display. 2319 * 2320 * <p>Property Config: 2321 * <ul> 2322 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2323 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2324 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2325 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2326 * <li>{@code Integer} property type 2327 * </ul> 2328 * 2329 * <p>Required Permissions: 2330 * <ul> 2331 * <li>Normal permission {@link Car#PERMISSION_READ_DISPLAY_UNITS} or Signature|Privileged 2332 * permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read property. 2333 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to write 2334 * property. 2335 * </ul> 2336 * 2337 * @data_enum {@link VehicleUnit} 2338 */ 2339 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_DISPLAY_UNITS, 2340 Car.PERMISSION_CONTROL_CAR_CLIMATE})) 2341 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE)) 2342 public static final int HVAC_TEMPERATURE_DISPLAY_UNITS = 289408270; 2343 /** 2344 * Actual fan speed. 2345 * 2346 * <p>Property Config: 2347 * <ul> 2348 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2349 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2350 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2351 * <li>{@code Integer} property type 2352 * </ul> 2353 * 2354 * <p>Required Permission: 2355 * <ul> 2356 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2357 * property. 2358 * <li>Property is not writable. 2359 * </ul> 2360 */ 2361 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2362 public static final int HVAC_ACTUAL_FAN_SPEED_RPM = 356517135; 2363 /** 2364 * Represents global power state for HVAC. 2365 * 2366 * <p>Setting this property to false MAY mark some properties that control individual HVAC 2367 * features/subsystems to UNAVAILABLE state. Setting this property to true MAY mark some 2368 * properties that control individual HVAC features/subsystems to AVAILABLE state (unless 2369 * any/all of them are UNAVAILABLE on their own individual merits). 2370 * 2371 * <p>Property Config: 2372 * <ul> 2373 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2374 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2375 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2376 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2377 * <li>{@code Boolean} property type 2378 * </ul> 2379 * 2380 * <p>Required Permission: 2381 * <ul> 2382 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2383 * and write property. 2384 * </ul> 2385 */ 2386 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2387 public static final int HVAC_POWER_ON = 354419984; 2388 /** 2389 * List of supported {@link CarHvacFanDirection} values for the vehicle. 2390 * 2391 * <p>For each supported area ID, this property provides a list of supported HVAC fan 2392 * positions for the {@link #HVAC_FAN_DIRECTION} property (e.g. 2393 * {@link CarHvacFanDirection#DEFROST_AND_FLOOR}). 2394 * 2395 * <p>This property will be supported if {@link #HVAC_FAN_DIRECTION} is supported on the 2396 * vehicle, and vice versa. 2397 * 2398 * <p>Property Config: 2399 * <ul> 2400 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2401 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2402 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 2403 * <li>{@code Integer[]} property type 2404 * </ul> 2405 * 2406 * <p>Required Permission: 2407 * <ul> 2408 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2409 * property. 2410 * <li>Property is not writable. 2411 * </ul> 2412 * 2413 * @data_enum {@link CarHvacFanDirection} 2414 */ 2415 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2416 public static final int HVAC_FAN_DIRECTION_AVAILABLE = 356582673; 2417 /** 2418 * Automatic recirculation on/off. 2419 * 2420 * <p>Property Config: 2421 * <ul> 2422 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2423 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2424 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2425 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2426 * <li>{@code Boolean} property type 2427 * </ul> 2428 * 2429 * <p>Required Permission: 2430 * <ul> 2431 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2432 * and write property. 2433 * </ul> 2434 */ 2435 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2436 public static final int HVAC_AUTO_RECIRC_ON = 354419986; 2437 /** 2438 * Seat ventilation. 2439 * 2440 * <p>This property is not in any particular unit but in the specified range of ventilation 2441 * settings. 0 means no ventilation. The value must be non-negative. Larger values indicate 2442 * stronger ventilation. 2443 * 2444 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 2445 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 2446 * all areaIds. 2447 * 2448 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} is 0. 2449 * 2450 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 2451 * maximum ventilation setting available for the seat. 2452 * 2453 * <p>Property Config: 2454 * <ul> 2455 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2456 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2457 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2458 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2459 * <li>{@code Integer} property type 2460 * </ul> 2461 * 2462 * <p>Required Permission: 2463 * <ul> 2464 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2465 * and write property. 2466 * </ul> 2467 */ 2468 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2469 public static final int HVAC_SEAT_VENTILATION = 356517139; 2470 /** 2471 * ELECTRIC DEFROSTER. 2472 * 2473 * <p>Property Config: 2474 * <ul> 2475 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2476 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2477 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WINDOW} 2478 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2479 * <li>{@code Boolean} property type 2480 * </ul> 2481 * 2482 * <p>Required Permission: 2483 * <ul> 2484 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_CLIMATE} to read 2485 * and write property. 2486 * </ul> 2487 */ 2488 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 2489 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_CLIMATE) 2490 public static final int HVAC_ELECTRIC_DEFROSTER_ON = 320865556; 2491 /** 2492 * Distance units for display. 2493 * 2494 * <p>Indicates which units the car is using to display distances to the user. 2495 * 2496 * <p>configArray represents the list of supported units for {@code 2497 * DISTANCE_DISPLAY_UNITS}. Here is an example configArray: 2498 * <ul> 2499 * <li>configArray[0] = {@link VehicleUnit#METER} 2500 * <li>configArray[1] = {@link VehicleUnit#KILOMETER} 2501 * <li>configArray[2] = {@link VehicleUnit#MILE} 2502 * </ul> 2503 * 2504 * <p>Property Config: 2505 * <ul> 2506 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2507 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2508 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2509 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2510 * <li>{@code Integer} property type 2511 * </ul> 2512 * 2513 * <p>Required Permissions: 2514 * <ul> 2515 * <li>Normal permission {@link Car#PERMISSION_READ_DISPLAY_UNITS} to read property. 2516 * <li>Normal permission {@link Car#PERMISSION_CONTROL_DISPLAY_UNITS} and Signature|Privileged 2517 * permission "android.car.permission.CAR_VENDOR_EXTENSION" to write property. 2518 * </ul> 2519 * 2520 * @data_enum {@link VehicleUnit} 2521 */ 2522 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DISPLAY_UNITS)) 2523 @RequiresPermission.Write(@RequiresPermission(allOf = {Car.PERMISSION_CONTROL_DISPLAY_UNITS, 2524 Car.PERMISSION_VENDOR_EXTENSION})) 2525 public static final int DISTANCE_DISPLAY_UNITS = 289408512; 2526 /** 2527 * Fuel volume units for display. 2528 * 2529 * <p>Indicates which units the car is using to display fuel volume to the user. 2530 * 2531 * <p>configArray represents the list of supported units for {@code 2532 * FUEL_VOLUME_DISPLAY_UNITS}. Here is an example configArray: 2533 * <ul> 2534 * <li>configArray[0] = {@link VehicleUnit#LITER} 2535 * <li>configArray[1] = {@link VehicleUnit#US_GALLON} 2536 * </ul> 2537 * 2538 * <p>Property Config: 2539 * <ul> 2540 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2541 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2542 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2543 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2544 * <li>{@code Integer} property type 2545 * </ul> 2546 * 2547 * <p>Required Permissions: 2548 * <ul> 2549 * <li>Normal permission {@link Car#PERMISSION_READ_DISPLAY_UNITS} to read property. 2550 * <li>Normal permission {@link Car#PERMISSION_CONTROL_DISPLAY_UNITS} and Signature|Privileged 2551 * permission "android.car.permission.CAR_VENDOR_EXTENSION" to write property. 2552 * </ul> 2553 * 2554 * @data_enum {@link VehicleUnit} 2555 */ 2556 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DISPLAY_UNITS)) 2557 @RequiresPermission.Write(@RequiresPermission(allOf = {Car.PERMISSION_CONTROL_DISPLAY_UNITS, 2558 Car.PERMISSION_VENDOR_EXTENSION})) 2559 public static final int FUEL_VOLUME_DISPLAY_UNITS = 289408513; 2560 /** 2561 * Tire pressure units for display. 2562 * 2563 * <p>Indicates which units the car is using to display tire pressure to the user. 2564 * 2565 * <p>configArray represents the list of supported units for {@code 2566 * TIRE_PRESSURE_DISPLAY_UNITS}. Here is an example configArray: 2567 * <ul> 2568 * <li>configArray[0] = {@link VehicleUnit#KILOPASCAL} 2569 * <li>configArray[1] = {@link VehicleUnit#PSI} 2570 * <li>configArray[2] = {@link VehicleUnit#BAR} 2571 * </ul> 2572 * 2573 * <p>Property Config: 2574 * <ul> 2575 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2576 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2577 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2578 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2579 * <li>{@code Integer} property type 2580 * </ul> 2581 * 2582 * <p>Required Permissions: 2583 * <ul> 2584 * <li>Normal permission {@link Car#PERMISSION_READ_DISPLAY_UNITS} to read property. 2585 * <li>Normal permission {@link Car#PERMISSION_CONTROL_DISPLAY_UNITS} and Signature|Privileged 2586 * permission "android.car.permission.CAR_VENDOR_EXTENSION" to write property. 2587 * </ul> 2588 * 2589 * @data_enum {@link VehicleUnit} 2590 */ 2591 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DISPLAY_UNITS)) 2592 @RequiresPermission.Write(@RequiresPermission(allOf = {Car.PERMISSION_CONTROL_DISPLAY_UNITS, 2593 Car.PERMISSION_VENDOR_EXTENSION})) 2594 public static final int TIRE_PRESSURE_DISPLAY_UNITS = 289408514; 2595 /** 2596 * EV battery units for display. 2597 * 2598 * <p>Indicates which units the vehicle is using to display EV battery information to the user. 2599 * 2600 * <p>configArray represents the list of supported units for {@code 2601 * EV_BATTERY_DISPLAY_UNITS}. Here is an example configArray: 2602 * <ul> 2603 * <li>configArray[0] = {@link VehicleUnit#WATT_HOUR} 2604 * <li>configArray[1] = {@link VehicleUnit#AMPERE_HOURS} 2605 * <li>configArray[2] = {@link VehicleUnit#KILOWATT_HOUR} 2606 * </ul> 2607 * 2608 * <p>Property Config: 2609 * <ul> 2610 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2611 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2612 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2613 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2614 * <li>{@code Integer} property type 2615 * </ul> 2616 * 2617 * <p>Required Permissions: 2618 * <ul> 2619 * <li>Normal permission {@link Car#PERMISSION_READ_DISPLAY_UNITS} to read property. 2620 * <li>Normal permission {@link Car#PERMISSION_CONTROL_DISPLAY_UNITS} and Signature|Privileged 2621 * permission "android.car.permission.CAR_VENDOR_EXTENSION" to write property. 2622 * </ul> 2623 * 2624 * @data_enum {@link VehicleUnit} 2625 */ 2626 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DISPLAY_UNITS)) 2627 @RequiresPermission.Write(@RequiresPermission(allOf = {Car.PERMISSION_CONTROL_DISPLAY_UNITS, 2628 Car.PERMISSION_VENDOR_EXTENSION})) 2629 public static final int EV_BATTERY_DISPLAY_UNITS = 289408515; 2630 /** 2631 * Speed units for display. 2632 * 2633 * <p>Indicates type of units the vehicle is using to display speed to user. 2634 * 2635 * <p>configArray represents the list of supported units for {@code 2636 * VEHICLE_SPEED_DISPLAY_UNITS}. Here is an example configArray: 2637 * <ul> 2638 * <li>configArray[0] = {@link VehicleUnit#METER_PER_SEC} 2639 * <li>configArray[1] = {@link VehicleUnit#MILES_PER_HOUR} 2640 * <li>configArray[2] = {@link VehicleUnit#KILOMETERS_PER_HOUR} 2641 * </ul> 2642 * 2643 * <p>Property Config: 2644 * <ul> 2645 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2646 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2647 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2648 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2649 * <li>{@code Integer} property type 2650 * </ul> 2651 * 2652 * <p>Required Permissions: 2653 * <ul> 2654 * <li>Normal permission {@link Car#PERMISSION_READ_DISPLAY_UNITS} to read property. 2655 * <li>Normal permission {@link Car#PERMISSION_CONTROL_DISPLAY_UNITS} and Signature|Privileged 2656 * permission "android.car.permission.CAR_VENDOR_EXTENSION" to write property. 2657 * </ul> 2658 * 2659 * @data_enum {@link VehicleUnit} 2660 */ 2661 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DISPLAY_UNITS)) 2662 @RequiresPermission.Write(@RequiresPermission(allOf = {Car.PERMISSION_CONTROL_DISPLAY_UNITS, 2663 Car.PERMISSION_VENDOR_EXTENSION})) 2664 public static final int VEHICLE_SPEED_DISPLAY_UNITS = 289408516; 2665 /** 2666 * Fuel consumption units for display. 2667 * 2668 * <p>Indicates type of units the car is using to display fuel consumption information to user. 2669 * 2670 * <p>{@code true} indicates units are distance over volume such as MPG. 2671 * 2672 * <p>{@code false} indicates units are volume over distance such as L/100KM. 2673 * 2674 * <p>Property Config: 2675 * <ul> 2676 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2677 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2678 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2679 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2680 * <li>{@code Boolean} property type 2681 * </ul> 2682 * 2683 * <p>Required Permissions: 2684 * <ul> 2685 * <li>Normal permission {@link Car#PERMISSION_READ_DISPLAY_UNITS} to read property. 2686 * <li>Normal permission {@link Car#PERMISSION_CONTROL_DISPLAY_UNITS} and Signature|Privileged 2687 * permission "android.car.permission.CAR_VENDOR_EXTENSION" to write property. 2688 * </ul> 2689 */ 2690 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DISPLAY_UNITS)) 2691 @RequiresPermission.Write(@RequiresPermission(allOf = {Car.PERMISSION_CONTROL_DISPLAY_UNITS, 2692 Car.PERMISSION_VENDOR_EXTENSION})) 2693 public static final int FUEL_CONSUMPTION_UNITS_DISTANCE_OVER_VOLUME = 287311364; 2694 /** 2695 * Outside temperature in celsius. 2696 * 2697 * <p>Property Config: 2698 * <ul> 2699 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2700 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2701 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 2702 * <li>{@code Float} property type 2703 * </ul> 2704 * 2705 * <p>Required Permission: 2706 * <ul> 2707 * <li>Normal permission {@link Car#PERMISSION_EXTERIOR_ENVIRONMENT} to read property. 2708 * <li>Property is not writable. 2709 * </ul> 2710 */ 2711 @RequiresPermission(Car.PERMISSION_EXTERIOR_ENVIRONMENT) 2712 public static final int ENV_OUTSIDE_TEMPERATURE = 291505923; 2713 /** 2714 * Property to control power state of application processor. 2715 * 2716 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 2717 * 2718 * <p>This property is not supported. 2719 * 2720 * @deprecated use {@link android.car.hardware.power.CarPowerManager} instead. 2721 */ 2722 @Deprecated 2723 @RequiresPermission(Car.PERMISSION_CAR_POWER) 2724 public static final int AP_POWER_STATE_REQ = 289475072; 2725 /** 2726 * Property to report power state of application processor. 2727 * 2728 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 2729 * 2730 * <p>This property is not supported. 2731 * 2732 * @deprecated use {@link android.car.hardware.power.CarPowerManager} instead. 2733 */ 2734 @Deprecated 2735 @RequiresPermission(Car.PERMISSION_CAR_POWER) 2736 public static final int AP_POWER_STATE_REPORT = 289475073; 2737 /** 2738 * Property to report bootup reason for the current power on. 2739 * 2740 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 2741 * 2742 * <p>This property is not supported. 2743 * 2744 * @deprecated use {@link android.car.hardware.power.CarPowerManager} instead. 2745 */ 2746 @Deprecated 2747 @RequiresPermission(Car.PERMISSION_CAR_POWER) 2748 public static final int AP_POWER_BOOTUP_REASON = 289409538; 2749 /** 2750 * Property to represent brightness of the display. 2751 * 2752 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 2753 * 2754 * <p>This property is not supported. 2755 * 2756 * @deprecated use {@link android.car.hardware.power.CarPowerManager} instead. 2757 */ 2758 @Deprecated 2759 @RequiresPermission(Car.PERMISSION_CAR_POWER) 2760 public static final int DISPLAY_BRIGHTNESS = 289409539; 2761 /** 2762 * Property to represent brightness of the displays which are controlled separately. 2763 * 2764 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 2765 * 2766 * <p>This property is not supported. 2767 * 2768 * @deprecated use {@link android.car.hardware.power.CarPowerManager} instead. 2769 */ 2770 @Deprecated 2771 @RequiresPermission(Car.PERMISSION_CAR_POWER) 2772 public static final int PER_DISPLAY_BRIGHTNESS = 289475076; 2773 /** 2774 * Valet mode enabled 2775 * 2776 * <p>This property allows the user to enable/disable valet mode in their vehicle. Valet mode is 2777 * a privacy and security setting that prevents an untrusted driver to access more private areas 2778 * in the vehicle, such as the glove box or the trunk(s). 2779 * 2780 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 2781 * only. 2782 * 2783 * <p>Property Config: 2784 * <ul> 2785 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2786 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2787 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 2788 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2789 * <li>{@code Boolean} property type 2790 * </ul> 2791 * 2792 * <p>Required Permissions: 2793 * <ul> 2794 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_VALET_MODE} or 2795 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_VALET_MODE} to read property. 2796 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_VALET_MODE} to write 2797 * property. 2798 * </ul> 2799 */ 2800 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 2801 @RequiresPermission.Read(@RequiresPermission( 2802 anyOf = {Car.PERMISSION_READ_VALET_MODE, Car.PERMISSION_CONTROL_VALET_MODE})) 2803 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_VALET_MODE)) 2804 public static final int VALET_MODE_ENABLED = 287312389; 2805 /** 2806 * Head up display (HUD) enabled 2807 * 2808 * <p>This property allows the user to turn on/off the HUD for their seat. 2809 * 2810 * <p>Each HUD in the vehicle will be assigned to the seat that is intended to use it. For 2811 * example, if there is a single HUD in the vehicle that is used by the driver so that they no 2812 * longer need to continuously look at the instrument cluster, then this property will be 2813 * defined with a single area ID that is equal to the driver's seat area ID. 2814 * 2815 * <p>Property Config: 2816 * <ul> 2817 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2818 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2819 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 2820 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2821 * <li>{@code Boolean} property type 2822 * </ul> 2823 * 2824 * <p>Required Permissions: 2825 * <ul> 2826 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_HEAD_UP_DISPLAY_STATUS} or 2827 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_HEAD_UP_DISPLAY} to read 2828 * property. 2829 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_HEAD_UP_DISPLAY} to write 2830 * property. 2831 * </ul> 2832 */ 2833 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 2834 @RequiresPermission.Read(@RequiresPermission( 2835 anyOf = {Car.PERMISSION_READ_HEAD_UP_DISPLAY_STATUS, 2836 Car.PERMISSION_CONTROL_HEAD_UP_DISPLAY})) 2837 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_HEAD_UP_DISPLAY)) 2838 public static final int HEAD_UP_DISPLAY_ENABLED = 354421254; 2839 /** 2840 * Property to feed H/W input events to android. 2841 * 2842 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 2843 * 2844 * <p>This property is not supported. 2845 * 2846 * @deprecated car service internal use only. 2847 */ 2848 @Deprecated 2849 public static final int HW_KEY_INPUT = 289475088; 2850 /** 2851 * Door position. 2852 * 2853 * <p>This property is not in any particular unit but in a specified range of relative 2854 * positions. 2855 * 2856 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 2857 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 2858 * all areaIds. 2859 * 2860 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} is 0. It 2861 * indicates the door is closed. 2862 * 2863 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 2864 * door is fully open. 2865 * 2866 * <p>All integers between the min and max values are supported and indicate a transition state 2867 * between the closed and fully open positions. 2868 * 2869 * <p>Property Config: 2870 * <ul> 2871 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2872 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2873 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_DOOR} 2874 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2875 * <li>{@code Integer} property type 2876 * </ul> 2877 * 2878 * <p>Required Permission: 2879 * <ul> 2880 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_DOORS} to read and 2881 * write property. 2882 * </ul> 2883 */ 2884 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_DOORS) 2885 public static final int DOOR_POS = 373295872; 2886 /** 2887 * Door move. 2888 * 2889 * <p>This property is not in any particular unit but in a specified range of relative movement 2890 * speeds. 2891 * 2892 * <p>Positive values mean the door is opening and negative values mean the door is closing. 2893 * Larger integers, either positive or negative, indicate a faster speed. Once the door reaches 2894 * the positional limit, the value resets to 0. When this property's value is 0, that means 2895 * there is no movement currently occurring. 2896 * 2897 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 2898 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 2899 * all areaIds. 2900 * 2901 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} indicates the 2902 * maximum movement speed of the door while closing. 2903 * 2904 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 2905 * maximum movement speed of the door while opening. 2906 * 2907 * <p>Property Config: 2908 * <ul> 2909 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2910 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2911 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_DOOR} 2912 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2913 * <li>{@code Integer} property type 2914 * </ul> 2915 * 2916 * <p>Required Permission: 2917 * <ul> 2918 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_DOORS} to read and 2919 * write property. 2920 * </ul> 2921 */ 2922 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_DOORS) 2923 public static final int DOOR_MOVE = 373295873; 2924 /** 2925 * Door lock. 2926 * 2927 * <p>True indicates that the door is locked. 2928 * 2929 * <p>Property Config: 2930 * <ul> 2931 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2932 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2933 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_DOOR} 2934 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2935 * <li>{@code Boolean} property type 2936 * </ul> 2937 * 2938 * <p>Required Permission: 2939 * <ul> 2940 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_DOORS} to read and 2941 * write property. 2942 * </ul> 2943 */ 2944 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_DOORS) 2945 public static final int DOOR_LOCK = 371198722; 2946 /** 2947 * Door child lock feature enabled. 2948 * 2949 * <p>Returns true if the door child lock feature is enabled and false if it is disabled. 2950 * If enabled, the door is unable to be opened from the inside. 2951 * 2952 * <p>Property Config: 2953 * <ul> 2954 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2955 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2956 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_DOOR} 2957 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2958 * <li>{@code Boolean} property type 2959 * </ul> 2960 * 2961 * <p>Required Permission: 2962 * <ul> 2963 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_DOORS} to read 2964 * and write property. 2965 * </ul> 2966 */ 2967 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 2968 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_DOORS) 2969 public static final int DOOR_CHILD_LOCK_ENABLED = 371198723; 2970 /** 2971 * Mirror Z Position. 2972 * 2973 * <p>This property is not in any particular unit but in a specified range of relative 2974 * positions. 2975 * 2976 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 2977 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 2978 * all areaIds. 2979 * 2980 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} indicates the 2981 * mirror is tilted completely downwards. This must be a non-positive value. 2982 * 2983 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 2984 * mirror is tilted completely upwards. This must be a non-negative value. 2985 * 2986 * <p>0 indicates the mirror is not tilted in either direction. 2987 * 2988 * <p>All integers between the min and max values are supported and indicate a transition state 2989 * between the completely downwards and completely upwards positions. 2990 * 2991 * <p>Property Config: 2992 * <ul> 2993 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 2994 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 2995 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_MIRROR} 2996 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 2997 * <li>{@code Integer} property type 2998 * </ul> 2999 * 3000 * <p>Required Permission: 3001 * <ul> 3002 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_MIRRORS} to read and 3003 * write property. 3004 * </ul> 3005 */ 3006 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_MIRRORS) 3007 public static final int MIRROR_Z_POS = 339741504; 3008 /** 3009 * Mirror Z Move. 3010 * 3011 * <p>This property is not in any particular unit but in a specified range of relative movement 3012 * speeds. 3013 * 3014 * <p>Positive values mean the mirror is tilting up and negative values mean the mirror is 3015 * tilting down. Larger integers, either positive or negative, indicate a faster speed. Once the 3016 * mirror reaches the positional limit, the value resets to 0. When this property's value is 0, 3017 * that means there is no movement currently occurring. 3018 * 3019 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3020 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3021 * all areaIds. 3022 * 3023 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} represents the 3024 * maximum movement speed of the mirror while tilting downwards. 3025 * 3026 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3027 * maximum movement speed of the mirror while tilting upwards. 3028 * 3029 * <p>All integers between min and max value are supported. 3030 * 3031 * <p>Property Config: 3032 * <ul> 3033 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3034 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3035 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_MIRROR} 3036 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3037 * <li>{@code Integer} property type 3038 * </ul> 3039 * 3040 * <p>Required Permission: 3041 * <ul> 3042 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_MIRRORS} to read and 3043 * write property. 3044 * </ul> 3045 */ 3046 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_MIRRORS) 3047 public static final int MIRROR_Z_MOVE = 339741505; 3048 /** 3049 * Mirror Y Position. 3050 * 3051 * <p>This property is not in any particular unit but in a specified range of relative 3052 * positions. 3053 * 3054 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3055 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3056 * all areaIds. 3057 * 3058 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} indicates the 3059 * mirror is tilted completely to the left. This must be a non-positive value. 3060 * 3061 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 3062 * mirror is tilted completely to the right. This must be a non-negative value. 3063 * 3064 * <p>0 indicates the mirror is not tilted in either direction. 3065 * 3066 * <p>All integers between the min and max values are supported and indicate a transition state 3067 * between the extreme left and extreme right positions. 3068 * 3069 * <p>Property Config: 3070 * <ul> 3071 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3072 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3073 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_MIRROR} 3074 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3075 * <li>{@code Integer} property type 3076 * </ul> 3077 * 3078 * <p>Required Permission: 3079 * <ul> 3080 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_MIRRORS} to read and 3081 * write property. 3082 * </ul> 3083 */ 3084 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_MIRRORS) 3085 public static final int MIRROR_Y_POS = 339741506; 3086 /** 3087 * Mirror Y Move. 3088 * 3089 * <p>This property is not in any particular unit but in a specified range of relative movement 3090 * speeds. 3091 * 3092 * <p>Positive values mean the mirror is tilting to the right and negative values mean the 3093 * support is tilting to the left. Larger integers, either positive or negative, indicate a 3094 * faster speed. Once the mirror reaches the positional limit, the value resets to 0. When this 3095 * property's value is 0, that means there is no movement currently occurring. 3096 * 3097 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3098 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3099 * all areaIds. 3100 * 3101 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} represents the 3102 * maximum movement speed of the mirror while tilting left. 3103 * 3104 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3105 * maximum movement speed of the mirror while tilting right. 3106 * 3107 * <p>Property Config: 3108 * <ul> 3109 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3110 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3111 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_MIRROR} 3112 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3113 * <li>{@code Integer} property type 3114 * </ul> 3115 * 3116 * <p>Required Permission: 3117 * <ul> 3118 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_MIRRORS} to read and 3119 * write property. 3120 * </ul> 3121 */ 3122 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_MIRRORS) 3123 public static final int MIRROR_Y_MOVE = 339741507; 3124 /** 3125 * Mirror Lock. 3126 * 3127 * <p>True indicates all mirror positions are locked and not changeable. 3128 * 3129 * <p>Property Config: 3130 * <ul> 3131 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3132 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3133 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 3134 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3135 * <li>{@code Boolean} property type 3136 * </ul> 3137 * 3138 * <p>Required Permission: 3139 * <ul> 3140 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_MIRRORS} to read and 3141 * write property. 3142 * </ul> 3143 */ 3144 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_MIRRORS) 3145 public static final int MIRROR_LOCK = 287312708; 3146 /** 3147 * Mirror Fold. 3148 * 3149 * <p>Property Config: 3150 * <ul> 3151 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3152 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3153 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 3154 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3155 * <li>{@code Boolean} property type 3156 * </ul> 3157 * 3158 * <p>Required Permission: 3159 * <ul> 3160 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_MIRRORS} to read and 3161 * write property. 3162 * </ul> 3163 */ 3164 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_MIRRORS) 3165 public static final int MIRROR_FOLD = 287312709; 3166 /** 3167 * Represents property for the Mirror Auto Fold feature. 3168 * 3169 * <p>This property is true when the feature for automatically folding the vehicle's mirrors 3170 * (for example, when the mirrors fold inward automatically when one exits and locks the 3171 * vehicle) is enabled. 3172 * 3173 * <p>Property Config: 3174 * <ul> 3175 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3176 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3177 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_MIRROR} 3178 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3179 * <li>{@code Boolean} property type 3180 * </ul> 3181 * 3182 * <p>Required Permission: 3183 * <ul> 3184 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_MIRRORS} to read and 3185 * write property. 3186 */ 3187 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 3188 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_MIRRORS) 3189 public static final int MIRROR_AUTO_FOLD_ENABLED = 337644358; 3190 /** 3191 * Represents property for the Mirror Auto Tilt feature. 3192 * 3193 * <p>This property is true when the feature for automatically tilting the vehicle's mirrors 3194 * (for example, when the mirrors tilt downward automatically when one reverses the vehicle) is 3195 * enabled. 3196 * 3197 * <p>Property Config: 3198 * <ul> 3199 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3200 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3201 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_MIRROR} 3202 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3203 * <li>{@code Boolean} property type 3204 * </ul> 3205 * 3206 * <p>Required Permission: 3207 * <ul> 3208 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_MIRRORS} to read and 3209 * write property. 3210 * </ul> 3211 */ 3212 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 3213 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_MIRRORS) 3214 public static final int MIRROR_AUTO_TILT_ENABLED = 337644359; 3215 /** 3216 * Property that represents the current position of the glove box door. 3217 * 3218 * <p>This property is not in any particular unit but in a specified range of relative 3219 * positions. 3220 * 3221 * <p>{@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the glove box's 3222 * position when closed. This value will be 0. 3223 * <p>{@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the glove box's 3224 * position when fully open. 3225 * 3226 * <p>All integers between the min and max values are supported and indicate a transition state 3227 * between the closed and fully open positions. 3228 * 3229 * <p>The supported area IDs match the seat(s) by which the glove box is intended to be used 3230 * (e.g.) if the front right dashboard has a glove box embedded in it, then the area ID should 3231 * be {@link VehicleAreaSeat#SEAT_ROW_1_RIGHT}). 3232 * 3233 * <p>Property Config: 3234 * <ul> 3235 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3236 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3237 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3238 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3239 * <li>{@code Integer} property type 3240 * </ul> 3241 * 3242 * <p>Required Permission: 3243 * <ul> 3244 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_GLOVE_BOX} to read and 3245 * write property. 3246 * </ul> 3247 */ 3248 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 3249 @RequiresPermission(Car.PERMISSION_CONTROL_GLOVE_BOX) 3250 public static final int GLOVE_BOX_DOOR_POS = 356518896; 3251 3252 /** 3253 * Lock or unlock the glove box. 3254 * 3255 * <p>If {@code true}, the glove box is locked. If {@code false}, the glove box is unlocked. 3256 * 3257 * <p>The supported area IDs match the seat(s) by which the glove box is intended to be used 3258 * (e.g. if the front right dashboard has a glove box embedded in it, then the area ID will be 3259 * {@link android.car.VehicleAreaSeat#SEAT_ROW_1_RIGHT}). 3260 * 3261 * <p>Property Config: 3262 * <ul> 3263 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3264 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3265 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3266 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3267 * <li>{@code Boolean} property type 3268 * </ul> 3269 * 3270 * <p>Required Permission: 3271 * <ul> 3272 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_GLOVE_BOX} to read and 3273 * write property. 3274 * </ul> 3275 */ 3276 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 3277 @RequiresPermission(Car.PERMISSION_CONTROL_GLOVE_BOX) 3278 public static final int GLOVE_BOX_LOCKED = 354421745; 3279 3280 /** 3281 * Seat memory select. 3282 * 3283 * <p>This parameter selects the memory preset to use to select the seat position. 3284 * 3285 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3286 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3287 * all areaIds. 3288 * 3289 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} is always 0. 3290 * 3291 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3292 * max memory preset that can be chosen. For instance, if the driver's seat has 3 memory 3293 * presets, the max value will be 2. When the user wants to select a preset, the desired preset 3294 * number (0, 1, or 2) is set. 3295 * 3296 * <p>Property Config: 3297 * <ul> 3298 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 3299 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3300 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3301 * <li>{@code Integer} property type 3302 * </ul> 3303 * 3304 * <p>Required Permission: 3305 * <ul> 3306 * <li>Property is not readable. 3307 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to write 3308 * property. 3309 * </ul> 3310 */ 3311 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3312 public static final int SEAT_MEMORY_SELECT = 356518784; 3313 /** 3314 * Seat memory set. 3315 * 3316 * <p>This setting allows the user to save the current seat position settings into the selected 3317 * preset slot. The {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} for each 3318 * seat position must match the {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} 3319 * for {@link #SEAT_MEMORY_SELECT}. 3320 * 3321 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3322 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3323 * all areaIds. 3324 * 3325 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} is always 0. 3326 * 3327 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3328 * max memory preset that can be chosen. For instance, if the driver's seat has 3 memory 3329 * presets, the max value will be 2. When the user wants to select a preset, the desired preset 3330 * number (0, 1, or 2) is set. 3331 * 3332 * <p>Property Config: 3333 * <ul> 3334 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 3335 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3336 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3337 * <li>{@code Integer} property type 3338 * </ul> 3339 * 3340 * <p>Required Permission: 3341 * <ul> 3342 * <li>Property is not readable. 3343 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to write 3344 * property. 3345 * </ul> 3346 */ 3347 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3348 public static final int SEAT_MEMORY_SET = 356518785; 3349 /** 3350 * Seatbelt buckled. 3351 * 3352 * <p>True indicates belt is buckled. 3353 * 3354 * <p>Property Config: 3355 * <ul> 3356 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3357 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3358 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3359 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3360 * <li>{@code Boolean} property type 3361 * </ul> 3362 * 3363 * <p>Required Permission: 3364 * <ul> 3365 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3366 * write property. 3367 * </ul> 3368 */ 3369 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3370 public static final int SEAT_BELT_BUCKLED = 354421634; 3371 /** 3372 * Seatbelt height position. 3373 * 3374 * <p>This property is not in any particular unit but in a specified range of relative 3375 * positions. 3376 * 3377 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3378 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3379 * all areaIds. 3380 * 3381 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} indicates the 3382 * seat belt's shoulder anchor is at its lowest position. 3383 * 3384 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 3385 * seat belt's shoulder anchor is at its highest position. 3386 * 3387 * <p>All integers between the min and max values are supported and indicate a transition state 3388 * between the lowest and highest positions. 3389 * 3390 * <p>Property Config: 3391 * <ul> 3392 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3393 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3394 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3395 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3396 * <li>{@code Integer} property type 3397 * </ul> 3398 * 3399 * <p>Required Permission: 3400 * <ul> 3401 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3402 * write property. 3403 * </ul> 3404 */ 3405 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3406 public static final int SEAT_BELT_HEIGHT_POS = 356518787; 3407 /** 3408 * Seatbelt height move. 3409 * 3410 * <p>This property is not in any particular unit but in a specified range of relative movement 3411 * speeds. 3412 * 3413 * <p>Positive values mean the seat belt's shoulder anchor is moving up and negative values mean 3414 * the seat belt's shoulder anchor is moving down. Larger integers, either positive or negative, 3415 * indicate a faster speed. Once the seat belt's shoulder anchor reaches the positional limit, 3416 * the value resets to 0. When this property's value is 0, that means there is no movement 3417 * currently occurring. 3418 * 3419 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3420 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3421 * all areaIds. 3422 * 3423 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} represents the 3424 * maximum movement speed of the seat belt's shoulder anchor while moving downwards. 3425 * 3426 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3427 * maximum movement speed of the seat belt's shoulder anchor while moving upwards. 3428 * 3429 * <p>Property Config: 3430 * <ul> 3431 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3432 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3433 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3434 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3435 * <li>{@code Integer} property type 3436 * </ul> 3437 * 3438 * <p>Required Permission: 3439 * <ul> 3440 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3441 * write property. 3442 * </ul> 3443 */ 3444 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3445 public static final int SEAT_BELT_HEIGHT_MOVE = 356518788; 3446 /** 3447 * Seat fore/aft position. 3448 * 3449 * <p>This property is not in any particular unit but in a specified range of relative 3450 * positions. 3451 * 3452 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3453 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3454 * all areaIds. 3455 * 3456 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} indicates the 3457 * seat is at its rearward-most linear position. 3458 * 3459 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 3460 * seat is at its forward-most linear position. 3461 * 3462 * <p>All integers between the min and max values are supported and indicate a transition state 3463 * between the forward most and rearward most positions. 3464 * 3465 * <p>Property Config: 3466 * <ul> 3467 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3468 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3469 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3470 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3471 * <li>{@code Integer} property type 3472 * </ul> 3473 * 3474 * <p>Required Permission: 3475 * <ul> 3476 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3477 * write property. 3478 * </ul> 3479 */ 3480 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3481 public static final int SEAT_FORE_AFT_POS = 356518789; 3482 /** 3483 * Seat fore/aft move. 3484 * 3485 * <p>This property moves the entire seat forward/backward in the direction it's facing. 3486 * 3487 * <p>This property is not in any particular unit but in a specified range of relative movement 3488 * speeds. 3489 * 3490 * <p>Positive values mean the seat is moving forward and negative values mean the seat is 3491 * moving backward. Larger integers, either positive or negative, indicate a faster speed. Once 3492 * the seat reaches the positional limit, the value resets to 0. When this property's value is 3493 * 0, that means there is no movement currently occurring. 3494 * 3495 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3496 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3497 * all areaIds. 3498 * 3499 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} represents the 3500 * maximum movement speed of the seat while moving backward. 3501 * 3502 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3503 * maximum movement speed of the seat while moving forward. 3504 * 3505 * <p>Property Config: 3506 * <ul> 3507 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3508 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3509 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3510 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3511 * <li>{@code Integer} property type 3512 * </ul> 3513 * 3514 * <p>Required Permission: 3515 * <ul> 3516 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3517 * write property. 3518 * </ul> 3519 */ 3520 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3521 public static final int SEAT_FORE_AFT_MOVE = 356518790; 3522 /** 3523 * Seat backrest angle 1 position. 3524 * 3525 * <p>This property is not in any particular unit but in a specified range of relative 3526 * positions. 3527 * 3528 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3529 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3530 * all areaIds. 3531 * 3532 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} indicates the 3533 * seat backrest's full recline position w.r.t the actuator at the bottom of the seat (see 3534 * {@link #SEAT_BACKREST_ANGLE_1_MOVE} for additional details). 3535 * 3536 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 3537 * seat backrest's most upright/forward position w.r.t the actuator at the bottom of the seat 3538 * (see {@link #SEAT_BACKREST_ANGLE_1_MOVE} for additional details). 3539 * 3540 * <p>All integers between the min and max values are supported and indicate a transition state 3541 * between the forward most and rearward most positions. 3542 * 3543 * <p>Property Config: 3544 * <ul> 3545 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3546 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3547 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3548 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3549 * <li>{@code Integer} property type 3550 * </ul> 3551 * 3552 * <p>Required Permission: 3553 * <ul> 3554 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3555 * write property. 3556 * </ul> 3557 */ 3558 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3559 public static final int SEAT_BACKREST_ANGLE_1_POS = 356518791; 3560 /** 3561 * Seat backrest angle 1 move. 3562 * 3563 * <p>This property moves the seat backrest along the axis of rotation defined by the actuator 3564 * closest to the bottom of the seat. This is the actuator that moves the seat upright/forward 3565 * or into recline as seen in most conventional vehicles. 3566 * 3567 * <p>This property is not in any particular unit but in a specified range of relative movement 3568 * speeds. 3569 * 3570 * <p>Positive values mean the seat is angling forward and negative values mean the seat is 3571 * reclining backward. Larger integers, either positive or negative, indicate a faster speed. 3572 * Once the seat reaches the positional limit, the value resets to 0. When this property's value 3573 * is 0, that means there is no movement currently occurring. 3574 * 3575 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3576 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3577 * all areaIds. 3578 * 3579 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} represents the 3580 * maximum movement speed of the seat backrest while reclining. 3581 * 3582 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3583 * maximum movement speed of the seat backrest while angling forward. 3584 * 3585 * <p>Property Config: 3586 * <ul> 3587 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3588 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3589 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3590 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3591 * <li>{@code Integer} property type 3592 * </ul> 3593 * 3594 * <p>Required Permission: 3595 * <ul> 3596 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3597 * write property. 3598 * </ul> 3599 */ 3600 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3601 public static final int SEAT_BACKREST_ANGLE_1_MOVE = 356518792; 3602 /** 3603 * Seat backrest angle 2 position. 3604 * 3605 * <p>This property is not in any particular unit but in a specified range of relative 3606 * positions. 3607 * 3608 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3609 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3610 * all areaIds. 3611 * 3612 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} indicates the 3613 * seat backrest's full recline position w.r.t the next actuator in the backrest from the one at 3614 * the bottom of the seat (see {@link #SEAT_BACKREST_ANGLE_2_MOVE} for more details). 3615 * 3616 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 3617 * seat backrest's most upright/forward position w.r.t the next actuator in the backrest from 3618 * the one at the bottom of the seat (see {@link #SEAT_BACKREST_ANGLE_2_MOVE} for more details). 3619 * 3620 * <p>All integers between the min and max values are supported and indicate a transition state 3621 * between the forward most and rearward most positions. 3622 * 3623 * <p>Property Config: 3624 * <ul> 3625 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3626 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3627 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3628 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3629 * <li>{@code Integer} property type 3630 * </ul> 3631 * 3632 * <p>Required Permission: 3633 * <ul> 3634 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3635 * write property. 3636 * </ul> 3637 */ 3638 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3639 public static final int SEAT_BACKREST_ANGLE_2_POS = 356518793; 3640 /** 3641 * Seat backrest angle 2 move. 3642 * 3643 * <p>This property will be implemented if there exists an additional actuator in the seat 3644 * backrest besides the one at the very bottom of the backrest, which is covered by {@link 3645 * #SEAT_BACKREST_ANGLE_1_MOVE}. This property will move the backrest along the axis of rotation 3646 * defined by this additional actuator. It can be assumed that this actuator is closer to the 3647 * headrest than the one defined by {@link #SEAT_BACKREST_ANGLE_1_MOVE}. 3648 * 3649 * <p>This property is not in any particular unit but in a specified range of relative movement 3650 * speeds. 3651 * 3652 * <p>Positive values mean the seat is angling forward and negative values mean the seat is 3653 * reclining backward. Larger integers, either positive or negative, indicate a faster speed. 3654 * Once the seat reaches the positional limit, the value resets to 0. When this property's value 3655 * is 0, that means there is no movement currently occurring. 3656 * 3657 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3658 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3659 * all areaIds. 3660 * 3661 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} represents the 3662 * maximum movement speed of the seat backrest while reclining. 3663 * 3664 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3665 * maximum movement speed of the seat backrest while angling forward. 3666 * 3667 * <p>Property Config: 3668 * <ul> 3669 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3670 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3671 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3672 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3673 * <li>{@code Integer} property type 3674 * </ul> 3675 * 3676 * <p>Required Permission: 3677 * <ul> 3678 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3679 * write property. 3680 * </ul> 3681 */ 3682 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3683 public static final int SEAT_BACKREST_ANGLE_2_MOVE = 356518794; 3684 /** 3685 * Seat height position. 3686 * 3687 * <p>This property is not in any particular unit but in a specified range of relative 3688 * positions. 3689 * 3690 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3691 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3692 * all areaIds. 3693 * 3694 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} indicates the 3695 * seat is in its lowest position. 3696 * 3697 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 3698 * seat is in its highest position. 3699 * 3700 * <p>All integers between the min and max values are supported and indicate a transition state 3701 * between the lowest and highest positions. 3702 * 3703 * <p>Property Config: 3704 * <ul> 3705 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3706 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3707 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3708 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3709 * <li>{@code Integer} property type 3710 * </ul> 3711 * 3712 * <p>Required Permission: 3713 * <ul> 3714 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3715 * write property. 3716 * </ul> 3717 */ 3718 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3719 public static final int SEAT_HEIGHT_POS = 356518795; 3720 /** 3721 * Seat height move. 3722 * 3723 * <p>This property is not in any particular unit but in a specified range of relative movement 3724 * speeds. 3725 * 3726 * <p>Positive values mean the seat is moving up and negative values mean the seat is moving 3727 * down. Larger integers, either positive or negative, indicate a faster speed. Once the seat 3728 * reaches the positional limit, the value resets to 0. When this property's value is 0, that 3729 * means there is no movement currently occurring. 3730 * 3731 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3732 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3733 * all areaIds. 3734 * 3735 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} represents the 3736 * maximum movement speed of the seat while moving downward. 3737 * 3738 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3739 * maximum movement speed of the seat while moving upward. 3740 * 3741 * <p>Property Config: 3742 * <ul> 3743 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3744 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3745 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3746 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3747 * <li>{@code Integer} property type 3748 * </ul> 3749 * 3750 * <p>Required Permission: 3751 * <ul> 3752 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3753 * write property. 3754 * </ul> 3755 */ 3756 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3757 public static final int SEAT_HEIGHT_MOVE = 356518796; 3758 /** 3759 * Seat depth position. 3760 * 3761 * <p>This property is not in any particular unit but in a specified range of relative 3762 * positions. 3763 * 3764 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3765 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3766 * all areaIds. 3767 * 3768 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} indicates the 3769 * seat is in its shallowest position (i.e. the position with the smallest distance between the 3770 * front edge of the seat cushion and the rear end of the seat). 3771 * 3772 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 3773 * seat is in its deepest position (i.e. the position with the largest distance between the 3774 * front edge of the seat cushion and the rear end of the seat). 3775 * 3776 * <p>All integers between the min and max values are supported and indicate a transition state 3777 * between the shallowest and deepest positions. 3778 * 3779 * <p>Property Config: 3780 * <ul> 3781 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3782 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3783 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3784 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3785 * <li>{@code Integer} property type 3786 * </ul> 3787 * 3788 * <p>Required Permission: 3789 * <ul> 3790 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3791 * write property. 3792 * </ul> 3793 */ 3794 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3795 public static final int SEAT_DEPTH_POS = 356518797; 3796 /** 3797 * Seat depth move. 3798 * 3799 * <p>This property is not in any particular unit but in a specified range of relative movement 3800 * speeds. 3801 * 3802 * <p>Positive values mean the distance between the seat's front edge and the back of the seat 3803 * is increasing, thus making the seat deeper. Negative values mean the distance between the 3804 * seat's front edge and the back of the seat is decreasing, thus making the seat shallower. 3805 * Larger integers, either positive or negative, indicate a faster speed. Once the seat depth 3806 * reaches its limit, the value resets to 0. When this property's value is 0, that means there 3807 * is no movement currently occurring. 3808 * 3809 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3810 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3811 * all areaIds. 3812 * 3813 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} represents the 3814 * maximum movement speed of the seat while getting shallower. 3815 * 3816 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3817 * maximum movement speed of the seat while getting deeper. 3818 * 3819 * <p>Property Config: 3820 * <ul> 3821 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3822 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3823 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3824 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3825 * <li>{@code Integer} property type 3826 * </ul> 3827 * 3828 * <p>Required Permission: 3829 * <ul> 3830 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3831 * write property. 3832 * </ul> 3833 */ 3834 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3835 public static final int SEAT_DEPTH_MOVE = 356518798; 3836 /** 3837 * Seat tilt position. 3838 * 3839 * <p>This property is not in any particular unit but in a specified range of relative 3840 * positions. 3841 * 3842 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3843 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3844 * all areaIds. 3845 * 3846 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} indicates the 3847 * seat bottom is angled at its lowest angular position. This corresponds to the seat's front 3848 * edge at its lowest possible position relative to the rear end of the seat. 3849 * 3850 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} indicates the 3851 * seat bottom is angled at its highest angular position. This corresponds to the seat's front 3852 * edge at its highest possible position relative to the rear end of the seat. 3853 * 3854 * <p>All integers between the min and max values are supported and indicate a transition state 3855 * between the lowest and highest positions. 3856 * 3857 * <p>Property Config: 3858 * <ul> 3859 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3860 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3861 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3862 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3863 * <li>{@code Integer} property type 3864 * </ul> 3865 * 3866 * <p>Required Permission: 3867 * <ul> 3868 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3869 * write property. 3870 * </ul> 3871 */ 3872 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3873 public static final int SEAT_TILT_POS = 356518799; 3874 /** 3875 * Seat tilt move. 3876 * 3877 * <p>This property is not in any particular unit but in a specified range of relative movement 3878 * speeds. 3879 * 3880 * <p>Positive values mean the seat cushion is tilting upward such that the seat cushion's front 3881 * edge is higher than the rear end of the seat cushion. Negative values mean the seat cushion 3882 * is tilting downward such that the seat cushion's front edge is lower than the rear end of the 3883 * seat cushion. Larger integers, either positive or negative, indicate a faster speed. Once the 3884 * seat cushion reaches the positional limit, the value resets to 0. When this property's value 3885 * is 0, that means there is no movement currently occurring. 3886 * 3887 * <p>{@link android.car.hardware.property.AreaIdConfig#hasMinSupportedValue()} and {@link 3888 * android.car.hardware.property.AreaIdConfig#hasMaxSupportedValue()} will be {@code true} for 3889 * all areaIds. 3890 * 3891 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMinValue()} represents the 3892 * maximum movement speed of the front edge of the seat while moving downward. 3893 * 3894 * <p>{@link android.car.hardware.property.MinMaxSupportedValue#getMaxValue()} represents the 3895 * maximum movement speed of the front edge of the seat while moving upward. 3896 * 3897 * <p>Property Config: 3898 * <ul> 3899 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3900 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3901 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3902 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3903 * <li>{@code Integer} property type 3904 * </ul> 3905 * 3906 * <p>Required Permission: 3907 * <ul> 3908 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3909 * write property. 3910 * </ul> 3911 */ 3912 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3913 public static final int SEAT_TILT_MOVE = 356518800; 3914 /** 3915 * Lumber fore/aft position. 3916 * 3917 * <p>This property is not in any particular unit but in a specified range of relative 3918 * positions. 3919 * 3920 * <p>{@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the seat lumbar 3921 * support's rearward most position (i.e. least supportive position). 3922 * <p>{@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the seat lumbar 3923 * support's forward most position (i.e. most supportive position). 3924 * 3925 * <p>All integers between the min and max values are supported and indicate a transition state 3926 * between the forward most and rearward most positions. 3927 * 3928 * <p>Property Config: 3929 * <ul> 3930 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3931 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3932 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3933 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3934 * <li>{@code Integer} property type 3935 * </ul> 3936 * 3937 * <p>Required Permission: 3938 * <ul> 3939 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3940 * write property. 3941 * </ul> 3942 */ 3943 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3944 public static final int SEAT_LUMBAR_FORE_AFT_POS = 356518801; 3945 /** 3946 * Lumbar fore/aft move. 3947 * 3948 * <p>This property is not in any particular unit but in a specified range of relative movement 3949 * speeds. 3950 * 3951 * <p>Positive values mean the lumbar support is moving forward towards the front of the seat 3952 * and negative values mean the lumbar support is moving backward away from the front of the 3953 * seat. Larger integers, either positive or negative, indicate a faster speed. Once the lumbar 3954 * support reaches the positional limit, the value resets to 0. When this property's value is 0, 3955 * that means there is no movement currently occurring. 3956 * 3957 * <p>See {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} and {@link 3958 * android.car.hardware.property.AreaIdConfig#getMinValue()} for the range of possible speeds. 3959 * All integers between min and max value are supported. 3960 * 3961 * <p>Property Config: 3962 * <ul> 3963 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3964 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3965 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3966 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3967 * <li>{@code Integer} property type 3968 * </ul> 3969 * 3970 * <p>Required Permission: 3971 * <ul> 3972 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 3973 * write property. 3974 * </ul> 3975 */ 3976 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 3977 public static final int SEAT_LUMBAR_FORE_AFT_MOVE = 356518802; 3978 /** 3979 * Lumbar side support position. 3980 * 3981 * <p>This property is not in any particular unit but in a specified range of relative 3982 * positions. 3983 * 3984 * <p>{@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the seat lumbar 3985 * side support's thinnest position (i.e most support). 3986 * <p>{@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the seat lumbar 3987 * side support's widest position (i.e least support). 3988 * 3989 * <p>All integers between the min and max values are supported and indicate a transition state 3990 * between the thinnest and widest positions. 3991 * 3992 * <p>Property Config: 3993 * <ul> 3994 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 3995 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 3996 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 3997 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 3998 * <li>{@code Integer} property type 3999 * </ul> 4000 * 4001 * <p>Required Permission: 4002 * <ul> 4003 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 4004 * write property. 4005 * </ul> 4006 */ 4007 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4008 public static final int SEAT_LUMBAR_SIDE_SUPPORT_POS = 356518803; 4009 /** 4010 * Lumbar side support move. 4011 * 4012 * <p>This property is not in any particular unit but in a specified range of relative movement 4013 * speeds. 4014 * 4015 * <p>Positive values mean the lumbar side support is getting wider (i.e. less support) and 4016 * negative values mean the lumbar side support is getting thinner (i.e. more support). Larger 4017 * integers, either positive or negative, indicate a faster speed. Once the lumbar side support 4018 * reaches the positional limit, the value resets to 0. When this property's value is 0, that 4019 * means there is no movement currently occurring. 4020 * 4021 * <p>See {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} and {@link 4022 * android.car.hardware.property.AreaIdConfig#getMinValue()} for the range of possible speeds. 4023 * All integers between min and max value are supported. 4024 * 4025 * <p>Property Config: 4026 * <ul> 4027 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4028 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4029 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4030 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4031 * <li>{@code Integer} property type 4032 * </ul> 4033 * 4034 * <p>Required Permission: 4035 * <ul> 4036 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 4037 * write property. 4038 * </ul> 4039 */ 4040 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4041 public static final int SEAT_LUMBAR_SIDE_SUPPORT_MOVE = 356518804; 4042 4043 /** 4044 * Headrest height position. 4045 * 4046 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 4047 * 4048 * <p>This property is not supported. 4049 * 4050 * @deprecated because it is defined as type {@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL}, 4051 * which means all seats use the same value. Use {@link #SEAT_HEADREST_HEIGHT_POS_V2} instead 4052 * which fixes this issue by being defined as type 4053 * {@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT}. 4054 */ 4055 @Deprecated 4056 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4057 public static final int SEAT_HEADREST_HEIGHT_POS = 289409941; 4058 4059 /** 4060 * Headrest height position. 4061 * 4062 * <p>This property is not in any particular unit but in a specified range of relative 4063 * positions. 4064 * 4065 * <p>The {@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the seat 4066 * headrest's shortest position. 4067 * <p>The {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the seat 4068 * headrest's tallest position. 4069 * 4070 * <p>All integers between the min and max values are supported and indicate a transition state 4071 * between the shortest and tallest positions. 4072 * 4073 * <p>{@link android.car.hardware.CarPropertyConfig#getAreaIds()} specifies which seats are 4074 * supported. 4075 * 4076 * <p>Property Config: 4077 * <ul> 4078 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4079 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4080 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4081 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4082 * <li>{@code Integer} property type 4083 * </ul> 4084 * 4085 * <p>Required Permission: 4086 * <ul> 4087 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read 4088 * and write property. 4089 * </ul> 4090 */ 4091 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4092 public static final int SEAT_HEADREST_HEIGHT_POS_V2 = 356518820; 4093 4094 /** 4095 * Headrest height move. 4096 * 4097 * <p>This property is not in any particular unit but in a specified range of relative movement 4098 * speeds. 4099 * 4100 * <p>Positive values mean the headrest is moving up and negative values mean the headrest is 4101 * moving down. Larger integers, either positive or negative, indicate a faster speed. Once the 4102 * headrest reaches the positional limit, the value resets to 0. When this property's value is 4103 * 0, that means there is no movement currently occurring. 4104 * 4105 * <p>See {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} and {@link 4106 * android.car.hardware.property.AreaIdConfig#getMinValue()} for the range of possible speeds. 4107 * All integers between min and max value are supported. 4108 * 4109 * <p>Property Config: 4110 * <ul> 4111 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4112 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4113 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4114 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4115 * <li>{@code Integer} property type 4116 * </ul> 4117 * 4118 * <p>Required Permission: 4119 * <ul> 4120 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read 4121 * and write property. 4122 * </ul> 4123 */ 4124 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4125 public static final int SEAT_HEADREST_HEIGHT_MOVE = 356518806; 4126 /** 4127 * Headrest angle position. 4128 * 4129 * <p>This property is not in any particular unit but in a specified range of relative 4130 * positions. 4131 * 4132 * <p>The {@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the seat 4133 * headrest's full recline position. 4134 * <p>The {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the seat 4135 * headrest's most upright/forward position. 4136 * 4137 * <p>All integers between the min and max values are supported and indicate a transition state 4138 * between the forward most and rearward most positions. 4139 * 4140 * <p>Property Config: 4141 * <ul> 4142 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4143 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4144 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4145 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4146 * <li>{@code Integer} property type 4147 * </ul> 4148 * 4149 * <p>Required Permission: 4150 * <ul> 4151 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read 4152 * and write property. 4153 * </ul> 4154 */ 4155 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4156 public static final int SEAT_HEADREST_ANGLE_POS = 356518807; 4157 /** 4158 * Headrest angle move. 4159 * 4160 * <p>This property is not in any particular unit but in a specified range of relative movement 4161 * speeds. 4162 * 4163 * <p>Positive values mean the headrest is moving upright/forward and negative values mean the 4164 * headrest is reclining. Larger integers, either positive or negative, indicate a faster speed. 4165 * Once the headrest reaches the positional limit, the value resets to 0. When this property's 4166 * value is 0, that means there is no movement currently occurring. 4167 * 4168 * <p>See {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} and {@link 4169 * android.car.hardware.property.AreaIdConfig#getMinValue()} for the range of possible speeds. 4170 * All integers between min and max value are supported. 4171 * 4172 * <p>Property Config: 4173 * <ul> 4174 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4175 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4176 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4177 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4178 * <li>{@code Integer} property type 4179 * </ul> 4180 * 4181 * <p>Required Permission: 4182 * <ul> 4183 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read 4184 * and write property. 4185 * </ul> 4186 */ 4187 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4188 public static final int SEAT_HEADREST_ANGLE_MOVE = 356518808; 4189 /** 4190 * Headrest fore/aft position. 4191 * 4192 * <p>This property is not in any particular unit but in a specified range of relative 4193 * positions. 4194 * 4195 * <p>The {@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the seat 4196 * headrest's rearward-most linear position. 4197 * <p>The {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the seat 4198 * headrest's forward-most linear position. 4199 * 4200 * <p>All integers between the min and max values are supported and indicate a transition state 4201 * between the forward most and rearward most positions. 4202 * 4203 * <p>Property Config: 4204 * <ul> 4205 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4206 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4207 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4208 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4209 * <li>{@code Integer} property type 4210 * </ul> 4211 * 4212 * <p>Required Permission: 4213 * <ul> 4214 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read 4215 * and write property. 4216 * </ul> 4217 */ 4218 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4219 public static final int SEAT_HEADREST_FORE_AFT_POS = 356518809; 4220 /** 4221 * Headrest fore/aft move. 4222 * 4223 * <p>This property is not in any particular unit but in a specified range of relative movement 4224 * speeds. 4225 * 4226 * <p>Positive values mean the headrest is moving forward towards the front of the seat and 4227 * negative values mean the headrest is moving backward away from the front of the seat. Larger 4228 * integers, either positive or negative, indicate a faster speed. Once the headrest reaches the 4229 * positional limit, the value resets to 0. When this property's value is 0, that means there is 4230 * no movement currently occurring. 4231 * 4232 * <p>See {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} and {@link 4233 * android.car.hardware.property.AreaIdConfig#getMinValue()} for the range of possible speeds. 4234 * All integers between min and max value are supported. 4235 * 4236 * <p>Property Config: 4237 * <ul> 4238 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4239 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4240 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4241 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4242 * <li>{@code Integer} property type 4243 * </ul> 4244 * 4245 * <p>Required Permission: 4246 * <ul> 4247 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read 4248 * and write property. 4249 * </ul> 4250 */ 4251 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4252 public static final int SEAT_HEADREST_FORE_AFT_MOVE = 356518810; 4253 /** 4254 * Represents property for state of the footwell lights. 4255 * 4256 * <p>{@code SEAT_FOOTWELL_LIGHTS_STATE} reflects the current state of the lights at any point 4257 * in time. This is different from the function of {@link #SEAT_FOOTWELL_LIGHTS_SWITCH} which 4258 * represents the position of the switch controlling the lights. Therefore, {@code 4259 * SEAT_FOOTWELL_LIGHTS_STATE} may not match the value of {@link #SEAT_FOOTWELL_LIGHTS_SWITCH} 4260 * (e.g. {@link #SEAT_FOOTWELL_LIGHTS_SWITCH}={@code VehicleLightSwitch#STATE_AUTOMATIC} and 4261 * {@code SEAT_FOOTWELL_LIGHTS_STATE}={@code VehicleLightState#STATE_ON}). 4262 * 4263 * <p>This property will only be implemented if {@code SEAT_FOOTWELL_LIGHTS_STATE}'s value may 4264 * be different from that of {@link #CABIN_LIGHTS_STATE}. 4265 * 4266 * <p>For each supported area ID, the {@link 4267 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} obtained from {@link 4268 * android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which enum values from 4269 * {@code VehicleLightState} are supported. 4270 * 4271 * <p>Property Config: 4272 * <ul> 4273 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4274 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4275 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4276 * <li>{@code Integer} property type 4277 * </ul> 4278 * 4279 * <p>Required Permission: 4280 * <ul> 4281 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_INTERIOR_LIGHTS} to 4282 * read property. 4283 * <li>Property is not writable. 4284 * </ul> 4285 * 4286 * @data_enum {@link VehicleLightState} 4287 */ 4288 @RequiresPermission(Car.PERMISSION_READ_INTERIOR_LIGHTS) 4289 public static final int SEAT_FOOTWELL_LIGHTS_STATE = 356518811; 4290 /** 4291 * Represents property for switch of the footwell lights. 4292 * 4293 * <p>{@code SEAT_FOOTWELL_LIGHTS_SWITCH} represents the position of the switch controlling the 4294 * lights. This is different from the function of {@link #SEAT_FOOTWELL_LIGHTS_STATE} which 4295 * reflects the current state of the lights at any point in time. Therefore, {@code 4296 * SEAT_FOOTWELL_LIGHTS_SWITCH} may not match the value of {@link #SEAT_FOOTWELL_LIGHTS_STATE} 4297 * (e.g. {@code SEAT_FOOTWELL_LIGHTS_SWITCH}={@code VehicleLightSwitch#STATE_AUTOMATIC} and 4298 * {@link #SEAT_FOOTWELL_LIGHTS_STATE}={@code VehicleLightState#STATE_ON}). 4299 * 4300 * <p>This property will only be implemented if {@code SEAT_FOOTWELL_LIGHTS_SWITCH}'s value may 4301 * be different from that of {@link #CABIN_LIGHTS_SWITCH}. 4302 * 4303 * <p>For each supported area ID, the {@link 4304 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} obtained from {@link 4305 * android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which enum values from 4306 * {@code VehicleLightSwitch} are supported. 4307 * 4308 * <p>Property Config: 4309 * <ul> 4310 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4311 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4312 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4313 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4314 * <li>{@code Integer} property type 4315 * </ul> 4316 * 4317 * <p>Required Permission: 4318 * <ul> 4319 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_INTERIOR_LIGHTS} to 4320 * read and write property. 4321 * </ul> 4322 * 4323 * @data_enum {@link VehicleLightSwitch} 4324 */ 4325 @RequiresPermission(Car.PERMISSION_CONTROL_INTERIOR_LIGHTS) 4326 public static final int SEAT_FOOTWELL_LIGHTS_SWITCH = 356518812; 4327 /** 4328 * Represents property for Seat easy access feature. 4329 * 4330 * <p>If true, the seat will automatically adjust to make it easier for the occupant to enter 4331 * and exit the vehicle. Each area ID maps to the seat that the user is trying to enter/exit 4332 * with the help of the easy access feature. 4333 * 4334 * <p>Property Config: 4335 * <ul> 4336 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4337 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4338 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4339 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4340 * <li>{@code Boolean} property type 4341 * </ul> 4342 * 4343 * <p>Required Permission: 4344 * <ul> 4345 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 4346 * write property. 4347 * </ul> 4348 */ 4349 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4350 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4351 public static final int SEAT_EASY_ACCESS_ENABLED = 354421661; 4352 /** 4353 * Represents feature to enable/disable a seat's ability to deploy airbag(s) when triggered 4354 * (e.g. by a crash). 4355 * 4356 * <p>If true, it means the seat's airbags are enabled, and if triggered (e.g. by a crash), they 4357 * will deploy. If false, it means the seat's airbags are disabled, and they will not deploy 4358 * under any circumstance. This property does not indicate if the airbags are deployed or not. 4359 * 4360 * <p>Property Config: 4361 * <ul> 4362 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4363 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4364 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4365 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4366 * <li>{@code Boolean} property type 4367 * </ul> 4368 * 4369 * <p>Required Permission: 4370 * <ul> 4371 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_AIRBAGS} to read and 4372 * write property. 4373 * </ul> 4374 */ 4375 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4376 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_AIRBAGS) 4377 public static final int SEAT_AIRBAG_ENABLED = 354421662; 4378 /** 4379 * State of deployment for seat airbags. 4380 * 4381 * <p>Bit flag property to relay information on which airbags have been deployed in the vehicle 4382 * at each seat, vs which ones are currently still armed. When SEAT_AIRBAG_ENABLED is set to 4383 * false at a particular areaId, this property will be UNAVAILABLE at that areaId. 4384 * 4385 * <p>Enums apply to each seat, not the global vehicle. For example, 4386 * {@link android.car.hardware.property.VehicleAirbagLocation#CURTAIN} at the driver seat areaId 4387 * represents whether the driver side curtain airbag has been deployed. Multiple bit flags can 4388 * be set to indicate that multiple different airbags have been deployed for the seat. 4389 * 4390 * <p>For each seat area ID, the {@link 4391 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 4392 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 4393 * from {@link android.car.hardware.property.VehicleAirbagLocation} are supported. 4394 * 4395 * <p>Property Config: 4396 * <ul> 4397 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4398 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4399 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4400 * <li>{@code Integer} property type 4401 * </ul> 4402 * 4403 * <p>Required Permission: 4404 * <ul> 4405 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_CAR_AIRBAGS} to read 4406 * property. 4407 * <li>Property is not writable. 4408 * </ul> 4409 * 4410 * @data_enum {@link android.car.hardware.property.VehicleAirbagLocation} 4411 */ 4412 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4413 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_CAR_AIRBAGS)) 4414 public static final int SEAT_AIRBAGS_DEPLOYED = 356518821; 4415 /** 4416 * Represents property for seat’s hipside (bottom cushion’s side) support position. 4417 * 4418 * <p>This property is not in any particular unit but in a specified range of relative 4419 * positions. 4420 * 4421 * <p>The {@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the seat 4422 * hipside support's thinnest position (i.e. most support). 4423 * <p>The {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the seat 4424 * hipside support's widest position (i.e. least support). 4425 * 4426 * <p>All integers between the min and max values are supported and indicate a transition state 4427 * between the thinnest and widest positions. 4428 * 4429 * <p>Property Config: 4430 * <ul> 4431 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4432 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4433 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4434 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4435 * <li>{@code Integer} property type 4436 * </ul> 4437 * 4438 * <p>Required Permission: 4439 * <ul> 4440 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 4441 * write property. 4442 * </ul> 4443 */ 4444 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4445 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4446 public static final int SEAT_CUSHION_SIDE_SUPPORT_POS = 356518815; 4447 /** 4448 * Represents property for movement direction and speed of seat cushion side support. 4449 * 4450 * <p>This property is not in any particular unit but in a specified range of relative movement 4451 * speeds. 4452 * 4453 * <p>Positive values means the seat cushion side support is growing wider (i.e. less support) 4454 * and negative values means the seat cushion side support is growing thinner (i.e. more 4455 * support). Larger integers, either positive or negative, indicate a faster speed. Once the 4456 * seat cushion side support reaches the positional limit, the value resets to 0. When this 4457 * property's value is 0, that means there is no movement currently occurring. 4458 * 4459 * <p>See {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} and {@link 4460 * android.car.hardware.property.AreaIdConfig#getMinValue()} for the range of possible speeds. 4461 * All integers between min and max value are supported. 4462 * 4463 * <p>Property Config: 4464 * <ul> 4465 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4466 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4467 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4468 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4469 * <li>{@code Integer} property type 4470 * </ul> 4471 * 4472 * <p>Required Permission: 4473 * <ul> 4474 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 4475 * write property. 4476 * </ul> 4477 */ 4478 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4479 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4480 public static final int SEAT_CUSHION_SIDE_SUPPORT_MOVE = 356518816; 4481 /** 4482 * Represents property for seat’s lumbar support vertical position. 4483 * 4484 * <p>This property is not in any particular unit but in a specified range of relative 4485 * positions. 4486 * 4487 * <p>The {@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the seat 4488 * lumbar support's lowest position. 4489 * <p>The {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the seat 4490 * lumbar support's highest position. 4491 * 4492 * <p>All integers between the min and max values are supported and indicate a transition state 4493 * between the lowest and highest positions. 4494 * 4495 * <p>Property Config: 4496 * <ul> 4497 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4498 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4499 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4500 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4501 * <li>{@code Integer} property type 4502 * </ul> 4503 * 4504 * <p>Required Permission: 4505 * <ul> 4506 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 4507 * write property. 4508 * </ul> 4509 */ 4510 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4511 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4512 public static final int SEAT_LUMBAR_VERTICAL_POS = 356518817; 4513 /** 4514 * Represents property for vertical movement direction and speed of seat lumbar support. 4515 * 4516 * <p>This property is not in any particular unit but in a specified range of relative movement 4517 * speeds. 4518 * 4519 * <p>Positive values mean the lumbar support is moving up and negative values mean the lumbar 4520 * support is moving down. Larger integers, either positive or negative, indicate a faster 4521 * speed. Once the lumbar support reaches the positional limit, the value resets to 0. When this 4522 * property's value is 0, that means there is no movement currently occurring. 4523 * 4524 * <p>See {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} and {@link 4525 * android.car.hardware.property.AreaIdConfig#getMinValue()} for the range of possible speeds. 4526 * All integers between min and max value are supported. 4527 * 4528 * <p>Property Config: 4529 * <ul> 4530 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4531 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4532 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4533 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4534 * <li>{@code Integer} property type 4535 * </ul> 4536 * 4537 * <p>Required Permission: 4538 * <ul> 4539 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 4540 * write property. 4541 * </ul> 4542 */ 4543 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4544 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4545 public static final int SEAT_LUMBAR_VERTICAL_MOVE = 356518818; 4546 /** 4547 * Represents property that indicates the current walk-in position of the seat. 4548 * 4549 * <p>This property is not in any particular unit but in a specified range of relative 4550 * positions. 4551 * 4552 * <p>{@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the normal seat 4553 * position. 4554 * <p>{@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the seat's 4555 * position in full walk-in mode. 4556 * 4557 * <p>All integers in between the min and max values are supported and indicate a transition 4558 * state between the normal and walk-in positions. The area IDs match the seats that actually 4559 * move when the walk-in feature activates. 4560 * 4561 * <p>Property Config: 4562 * <ul> 4563 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4564 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4565 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4566 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4567 * <li>{@code Integer} property type 4568 * </ul> 4569 * 4570 * <p>Required Permission: 4571 * <ul> 4572 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read and 4573 * write property. 4574 * </ul> 4575 */ 4576 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4577 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_SEATS) 4578 public static final int SEAT_WALK_IN_POS = 356518819; 4579 /** 4580 * Seat belt pretensioner deployed. 4581 * 4582 * <p>Property to relay information on whether the seat belt pretensioner has been deployed for 4583 * a particular seat due to a collision. This is different from the regular seat belt tightening 4584 * system that continuously adds tension to the seat belts so that they fit snugly around the 4585 * person sitting in the seat, nor is it the seat belt retractor system that locks the seat belt 4586 * in place during sudden brakes or when the user jerks the seat belt. 4587 * 4588 * <p>If this property is dependant on the state of other properties, and if those properties 4589 * are currently in the state that doesn't support this property, reading this property will 4590 * throw {@link android.car.hardware.property.PropertyNotAvailableException}. 4591 * 4592 * <p>Property Config: 4593 * <ul> 4594 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4595 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4596 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4597 * <li>{@code Boolean} property type 4598 * </ul> 4599 * 4600 * <p>Required Permission: 4601 * <ul> 4602 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_CAR_SEAT_BELTS} to read 4603 * property. 4604 * <li>Property is not writable. 4605 * </ul> 4606 */ 4607 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4608 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_CAR_SEAT_BELTS)) 4609 public static final int SEAT_BELT_PRETENSIONER_DEPLOYED = 354421670; 4610 /** 4611 * Seat Occupancy. 4612 * 4613 * <p>Property Config: 4614 * <ul> 4615 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4616 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 4617 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4618 * <li>{@code Integer} property type 4619 * </ul> 4620 * 4621 * <p>Required Permission: 4622 * <ul> 4623 * <li>Dangerous permission {@link Car#PERMISSION_READ_CAR_SEATS} or Signature|Privileged 4624 * permission {@link Car#PERMISSION_CONTROL_CAR_SEATS} to read property. 4625 * <li>Property is not writable. 4626 * </ul> 4627 * 4628 * @data_enum {@link VehicleSeatOccupancyState} 4629 */ 4630 @FlaggedApi(FLAG_VEHICLE_PROPERTY_25Q2_3P_PERMISSIONS) 4631 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_CAR_SEATS, 4632 Car.PERMISSION_CONTROL_CAR_SEATS})) 4633 public static final int SEAT_OCCUPANCY = 356518832; 4634 /** 4635 * Window Position. 4636 * 4637 * <p>This property is not in any particular unit but in a specified range of relative 4638 * positions. 4639 * 4640 * <p>{@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the window's 4641 * position when closed/fully open out of plane. If the window cannot open out of plane, then 4642 * {@link android.car.hardware.property.AreaIdConfig#getMinValue()} is the position of the 4643 * window when fully closed and must be 0. If the window can open out of plane, {@link 4644 * android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the window is fully open 4645 * in its position out of plane and will be a negative value. 4646 * <p>{@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the window's 4647 * position when fully open. 4648 * 4649 * <p>All integers in between the min and max values are supported and indicate a transition 4650 * state between the closed and fully open positions. 4651 * 4652 * <p>Property Config: 4653 * <ul> 4654 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4655 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4656 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WINDOW} 4657 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4658 * <li>{@code Integer} property type 4659 * </ul> 4660 * 4661 * <p>Required Permission: 4662 * <ul> 4663 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_WINDOWS} to read and 4664 * write property. 4665 * </ul> 4666 */ 4667 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_WINDOWS) 4668 public static final int WINDOW_POS = 322964416; 4669 /** 4670 * Window Move. 4671 * 4672 * <p>This property is not in any particular unit but in a specified range of relative movement 4673 * speeds. 4674 * 4675 * <p>Positive values mean the window is either closing from its out of plane position (if such 4676 * a position is supported by the window), or is opening in plane. Negative values mean the 4677 * window is closing in plane, or opening in its out of plane position (if the position is 4678 * supported). Larger integers, either positive or negative, indicate a faster speed. Once the 4679 * window reaches the positional limit, the value resets to 0. When this property's value is 0, 4680 * that means there is no movement currently occurring. 4681 * 4682 * <p>See {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} and {@link 4683 * android.car.hardware.property.AreaIdConfig#getMinValue()} for the range of possible speeds. 4684 * All integers between min and max value are supported. 4685 * 4686 * <p>Property Config: 4687 * <ul> 4688 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4689 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4690 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WINDOW} 4691 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4692 * <li>{@code Integer} property type 4693 * </ul> 4694 * 4695 * <p>Required Permission: 4696 * <ul> 4697 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_WINDOWS} to read and 4698 * write property. 4699 * </ul> 4700 */ 4701 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_WINDOWS) 4702 public static final int WINDOW_MOVE = 322964417; 4703 /** 4704 * Window Child Lock. 4705 * 4706 * <p>True indicates that the window is child-locked. 4707 * 4708 * <p>Property Config: 4709 * <ul> 4710 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4711 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4712 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WINDOW} 4713 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4714 * <li>{@code Boolean} property type 4715 * </ul> 4716 * 4717 * <p>Required Permission: 4718 * <ul> 4719 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_WINDOWS} to read and 4720 * write property. 4721 * </ul> 4722 */ 4723 @RequiresPermission(Car.PERMISSION_CONTROL_CAR_WINDOWS) 4724 public static final int WINDOW_LOCK = 320867268; 4725 4726 /** 4727 * Windshield wipers period (milliseconds). 4728 * 4729 * <p>Returns the instantaneous time period for 1 full cycle of the windshield wipers in {@link 4730 * android.car.VehicleUnit#MILLI_SECS}. A full cycle is defined as a wiper moving from and 4731 * returning to its rest position. The {@link 4732 * android.car.hardware.property.AreaIdConfig#getMaxValue()} specifies the longest wiper period. 4733 * The {@link android.car.hardware.property.AreaIdConfig#getMinValue()} is always 0. When an 4734 * intermittent wiper setting is selected, this property value will be set to 0 during the 4735 * "pause" phase of the intermittent wiping. 4736 * 4737 * <p>Property Config: 4738 * <ul> 4739 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4740 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WINDOW} 4741 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4742 * <li>{@code Integer} property type 4743 * </ul> 4744 * 4745 * <p>Required Permission: 4746 * <ul> 4747 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_WINDSHIELD_WIPERS} to read 4748 * property. 4749 * <li>Property is not writable. 4750 * </ul> 4751 */ 4752 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4753 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_WINDSHIELD_WIPERS)) 4754 public static final int WINDSHIELD_WIPERS_PERIOD = 322964421; 4755 4756 /** 4757 * Windshield wipers state. 4758 * 4759 * <p>Returns the current state of the windshield wipers. The value of {@code 4760 * WINDSHIELD_WIPERS_STATE} may not match the value of {@link #WINDSHIELD_WIPERS_SWITCH}. (e.g. 4761 * {@code #WINDSHIELD_WIPERS_STATE} = {@link 4762 * android.car.hardware.property.WindshieldWipersState#ON} and {@link 4763 * #WINDSHIELD_WIPERS_SWITCH} = {@link 4764 * android.car.hardware.property.WindshieldWipersSwitch#AUTO}). 4765 * 4766 * <p>If {@code #WINDSHIELD_WIPERS_STATE} = {@link 4767 * android.car.hardware.property.WindshieldWipersState#ON} and {@link #WINDSHIELD_WIPERS_PERIOD} 4768 * is implemented, then {@link #WINDSHIELD_WIPERS_PERIOD} will reflect the time period of 1 4769 * full cycle of the wipers. 4770 * 4771 * <p>For each supported area ID, the {@link 4772 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 4773 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 4774 * from {@link android.car.hardware.property.WindshieldWipersState} are supported. 4775 * 4776 * <p>Property Config: 4777 * <ul> 4778 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4779 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WINDOW} 4780 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4781 * <li>{@code Integer} property type 4782 * </ul> 4783 * 4784 * <p>Required Permission: 4785 * <ul> 4786 * <li>Dangerous permission {@link Car#PERMISSION_READ_WINDSHIELD_WIPERS_3P} or 4787 * Signature|Privileged permission {@link Car#PERMISSION_READ_WINDSHIELD_WIPERS} to read 4788 * property. 4789 * <li>Property is not writable. 4790 * </ul> 4791 * 4792 * @data_enum {@link WindshieldWipersState} 4793 */ 4794 @FlaggedApi(FLAG_VEHICLE_PROPERTY_25Q2_3P_PERMISSIONS) 4795 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_WINDSHIELD_WIPERS_3P, 4796 Car.PERMISSION_READ_WINDSHIELD_WIPERS})) 4797 public static final int WINDSHIELD_WIPERS_STATE = 322964422; 4798 4799 /** 4800 * Windshield wipers switch. 4801 * 4802 * <p>Represents the position of the switch controlling the windshield wipers. The value of 4803 * {@code WINDSHIELD_WIPERS_SWITCH} may not match the value of {@link #WINDSHIELD_WIPERS_STATE} 4804 * (e.g. {@code WINDSHIELD_WIPERS_SWITCH} = {@link 4805 * android.car.hardware.property.WindshieldWipersSwitch#AUTO} and {@link 4806 * #WINDSHIELD_WIPERS_STATE} = WindshieldWipersState#ON). 4807 * 4808 * <p>For each supported area ID, the {@link 4809 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 4810 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which values 4811 * from {@link android.car.hardware.property.WindshieldWipersSwitch} are supported. 4812 * 4813 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 4814 * only. 4815 * 4816 * <p>Property Config: 4817 * <ul> 4818 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4819 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4820 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_WINDOW} 4821 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4822 * <li>{@code Integer} property type 4823 * </ul> 4824 * 4825 * <p>Required Permissions: 4826 * <ul> 4827 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_WINDSHIELD_WIPERS} or 4828 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_WINDSHIELD_WIPERS} to read 4829 * property. 4830 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_WINDSHIELD_WIPERS} to 4831 * write property. 4832 * </ul> 4833 * 4834 * @data_enum {@link WindshieldWipersSwitch} 4835 */ 4836 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4837 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_WINDSHIELD_WIPERS, 4838 Car.PERMISSION_CONTROL_WINDSHIELD_WIPERS})) 4839 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_WINDSHIELD_WIPERS)) 4840 public static final int WINDSHIELD_WIPERS_SWITCH = 322964423; 4841 4842 /** 4843 * Steering wheel depth position. 4844 * 4845 * <p>This property is not in any particular unit but in a specified range of relative 4846 * positions. 4847 * 4848 * <p>{@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the steering 4849 * wheel's position when closest to the driver. 4850 * <p>{@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the steering 4851 * wheel's position when farthest from the driver. 4852 * 4853 * <p>All integers in between the min and max values are supported and indicate a transition 4854 * state between the closest and farthest positions. 4855 * 4856 * <p>Property Config: 4857 * <ul> 4858 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4859 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4860 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 4861 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4862 * <li>{@code Integer} property type 4863 * </ul> 4864 * 4865 * <p>Required Permission: 4866 * <ul> 4867 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_STEERING_WHEEL} to read 4868 * and write property. 4869 * </ul> 4870 */ 4871 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4872 @RequiresPermission(Car.PERMISSION_CONTROL_STEERING_WHEEL) 4873 public static final int STEERING_WHEEL_DEPTH_POS = 289410016; 4874 /** 4875 * Steering wheel depth movement. 4876 * 4877 * <p>Returns the speed and direction, either towards or away from the driver, that the 4878 * steering wheel is moving in. This property is not in any particular unit but in a specified 4879 * range of relative movement speeds. 4880 * 4881 * <p>Positive values mean the steering wheel is moving away from the driver and negative values 4882 * mean the steering wheel is moving towards the driver. Larger integers, either positive or 4883 * negative, indicate a faster speed. Once the steering wheel reaches the positional limit, the 4884 * value resets to 0. When this property's value is 0, that means there is no movement currently 4885 * occurring. 4886 * 4887 * <p>See {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} and {@link 4888 * android.car.hardware.property.AreaIdConfig#getMinValue()} for the range of possible speeds. 4889 * All integers between min and max value are supported. 4890 * 4891 * <p>Property Config: 4892 * <ul> 4893 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4894 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4895 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 4896 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4897 * <li>{@code Integer} property type 4898 * </ul> 4899 * 4900 * <p>Required Permission: 4901 * <ul> 4902 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_STEERING_WHEEL} to read 4903 * and write property. 4904 * </ul> 4905 */ 4906 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4907 @RequiresPermission(Car.PERMISSION_CONTROL_STEERING_WHEEL) 4908 public static final int STEERING_WHEEL_DEPTH_MOVE = 289410017; 4909 /** 4910 * Steering wheel height position. 4911 * 4912 * <p>This property is not in any particular unit but in a specified range of relative 4913 * positions. 4914 * 4915 * <p>{@link android.car.hardware.property.AreaIdConfig#getMinValue()} indicates the steering 4916 * wheel's lowest position. 4917 * <p>{@link android.car.hardware.property.AreaIdConfig#getMaxValue()} indicates the steering 4918 * wheel's highest position. 4919 * 4920 * <p>All integers in between the min and max values are supported and indicate a transition 4921 * state between the lowest and highest positions. 4922 * 4923 * <p>Property Config: 4924 * <ul> 4925 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4926 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4927 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 4928 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4929 * <li>{@code Integer} property type 4930 * </ul> 4931 * 4932 * <p>Required Permission: 4933 * <ul> 4934 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_STEERING_WHEEL} to read 4935 * and write property. 4936 * </ul> 4937 */ 4938 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4939 @RequiresPermission(Car.PERMISSION_CONTROL_STEERING_WHEEL) 4940 public static final int STEERING_WHEEL_HEIGHT_POS = 289410018; 4941 /** 4942 * Steering wheel height movement. 4943 * 4944 * <p>Returns the speed and direction, either upwards or downwards, that the steering wheel is 4945 * moving in. This property is not in any particular unit but in a specified range of relative 4946 * movement speeds. 4947 * 4948 * <p>Positive values mean moving upwards and negative values mean moving downwards. Larger 4949 * integers, either positive or negative, indicate a faster speed. Once the steering wheel 4950 * reaches the positional limit, the value resets to 0. When this property's value is 0, that 4951 * means there is no movement currently occurring. 4952 * 4953 * <p>See {@link android.car.hardware.property.AreaIdConfig#getMaxValue()} and {@link 4954 * android.car.hardware.property.AreaIdConfig#getMinValue()} for the range of possible speeds. 4955 * All integers between min and max value are supported. 4956 * 4957 * <p>Property Config: 4958 * <ul> 4959 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4960 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4961 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 4962 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4963 * <li>{@code Integer} property type 4964 * </ul> 4965 * 4966 * <p>Required Permission: 4967 * <ul> 4968 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_STEERING_WHEEL} to read 4969 * and write property. 4970 * </ul> 4971 */ 4972 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4973 @RequiresPermission(Car.PERMISSION_CONTROL_STEERING_WHEEL) 4974 public static final int STEERING_WHEEL_HEIGHT_MOVE = 289410019; 4975 /** 4976 * Steering wheel theft lock feature enabled. 4977 * 4978 * <p>Returns true if the steering wheel theft lock feature is enabled and false if it is 4979 * disabled. If enabled, the steering wheel will lock automatically to prevent theft in 4980 * certain situations. 4981 * 4982 * <p>Property Config: 4983 * <ul> 4984 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 4985 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 4986 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 4987 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 4988 * <li>{@code Boolean} property type 4989 * </ul> 4990 * 4991 * <p>Required Permission: 4992 * <ul> 4993 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_STEERING_WHEEL} to read 4994 * and write property. 4995 * </ul> 4996 */ 4997 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 4998 @RequiresPermission(Car.PERMISSION_CONTROL_STEERING_WHEEL) 4999 public static final int STEERING_WHEEL_THEFT_LOCK_ENABLED = 287312868; 5000 /** 5001 * Steering wheel locked. 5002 * 5003 * <p>Returns true if the steering wheel is locked. If locked, the steering wheel’s position is 5004 * not changeable. 5005 * 5006 * <p>Property Config: 5007 * <ul> 5008 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 5009 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5010 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5011 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5012 * <li>{@code Boolean} property type 5013 * </ul> 5014 * 5015 * <p>Required Permission: 5016 * <ul> 5017 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_STEERING_WHEEL} to read 5018 * and write property. 5019 * </ul> 5020 */ 5021 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 5022 @RequiresPermission(Car.PERMISSION_CONTROL_STEERING_WHEEL) 5023 public static final int STEERING_WHEEL_LOCKED = 287312869; 5024 /** 5025 * Steering wheel easy access feature enabled. 5026 * 5027 * <p>Returns true if the steering wheel easy access feature is enabled and false if it is 5028 * disabled. If enabled, the driver’s steering wheel will automatically adjust to make it easier 5029 * for the driver to enter and exit the vehicle. 5030 * 5031 * <p>Property Config: 5032 * <ul> 5033 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 5034 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5035 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5036 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5037 * <li>{@code Boolean} property type 5038 * </ul> 5039 * 5040 * <p>Required Permission: 5041 * <ul> 5042 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_STEERING_WHEEL} to read 5043 * and write property. 5044 * </ul> 5045 */ 5046 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 5047 @RequiresPermission(Car.PERMISSION_CONTROL_STEERING_WHEEL) 5048 public static final int STEERING_WHEEL_EASY_ACCESS_ENABLED = 287312870; 5049 /** 5050 * Vehicle Maps Service (VMS) message. 5051 * 5052 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 5053 * 5054 * <p>This property is not supported. 5055 * 5056 * @deprecated use {@link android.car.vms.VmsClientManager} instead. 5057 */ 5058 @Deprecated 5059 @RequiresPermission(anyOf = {Car.PERMISSION_VMS_PUBLISHER, Car.PERMISSION_VMS_SUBSCRIBER}) 5060 public static final int VEHICLE_MAP_SERVICE = 299895808; 5061 /** 5062 * Characterization of inputs used for computing location. 5063 * 5064 * <p>This property indicates what (if any) data and sensor inputs are considered by the system 5065 * when computing the vehicle's location that is shared with Android through {@link 5066 * android.location.LocationManager#GPS_PROVIDER}. 5067 * 5068 * <p>The value returned is a collection of bit flags. The bit flags are defined in {@link 5069 * LocationCharacterization}. The value will also include exactly 5070 * one of {@link LocationCharacterization#DEAD_RECKONED} or {@link 5071 * LocationCharacterization#RAW_GNSS_ONLY} among its collection of 5072 * bit flags. 5073 * 5074 * <p>When this property is not supported, it is assumed that no additional sensor inputs are 5075 * fused into the GNSS updates provided through {@link 5076 * android.location.LocationManager#GPS_PROVIDER}. That is unless otherwise specified through 5077 * other {@link android.location.LocationManager} APIs. 5078 * 5079 * <p>Property Config: 5080 * <ul> 5081 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5082 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5083 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 5084 * <li>{@code Integer} property type 5085 * </ul> 5086 * 5087 * <p>Required Permission: 5088 * <ul> 5089 * <li>Dangerous permission {@link android.Manifest.permission#ACCESS_FINE_LOCATION} to read 5090 * property. 5091 * <li>Property is not writable. 5092 * </ul> 5093 * 5094 * @data_flag {@link LocationCharacterization} 5095 */ 5096 @RequiresPermission(ACCESS_FINE_LOCATION) 5097 public static final int LOCATION_CHARACTERIZATION = 289410064; 5098 5099 /** 5100 * Static data for the position of each ultrasonic sensor installed on the vehicle. 5101 * 5102 * <p>Each individual sensor is identified by its unique {@link AreaIdConfig#getAreaId()} and 5103 * returns the sensor's position formatated as [x, y, z] where: 5104 * 5105 * <ul> 5106 * <li>x is the position of the sensor along the x-axis relative to the origin of the Android 5107 * Automotive sensor coordinate frame in millimeters. 5108 * <li>y is the position of the sensor along the y-axis relative to the origin of the Android 5109 * Automotive sensor coordinate frame in millimeters. 5110 * <li>z is the position of the sensor along the z-axis relative to the origin of the Android 5111 * Automotive sensor coordinate frame in millimeters. 5112 * </ul> 5113 * 5114 * <p>Property Config: 5115 * <ul> 5116 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5117 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_VENDOR} 5118 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 5119 * <li>{@code Integer[]} property type 5120 * </ul> 5121 * 5122 * <p>Required Permission: 5123 * <ul> 5124 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ULTRASONICS_SENSOR_DATA} to 5125 * read property. 5126 * <li>Property is not writable. 5127 * </ul> 5128 */ 5129 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 5130 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ULTRASONICS_SENSOR_DATA)) 5131 public static final int ULTRASONICS_SENSOR_POSITION = 406916128; 5132 5133 /** 5134 * Static data for the orientation of each ultrasonic sensor installed on the vehicle. 5135 * 5136 * <p>Each individual sensor is identified by its {@link AreaIdConfig#getAreaId()} and returns 5137 * the sensor's orientation formatted as [qw, qx, qy, qz] where: 5138 * 5139 * <ul> 5140 * <li>qw is the quaternion coefficient w within the quaterinion (w + xi + yj + zk) describing 5141 * the rotation of the sensor relative to the Android Automotive sensor coordinate frame. 5142 * <li>qx is the quaternion coefficient x within the quaterinion (w + xi + yj + zk) describing 5143 * the rotation of the sensor relative to the Android Automotive sensor coordinate frame. 5144 * <li>qy is the quaternion coefficient y within the quaterinion (w + xi + yj + zk) describing 5145 * the rotation of the sensor relative to the Android Automotive sensor coordinate frame. 5146 * <li>qz is the quaternion coefficient z within the quaterinion (w + xi + yj + zk) describing 5147 * the rotation of the sensor relative to the Android Automotive sensor coordinate frame. 5148 * </ul> 5149 * 5150 * <p>This assumes each sensor uses the same axes conventions as Android Automotive. 5151 * 5152 * <p>Property Config: 5153 * <ul> 5154 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5155 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_VENDOR} 5156 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 5157 * <li>{@code Float[]} property type 5158 * </ul> 5159 * 5160 * <p>Required Permission: 5161 * <ul> 5162 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ULTRASONICS_SENSOR_DATA} to 5163 * read property. 5164 * <li>Property is not writable. 5165 * </ul> 5166 */ 5167 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 5168 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ULTRASONICS_SENSOR_DATA)) 5169 public static final int ULTRASONICS_SENSOR_ORIENTATION = 409013281; 5170 5171 /** 5172 * Static data for the field of view of each ultrasonic sensor in degrees. 5173 * 5174 * <p>Each individual sensor is identified by its {@link AreaIdConfig#getAreaId()} and returns 5175 * the sensor's field of view formatted as [horizontal, vertical] where: 5176 * 5177 * <ul> 5178 * <li>horizontal is the horizontal field of view for the specified ultrasonic sensor in 5179 * degrees. 5180 * <li>vertical is the vertical field of view for the associated specified ultrasonic sensor in 5181 * degrees. 5182 * </ul> 5183 * 5184 * <p>This assumes each sensor uses the same axes conventions as Android Automotive. 5185 * 5186 * <p>Property Config: 5187 * <ul> 5188 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5189 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_VENDOR} 5190 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 5191 * <li>{@code Integer[]} property type 5192 * </ul> 5193 * 5194 * <p>Required Permission: 5195 * <ul> 5196 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ULTRASONICS_SENSOR_DATA} to 5197 * read property. 5198 * <li>Property is not writable. 5199 * </ul> 5200 */ 5201 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 5202 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ULTRASONICS_SENSOR_DATA)) 5203 public static final int ULTRASONICS_SENSOR_FIELD_OF_VIEW = 406916130; 5204 5205 /** 5206 * Static data for the detection range of each ultrasonic sensor in millimeters. 5207 * 5208 * <p>Each individual sensor is identified by its {@link AreaIdConfig#getAreaId()} and returns 5209 * the sensor's detection range formatted as [minimum, maximum] where: 5210 * 5211 * <ul> 5212 * <li>minimum is the minimum range detectable by the ultrasonic sensor in millimeters. 5213 * <li>maximum is the maximum range detectable by the ultrasonic sensor in millimeters. 5214 * </ul> 5215 * 5216 * <p>Property Config: 5217 * <ul> 5218 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5219 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_VENDOR} 5220 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 5221 * <li>{@code Integer[]} property type 5222 * </ul> 5223 * 5224 * <p>Required Permission: 5225 * <ul> 5226 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ULTRASONICS_SENSOR_DATA} to 5227 * read property. 5228 * <li>Property is not writable. 5229 * </ul> 5230 */ 5231 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 5232 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ULTRASONICS_SENSOR_DATA)) 5233 public static final int ULTRASONICS_SENSOR_DETECTION_RANGE = 406916131; 5234 5235 /** 5236 * Static data for the supported ranges of each ultrasonic sensor in millimeters. 5237 * 5238 * <p>For ultrasonic sensors that only support readings within a specific range. For example, if 5239 * an ultrasonic sensor detects an object at 700mm, but can only report that an object has been 5240 * detected between 500mm and 1000mm. 5241 * 5242 * <p>Each individual sensor is identified by its {@link AreaIdConfig#getAreaId()} and returns 5243 * the sensor's supported ranges formatted as [range_min_1, range_max_1, range_min_2, 5244 * range_max_2, ...] where: 5245 * 5246 * <ul> 5247 * <li>range_min_1 is the minimum of one supported range by the specified sensor in 5248 * millimeters, inclusive. 5249 * <li>range_max_1 is the maximum of one supported range by the specified sensor in 5250 * millimeters, inclusive. 5251 * <li> range_min_2 is the minimum of another supported range by the specified sensor in 5252 * millimeters, inclusive. 5253 * <li> range_max_2 is the maximum of another supported range by the specified sensor in 5254 * millimeters, inclusive. 5255 * </ul> 5256 * 5257 * <p>For example, if an ultrasonic sensor supports the ranges 150mm to 499mm, 500mm to 999mm, 5258 * and 1000mm to 1500mm, then the property should be set to: 5259 * <ul> 5260 * <li>value[0] = 150 5261 * <li>value[1] = 499 5262 * <li>value[2] = 500 5263 * <li>value[3] = 999 5264 * <li>value[4] = 1000 5265 * <li>value[5] = 1500 5266 * </ul> 5267 * 5268 * <p>If this property is not defined, all the values within the 5269 * {@link #ULTRASONICS_SENSOR_DETECTION_RANGE} for the specified sensor are assumed to be 5270 * supported. 5271 * 5272 * <p>Property Config: 5273 * <ul> 5274 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5275 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_VENDOR} 5276 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 5277 * <li>{@code Integer[]} property type 5278 * </ul> 5279 * 5280 * <p>Required Permission: 5281 * <ul> 5282 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ULTRASONICS_SENSOR_DATA} to 5283 * read property. 5284 * <li>Property is not writable. 5285 * </ul> 5286 */ 5287 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 5288 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ULTRASONICS_SENSOR_DATA)) 5289 public static final int ULTRASONICS_SENSOR_SUPPORTED_RANGES = 406916132; 5290 5291 /** 5292 * The distance reading of the nearest detected object per sensor in millimeters. 5293 * 5294 * <p>Each individual sensor is identified by its {@link AreaIdConfig#getAreaId()} and returns 5295 * the sensor's measured distance formatted as [distance, distance_error] where: 5296 * 5297 * <ul> 5298 * <li>distance is the measured distance of the nearest object in millimeters. If only a range 5299 * is supported, this value must be set to the minimum supported distance in the detected range 5300 * as specified in {@link #ULTRASONICS_SENSOR_SUPPORTED_RANGES}. 5301 * <li>distance_error is the error of the measured distance value in millimeters. 5302 * </ul> 5303 * 5304 * <p>If no object is detected, an empty vector will be returned. If distance_error is not 5305 * available then an array of only the measured distance will be returned. 5306 * 5307 * <p>Property Config: 5308 * <ul> 5309 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5310 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_VENDOR} 5311 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 5312 * <li>{@code Integer[]} property type 5313 * </ul> 5314 * 5315 * <p>Required Permission: 5316 * <ul> 5317 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ULTRASONICS_SENSOR_DATA} to 5318 * read property. 5319 * <li>Property is not writable. 5320 * </ul> 5321 */ 5322 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 5323 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ULTRASONICS_SENSOR_DATA)) 5324 public static final int ULTRASONICS_SENSOR_MEASURED_DISTANCE = 406916133; 5325 5326 /** 5327 * OBD2 Live Sensor Data. 5328 * 5329 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 5330 * 5331 * <p>This property is not supported. 5332 * 5333 * @deprecated use {@link android.car.diagnostic.CarDiagnosticManager} instead. 5334 */ 5335 @Deprecated 5336 @RequiresPermission(Car.PERMISSION_CAR_DIAGNOSTIC_READ_ALL) 5337 public static final int OBD2_LIVE_FRAME = 299896064; 5338 /** 5339 * OBD2 Freeze Frame Sensor Data. 5340 * 5341 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 5342 * 5343 * <p>This property is not supported. 5344 * 5345 * @deprecated use {@link android.car.diagnostic.CarDiagnosticManager} instead. 5346 */ 5347 @Deprecated 5348 @RequiresPermission(Car.PERMISSION_CAR_DIAGNOSTIC_READ_ALL) 5349 public static final int OBD2_FREEZE_FRAME = 299896065; 5350 /** 5351 * OBD2 Freeze Frame Information. 5352 * 5353 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 5354 * 5355 * <p>This property is not supported. 5356 * 5357 * @deprecated use {@link android.car.diagnostic.CarDiagnosticManager} instead. 5358 */ 5359 @Deprecated 5360 @RequiresPermission(Car.PERMISSION_CAR_DIAGNOSTIC_READ_ALL) 5361 public static final int OBD2_FREEZE_FRAME_INFO = 299896066; 5362 /** 5363 * OBD2 Freeze Frame Clear. 5364 * 5365 * <p>Not exposed through {@link android.car.hardware.property.CarPropertyManager}. 5366 * 5367 * <p>This property is not supported. 5368 * 5369 * @deprecated use {@link android.car.diagnostic.CarDiagnosticManager} instead. 5370 */ 5371 @Deprecated 5372 @RequiresPermission(Car.PERMISSION_CAR_DIAGNOSTIC_CLEAR) 5373 public static final int OBD2_FREEZE_FRAME_CLEAR = 299896067; 5374 /** 5375 * Headlights State. 5376 * 5377 * <p>Property Config: 5378 * <ul> 5379 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5380 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5381 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5382 * <li>{@code Integer} property type 5383 * </ul> 5384 * 5385 * <p>Required Permission: 5386 * <ul> 5387 * <li>Signature|Privileged permission {@link Car#PERMISSION_EXTERIOR_LIGHTS} to read 5388 * property. 5389 * <li>Property is not writable. 5390 * </ul> 5391 * 5392 * @data_enum {@link VehicleLightState} 5393 */ 5394 @RequiresPermission(Car.PERMISSION_EXTERIOR_LIGHTS) 5395 public static final int HEADLIGHTS_STATE = 289410560; 5396 /** 5397 * High beam lights state. 5398 * 5399 * <p>Property Config: 5400 * <ul> 5401 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5402 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5403 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5404 * <li>{@code Integer} property type 5405 * </ul> 5406 * 5407 * <p>Required Permission: 5408 * <ul> 5409 * <li>Signature|Privileged permission {@link Car#PERMISSION_EXTERIOR_LIGHTS} to read 5410 * property. 5411 * <li>Property is not writable. 5412 * </ul> 5413 * 5414 * @data_enum {@link VehicleLightState} 5415 */ 5416 @RequiresPermission(Car.PERMISSION_EXTERIOR_LIGHTS) 5417 public static final int HIGH_BEAM_LIGHTS_STATE = 289410561; 5418 /** 5419 * Fog light state. 5420 * 5421 * <p>If the car has both front and rear fog lights: 5422 * <ul> 5423 * <li>If front and rear fog lights can only be controlled together: {@code FOG_LIGHTS_STATE} 5424 * provides the state of fog lights. 5425 * <li>If front and rear fog lights can only be controlled independently: {@link 5426 * #FRONT_FOG_LIGHTS_STATE} and {@link #REAR_FOG_LIGHTS_STATE} provide the state of front, rear 5427 * fog lights respectively. 5428 * </ul> 5429 * 5430 * <p>If the car has only front fog lights: 5431 * <ul> 5432 * <li>Only one of {@code FOG_LIGHTS_STATE} or {@link #FRONT_FOG_LIGHTS_STATE} will be 5433 * implemented in the car. The implemented property provides the state of the front fog lights. 5434 * </ul> 5435 * 5436 * <p>If the car has only rear fog lights: 5437 * <ul> 5438 * <li>Only one of {@code FOG_LIGHTS_STATE} or {@link #REAR_FOG_LIGHTS_STATE} will be 5439 * implemented in the car. The implemented property provides the state of the rear fog lights. 5440 * </ul> 5441 * 5442 * <p>Property Config: 5443 * <ul> 5444 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5445 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5446 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5447 * <li>{@code Integer} property type 5448 * </ul> 5449 * 5450 * <p>Required Permission: 5451 * <ul> 5452 * <li>Signature|Privileged permission {@link Car#PERMISSION_EXTERIOR_LIGHTS} to read 5453 * property. 5454 * <li>Property is not writable. 5455 * </ul> 5456 * 5457 * @data_enum {@link VehicleLightState} 5458 */ 5459 @RequiresPermission(Car.PERMISSION_EXTERIOR_LIGHTS) 5460 public static final int FOG_LIGHTS_STATE = 289410562; 5461 /** 5462 * Hazard light status. 5463 * 5464 * <p>Property Config: 5465 * <ul> 5466 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5467 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5468 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5469 * <li>{@code Integer} property type 5470 * </ul> 5471 * 5472 * <p>Required Permission: 5473 * <ul> 5474 * <li>Signature|Privileged permission {@link Car#PERMISSION_EXTERIOR_LIGHTS} to read 5475 * property. 5476 * <li>Property is not writable. 5477 * </ul> 5478 * 5479 * @data_enum {@link VehicleLightState} 5480 */ 5481 @RequiresPermission(Car.PERMISSION_EXTERIOR_LIGHTS) 5482 public static final int HAZARD_LIGHTS_STATE = 289410563; 5483 /** 5484 * Headlight switch. 5485 * 5486 * <p>Property Config: 5487 * <ul> 5488 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 5489 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5490 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5491 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5492 * <li>{@code Integer} property type 5493 * </ul> 5494 * 5495 * <p>Required Permission: 5496 * <ul> 5497 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_EXTERIOR_LIGHTS} to 5498 * read and write property. 5499 * </ul> 5500 * 5501 * @data_enum {@link VehicleLightSwitch} 5502 */ 5503 @RequiresPermission(Car.PERMISSION_CONTROL_EXTERIOR_LIGHTS) 5504 public static final int HEADLIGHTS_SWITCH = 289410576; 5505 /** 5506 * High beam light switch. 5507 * 5508 * <p>Property Config: 5509 * <ul> 5510 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 5511 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5512 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5513 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5514 * <li>{@code Integer} property type 5515 * </ul> 5516 * 5517 * <p>Required Permission: 5518 * <ul> 5519 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_EXTERIOR_LIGHTS} to 5520 * read and write property. 5521 * </ul> 5522 * 5523 * @data_enum {@link VehicleLightSwitch} 5524 */ 5525 @RequiresPermission(Car.PERMISSION_CONTROL_EXTERIOR_LIGHTS) 5526 public static final int HIGH_BEAM_LIGHTS_SWITCH = 289410577; 5527 /** 5528 * Fog light switch. 5529 * 5530 * <p>If the car has both front and rear fog lights: 5531 * <ul> 5532 * <li>If front and rear fog lights can only be controlled together: {@code FOG_LIGHTS_SWITCH} 5533 * should be used to change the fog lights state. 5534 * <li>If front and rear fog lights can only be controlled independently: {@link 5535 * #FRONT_FOG_LIGHTS_SWITCH} and {@link #REAR_FOG_LIGHTS_SWITCH} should be used to change the 5536 * front and rear fog lights state respectively. 5537 * </ul> 5538 * 5539 * <p>If the car has only front fog lights: 5540 * <ul> 5541 * <li>Only one of {@code FOG_LIGHTS_SWITCH} or {@link #FRONT_FOG_LIGHTS_SWITCH} will be 5542 * implemented in the car. The implemented property should be used to change the front fog 5543 * lights state. 5544 * </ul> 5545 * 5546 * <p>If the car has only rear fog lights: 5547 * <ul> 5548 * <li>Only one of {@code FOG_LIGHTS_SWITCH} or {@link #REAR_FOG_LIGHTS_SWITCH} will be 5549 * implemented in the car. The implemented property should be used to change the rear fog 5550 * lights state. 5551 * </ul> 5552 * 5553 * <p>Property Config: 5554 * <ul> 5555 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 5556 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5557 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5558 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5559 * <li>{@code Integer} property type 5560 * </ul> 5561 * 5562 * <p>Required Permission: 5563 * <ul> 5564 * <li>Signature|Privileged permission{@link Car#PERMISSION_CONTROL_EXTERIOR_LIGHTS} to 5565 * read and write property. 5566 * </ul> 5567 * 5568 * @data_enum {@link VehicleLightSwitch} 5569 */ 5570 @RequiresPermission(Car.PERMISSION_CONTROL_EXTERIOR_LIGHTS) 5571 public static final int FOG_LIGHTS_SWITCH = 289410578; 5572 /** 5573 * Hazard light switch. 5574 * 5575 * <p>Property Config: 5576 * <ul> 5577 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 5578 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5579 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5580 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5581 * <li>{@code Integer} property type 5582 * </ul> 5583 * 5584 * <p>Required Permission: 5585 * <ul> 5586 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_EXTERIOR_LIGHTS} to 5587 * read and write property. 5588 * </ul> 5589 * 5590 * @data_enum {@link VehicleLightSwitch} 5591 */ 5592 @RequiresPermission(Car.PERMISSION_CONTROL_EXTERIOR_LIGHTS) 5593 public static final int HAZARD_LIGHTS_SWITCH = 289410579; 5594 /** 5595 * Cabin lights. 5596 * 5597 * <p>Property Config: 5598 * <ul> 5599 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5600 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5601 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5602 * <li>{@code Integer} property type 5603 * </ul> 5604 * 5605 * <p>Required Permission: 5606 * <ul> 5607 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_INTERIOR_LIGHTS} to 5608 * read property. 5609 * <li>Property is not writable. 5610 * </ul> 5611 * 5612 * @data_enum {@link VehicleLightState} 5613 */ 5614 @RequiresPermission(Car.PERMISSION_READ_INTERIOR_LIGHTS) 5615 public static final int CABIN_LIGHTS_STATE = 289410817; 5616 /** 5617 * Cabin lights switch. 5618 * 5619 * <p>Property Config: 5620 * <ul> 5621 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 5622 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5623 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5624 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5625 * <li>{@code Integer} property type 5626 * </ul> 5627 * 5628 * <p>Required Permission: 5629 * <ul> 5630 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_INTERIOR_LIGHTS} to 5631 * read and write property. 5632 * </ul> 5633 * 5634 * @data_enum {@link VehicleLightSwitch} 5635 */ 5636 @RequiresPermission(Car.PERMISSION_CONTROL_INTERIOR_LIGHTS) 5637 public static final int CABIN_LIGHTS_SWITCH = 289410818; 5638 /** 5639 * Reading lights. 5640 * 5641 * <p>Property Config: 5642 * <ul> 5643 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5644 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 5645 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5646 * <li>{@code Integer} property type 5647 * </ul> 5648 * 5649 * <p>Required Permission: 5650 * <ul> 5651 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_INTERIOR_LIGHTS} to 5652 * read property. 5653 * <li>Property is not writable. 5654 * </ul> 5655 * 5656 * @data_enum {@link VehicleLightState} 5657 */ 5658 @RequiresPermission(Car.PERMISSION_READ_INTERIOR_LIGHTS) 5659 public static final int READING_LIGHTS_STATE = 356519683; 5660 /** 5661 * Reading lights switch. 5662 * 5663 * <p>Property Config: 5664 * <ul> 5665 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 5666 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5667 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_SEAT} 5668 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5669 * <li>{@code Integer} property type 5670 * </ul> 5671 * 5672 * <p>Required Permission: 5673 * <ul> 5674 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_INTERIOR_LIGHTS} to 5675 * read and write property. 5676 * </ul> 5677 * 5678 * @data_enum {@link VehicleLightSwitch} 5679 */ 5680 @RequiresPermission(Car.PERMISSION_CONTROL_INTERIOR_LIGHTS) 5681 public static final int READING_LIGHTS_SWITCH = 356519684; 5682 5683 /** 5684 * Steering wheel lights state. 5685 * 5686 * <p>Returns the current state of the steering wheel lights. This is different from {@link 5687 * #STEERING_WHEEL_LIGHTS_SWITCH} which represents the position of the switch controlling 5688 * the lights. Therefore, {@code STEERING_WHEEL_LIGHTS_STATE} may not match the value of 5689 * {@link #STEERING_WHEEL_LIGHTS_SWITCH} (e.g. {@link #STEERING_WHEEL_LIGHTS_SWITCH}={@code 5690 * VehicleLightSwitch#STATE_AUTOMATIC} and {@code STEERING_WHEEL_LIGHTS_STATE}={@code 5691 * VehicleLightState#STATE_ON}). 5692 * 5693 * <p>This property will only be implemented if {@code STEERING_WHEEL_LIGHTS_STATE}'s value may 5694 * be different from that of {@link #CABIN_LIGHTS_STATE}. 5695 * 5696 * <p>For the global area ID (0), the {@link 5697 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} obtained from {@link 5698 * android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which enum values from 5699 * {@code VehicleLightState} are supported. 5700 * 5701 * <p>Property Config: 5702 * <ul> 5703 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5704 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5705 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5706 * <li>{@code Integer} property type 5707 * </ul> 5708 * 5709 * <p>Required Permission: 5710 * <ul> 5711 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_INTERIOR_LIGHTS} to 5712 * read property. 5713 * <li>Property is not writable. 5714 * </ul> 5715 * 5716 * @data_enum {@link VehicleLightState} 5717 */ 5718 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_INTERIOR_LIGHTS)) 5719 public static final int STEERING_WHEEL_LIGHTS_STATE = 289410828; 5720 5721 /** 5722 * Steering wheel lights switch. 5723 * 5724 * <p>Returns the position of the switch controlling the steering wheel lights. This is 5725 * different from {@link #STEERING_WHEEL_LIGHTS_STATE} which represents the current state of the 5726 * steering wheel lights. Therefore, {@code STEERING_WHEEL_LIGHTS_SWITCH} may not match the 5727 * value of {@link #STEERING_WHEEL_LIGHTS_STATE} (e.g. {@code STEERING_WHEEL_LIGHTS_SWITCH}= 5728 * {@code VehicleLightSwitch#STATE_AUTOMATIC} and {@link #STEERING_WHEEL_LIGHTS_STATE}={@code 5729 * VehicleLightState#STATE_ON}). 5730 * 5731 * <p>This property will only be implemented if {@code STEERING_WHEEL_LIGHTS_SWITCH}'s value may 5732 * be different from that of {@link #CABIN_LIGHTS_SWITCH}. 5733 * 5734 * <p>For the global area ID (0), the {@link 5735 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} obtained from {@link 5736 * android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which enum values from 5737 * {@code VehicleLightSwitch} are supported. 5738 * 5739 * <p>Property Config: 5740 * <ul> 5741 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 5742 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5743 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5744 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5745 * <li>{@code Integer} property type 5746 * </ul> 5747 * 5748 * <p>Required Permission: 5749 * <ul> 5750 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_INTERIOR_LIGHTS} to 5751 * read and write property. 5752 * </ul> 5753 * 5754 * @data_enum {@link VehicleLightSwitch} 5755 */ 5756 @RequiresPermission(Car.PERMISSION_CONTROL_INTERIOR_LIGHTS) 5757 public static final int STEERING_WHEEL_LIGHTS_SWITCH = 289410829; 5758 5759 /** 5760 * Property to get the initial settings for multi-user management (such as initial user). 5761 * 5762 * <p>Doesn't require permission because it's not exposed through 5763 * {@link android.car.hardware.property.CarPropertyManager}. 5764 * 5765 * <p>Property Config: 5766 * <ul> 5767 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} 5768 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5769 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5770 * <li>{@code Object[]} property type 5771 * </ul> 5772 * 5773 * @hide 5774 */ 5775 public static final int INITIAL_USER_INFO = 299896583; 5776 5777 /** 5778 * Property to switch user for multi-user management. 5779 * 5780 * <p>Doesn't require permission because it's not exposed through 5781 * {@link android.car.hardware.property.CarPropertyManager}. 5782 * 5783 * <p>Property Config: 5784 * <ul> 5785 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} 5786 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5787 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5788 * <li>{@code Object[]} property type 5789 * </ul> 5790 * 5791 * @hide 5792 */ 5793 public static final int SWITCH_USER = 299896584; 5794 5795 /** 5796 * Property to create a new user for multi-user management. 5797 * 5798 * <p>Doesn't require permission because it's not exposed through 5799 * {@link android.car.hardware.property.CarPropertyManager}. 5800 * 5801 * <p>Property Config: 5802 * <ul> 5803 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} 5804 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5805 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5806 * <li>{@code Object[]} property type 5807 * </ul> 5808 * 5809 * @hide 5810 */ 5811 public static final int CREATE_USER = 299896585; 5812 5813 /** 5814 * Property to remove a new user for multi-user management. 5815 * 5816 * <p>Doesn't require permission because it's not exposed through 5817 * {@link android.car.hardware.property.CarPropertyManager}. 5818 * 5819 * <p>Property Config: 5820 * <ul> 5821 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 5822 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5823 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 5824 * <li>{@code Object[]} property type 5825 * </ul> 5826 * 5827 * @hide 5828 */ 5829 public static final int REMOVE_USER = 299896586; 5830 5831 /** 5832 * Property to get / set the user authentication types associated with an Android user. 5833 * 5834 * <p>Doesn't require permission because it's not exposed through 5835 * {@link android.car.hardware.property.CarPropertyManager}. 5836 * 5837 * <p>Property Config: 5838 * <ul> 5839 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} 5840 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5841 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5842 * <li>{@code Object[]} property type 5843 * </ul> 5844 * 5845 * @hide 5846 */ 5847 public static final int USER_IDENTIFICATION_ASSOCIATION = 299896587; 5848 5849 /** 5850 * Property for VHAL to apply power policy. 5851 * 5852 * <p>Doesn't require permission because it's not exposed through 5853 * {@link android.car.hardware.property.CarPropertyManager}. 5854 * 5855 * <p>Property Config: 5856 * <ul> 5857 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5858 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5859 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5860 * <li>{@code String} property type 5861 * </ul> 5862 * 5863 * @hide 5864 */ 5865 public static final int POWER_POLICY_REQ = 286265121; 5866 5867 /** 5868 * Property for VHAL to set the default power policies per power status transition. 5869 * 5870 * <p>Doesn't require permission because it's not exposed through 5871 * {@link android.car.hardware.property.CarPropertyManager}. 5872 * 5873 * <p>Property Config: 5874 * <ul> 5875 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5876 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5877 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5878 * <li>{@code String} property type 5879 * </ul> 5880 * 5881 * @hide 5882 */ 5883 public static final int POWER_POLICY_GROUP_REQ = 286265122; 5884 5885 /** 5886 * Property to report a new current power policy to VHAL. 5887 * 5888 * <p>Doesn't require permission because it's not exposed through 5889 * {@link android.car.hardware.property.CarPropertyManager}. 5890 * 5891 * <p>Property Config: 5892 * <ul> 5893 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} 5894 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5895 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5896 * <li>{@code String} property type 5897 * </ul> 5898 * 5899 * @hide 5900 */ 5901 public static final int CURRENT_POWER_POLICY = 286265123; 5902 5903 /** 5904 * Property to report that car watchdog is alive. 5905 * 5906 * <p>Doesn't require permission because it's not exposed through 5907 * {@link android.car.hardware.property.CarPropertyManager}. 5908 * 5909 * <p>Property Config: 5910 * <ul> 5911 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 5912 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5913 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5914 * <li>{@code Long} property type 5915 * </ul> 5916 * 5917 * @hide 5918 */ 5919 public static final int WATCHDOG_ALIVE = 290459441; 5920 5921 /** 5922 * Property to report a process terminated by car watchdog. 5923 * 5924 * <p>Doesn't require permission because it's not exposed through 5925 * {@link android.car.hardware.property.CarPropertyManager}. 5926 * 5927 * <p>Property Config: 5928 * <ul> 5929 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 5930 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5931 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5932 * <li>{@code Object[]} property type 5933 * </ul> 5934 * 5935 * @hide 5936 */ 5937 public static final int WATCHDOG_TERMINATED_PROCESS = 299896626; 5938 5939 /** 5940 * Property to signal a heartbeat from VHAL. 5941 * 5942 * <p>Doesn't require permission because it's not exposed through 5943 * {@link android.car.hardware.property.CarPropertyManager}. 5944 * 5945 * <p>Property Config: 5946 * <ul> 5947 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5948 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5949 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5950 * <li>{@code Long} property type 5951 * </ul> 5952 * 5953 * @hide 5954 */ 5955 public static final int VHAL_HEARTBEAT = 290459443; 5956 5957 /** 5958 * Property to start the ClusterUI in cluster display. 5959 * 5960 * <p>Doesn't require permission because it's not exposed through 5961 * {@link android.car.hardware.property.CarPropertyManager}. 5962 * 5963 * <p>Property Config: 5964 * <ul> 5965 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5966 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5967 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5968 * <li>{@code Integer} property type 5969 * </ul> 5970 * 5971 * @hide 5972 */ 5973 public static final int CLUSTER_SWITCH_UI = 289410868; 5974 5975 /** 5976 * Property to change the state of the cluster display. 5977 * 5978 * <p>Doesn't require permission because it's not exposed through 5979 * {@link android.car.hardware.property.CarPropertyManager}. 5980 * 5981 * <p>Property Config: 5982 * <ul> 5983 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 5984 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 5985 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 5986 * <li>{@code Integer[]} property type 5987 * </ul> 5988 * 5989 * @hide 5990 */ 5991 public static final int CLUSTER_DISPLAY_STATE = 289476405; 5992 5993 /** 5994 * Property to reports the current display and ClusterUI statue. 5995 * 5996 * <p>Doesn't require permission because it's not exposed through 5997 * {@link android.car.hardware.property.CarPropertyManager}. 5998 * 5999 * <p>Property Config: 6000 * <ul> 6001 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 6002 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6003 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6004 * <li>{@code Object[]} property type 6005 * </ul> 6006 * 6007 * @hide 6008 */ 6009 public static final int CLUSTER_REPORT_STATE = 299896630; 6010 6011 /** 6012 * Property to request to change the cluster display state to show some ClusterUI. 6013 * 6014 * <p>Doesn't require permission because it's not exposed through 6015 * {@link android.car.hardware.property.CarPropertyManager}. 6016 * 6017 * <p>Property Config: 6018 * <ul> 6019 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 6020 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6021 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6022 * <li>{@code Integer} property type 6023 * </ul> 6024 * 6025 * @hide 6026 */ 6027 public static final int CLUSTER_REQUEST_DISPLAY = 289410871; 6028 6029 /** 6030 * Property to inform the current navigation state. 6031 * 6032 * <p>Doesn't require permission because it's not exposed through 6033 * {@link android.car.hardware.property.CarPropertyManager}. 6034 * 6035 * <p>Property Config: 6036 * <ul> 6037 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 6038 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6039 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6040 * <li>{@code byte[]} property type 6041 * </ul> 6042 * 6043 * @hide 6044 */ 6045 public static final int CLUSTER_NAVIGATION_STATE = 292556600; 6046 6047 /** 6048 * Property to send the heartbeat signal to ClusterOS. 6049 * 6050 * <p>Doesn't require permission because it's not exposed through 6051 * {@link android.car.hardware.property.CarPropertyManager}. 6052 * 6053 * <p>Property Config: 6054 * <ul> 6055 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 6056 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6057 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6058 * <li>{@code Object[]} property type 6059 * </ul> 6060 * 6061 * @hide 6062 */ 6063 public static final int CLUSTER_HEARTBEAT = 299896651; 6064 6065 /** 6066 * Current date and time, encoded as Unix time. 6067 * 6068 * <p>This value denotes the number of milliseconds that have elapsed since 1/1/1970 UTC. 6069 * 6070 * <p>Property Config: 6071 * <ul> 6072 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 6073 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6074 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6075 * <li>{@code Long} property type 6076 * </ul> 6077 * 6078 * <p>Required Permission: 6079 * <ul> 6080 * <li>Property is not readable. 6081 * <li>Signature|Privileged permission {@link Car#PERMISSION_CAR_EPOCH_TIME} to write 6082 * property. 6083 * </ul> 6084 */ 6085 @RequiresPermission(Car.PERMISSION_CAR_EPOCH_TIME) 6086 public static final int EPOCH_TIME = 290457094; 6087 6088 /** 6089 * Electronic Toll Collection card type. 6090 * 6091 * <p>This property indicates the type of ETC(Electronic Toll Collection) card in the vehicle. 6092 * If the head unit is aware of an ETC card attached to the vehicle, this property should return 6093 * the type of card attached; otherwise, this property should be UNAVAILABLE. The property value 6094 * should be one of {@link VehicleElectronicTollCollectionCardType}. 6095 * 6096 * <p>Property Config: 6097 * <ul> 6098 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6099 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6100 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6101 * <li>{@code Integer} property type 6102 * </ul> 6103 * 6104 * <p>Required Permission: 6105 * <ul> 6106 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 6107 * <li>Property is not writable. 6108 * </ul> 6109 * 6110 * @data_enum {@link VehicleElectronicTollCollectionCardType} 6111 */ 6112 @RequiresPermission(Car.PERMISSION_CAR_INFO) 6113 public static final int ELECTRONIC_TOLL_COLLECTION_CARD_TYPE = 289410873; 6114 6115 /** 6116 * Electronic Toll Collection card status. 6117 * 6118 * <p>This property indicates the status of ETC(Electronic Toll Collection) card in the vehicle. 6119 * If the head unit is aware of an ETC card attached to the vehicle, ETC_CARD_STATUS gives that 6120 * status of the card; otherwise, this property should be UNAVAILABLE. The property value should 6121 * be one of {@link VehicleElectronicTollCollectionCardStatus}. 6122 * 6123 * <p>Property Config: 6124 * <ul> 6125 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6126 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6127 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6128 * <li>{@code Integer} property type 6129 * </ul> 6130 * 6131 * <p>Required Permission: 6132 * <ul> 6133 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 6134 * <li>Property is not writable. 6135 * </ul> 6136 * 6137 * @data_enum {@link VehicleElectronicTollCollectionCardStatus} 6138 */ 6139 @RequiresPermission(Car.PERMISSION_CAR_INFO) 6140 public static final int ELECTRONIC_TOLL_COLLECTION_CARD_STATUS = 289410874; 6141 6142 /** 6143 * Front fog lights state. 6144 * 6145 * <p>Please refer to the documentation on {@link #FOG_LIGHTS_STATE} for more information. 6146 * 6147 * <p>Property Config: 6148 * <ul> 6149 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6150 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6151 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6152 * <li>{@code Integer} property type 6153 * </ul> 6154 * 6155 * <p>Required Permission: 6156 * <ul> 6157 * <li>Signature|Privileged permission {@link Car#PERMISSION_EXTERIOR_LIGHTS} to read 6158 * property. 6159 * <li>Property is not writable. 6160 * </ul> 6161 * 6162 * @data_enum {@link VehicleLightState} 6163 */ 6164 @RequiresPermission(Car.PERMISSION_EXTERIOR_LIGHTS) 6165 public static final int FRONT_FOG_LIGHTS_STATE = 289410875; 6166 6167 /** 6168 * Front fog lights switch. 6169 * 6170 * <p>Please refer to the documentation on {@link #FOG_LIGHTS_SWITCH} for more information. 6171 * 6172 * <p>Property Config: 6173 * <ul> 6174 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6175 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6176 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6177 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6178 * <li>{@code Integer} property type 6179 * </ul> 6180 * 6181 * <p>Required Permission: 6182 * <ul> 6183 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_EXTERIOR_LIGHTS} to 6184 * read and write property. 6185 * </ul> 6186 * 6187 * @data_enum {@link VehicleLightSwitch} 6188 */ 6189 @RequiresPermission(Car.PERMISSION_CONTROL_EXTERIOR_LIGHTS) 6190 public static final int FRONT_FOG_LIGHTS_SWITCH = 289410876; 6191 6192 /** 6193 * Rear fog lights state. 6194 * 6195 * <p>Please refer to the documentation on {@link #FOG_LIGHTS_STATE} for more information. 6196 * 6197 * <p>Property Config: 6198 * <ul> 6199 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6200 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6201 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6202 * <li>{@code Integer} property type 6203 * </ul> 6204 * 6205 * <p>Required Permission: 6206 * <ul> 6207 * <li>Signature|Privileged permission {@link Car#PERMISSION_EXTERIOR_LIGHTS} to read 6208 * property. 6209 * <li>Property is not writable. 6210 * </ul> 6211 * 6212 * @data_enum {@link VehicleLightState} 6213 */ 6214 @RequiresPermission(Car.PERMISSION_EXTERIOR_LIGHTS) 6215 public static final int REAR_FOG_LIGHTS_STATE = 289410877; 6216 6217 /** 6218 * Rear fog lights switch. 6219 * 6220 * <p>Please refer to the documentation on {@link #FOG_LIGHTS_SWITCH} for more information. 6221 * 6222 * <p>Property Config: 6223 * <ul> 6224 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6225 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6226 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6227 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6228 * <li>{@code Integer} property type 6229 * </ul> 6230 * 6231 * <p>Required Permission: 6232 * <ul> 6233 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_EXTERIOR_LIGHTS} to 6234 * read and write property. 6235 * </ul> 6236 * 6237 * @data_enum {@link VehicleLightSwitch} 6238 */ 6239 @RequiresPermission(Car.PERMISSION_CONTROL_EXTERIOR_LIGHTS) 6240 public static final int REAR_FOG_LIGHTS_SWITCH = 289410878; 6241 6242 /** 6243 * The vehicle's selected alternating current (AC) EV charging draw limit in Amperes. 6244 * 6245 * <p>This may or may not match the vehicle's maximum possible draw limit. This maximum draw 6246 * limit in Amperes is listed in the first entry in its 6247 * {@link CarPropertyConfig#getConfigArray()}. 6248 * 6249 * <p>If property is writable, the user may adjust this value. 6250 * 6251 * <p>Property Config: 6252 * <ul> 6253 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6254 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6255 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6256 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6257 * <li>{@code Float} property type 6258 * </ul> 6259 * 6260 * <p>Required Permissions: 6261 * <ul> 6262 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} or Signature|Privileged permission 6263 * {@link Car#PERMISSION_CONTROL_CAR_ENERGY} to read property. 6264 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_ENERGY} to write 6265 * property. 6266 * </ul> 6267 */ 6268 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_ENERGY, 6269 Car.PERMISSION_CONTROL_CAR_ENERGY})) 6270 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_CAR_ENERGY)) 6271 public static final int EV_CHARGE_CURRENT_DRAW_LIMIT = 291508031; 6272 6273 /** 6274 * EV charge percent limit. 6275 * 6276 * <p>Indicates the maximum charge percent threshold set by the user. Returns a float value 6277 * from 0 to 100. 6278 * 6279 * <p>configArray is optional. If it is populated, it represents the valid charge percent limit 6280 * values for the vehicle. Here is an example configArray: 6281 * <ul> 6282 * <li>configArray[0] = 20 6283 * <li>configArray[1] = 40 6284 * <li>configArray[2] = 60 6285 * <li>configArray[3] = 80 6286 * </ul> 6287 * 6288 * <p>Property Config: 6289 * <ul> 6290 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6291 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6292 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6293 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6294 * <li>{@code Float} property type 6295 * </ul> 6296 * 6297 * <p>Required Permissions: 6298 * <ul> 6299 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} or Signature|Privileged permission 6300 * {@link Car#PERMISSION_CONTROL_CAR_ENERGY} to read property. 6301 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_ENERGY} to write 6302 * property. 6303 * </ul> 6304 */ 6305 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_ENERGY, 6306 Car.PERMISSION_CONTROL_CAR_ENERGY})) 6307 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_CAR_ENERGY)) 6308 public static final int EV_CHARGE_PERCENT_LIMIT = 291508032; 6309 6310 /** 6311 * Charging state of the car. 6312 * 6313 * <p>Returns the current charging state of the car. See {@link 6314 * android.car.hardware.property.EvChargeState} for possible values for {@code EV_CHARGE_STATE}. 6315 * 6316 * <p>If the vehicle has a target charge percentage other than 100, this property will return 6317 * {@link EvChargeState#STATE_FULLY_CHARGED} when the battery charge level has reached the 6318 * target level. See {@link #EV_CHARGE_PERCENT_LIMIT} for more context. 6319 * 6320 * <p>Property Config: 6321 * <ul> 6322 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6323 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6324 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6325 * <li>{@code Integer} property type 6326 * </ul> 6327 * 6328 * <p>Required Permission: 6329 * <ul> 6330 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} to read property. 6331 * <li>Property is not writable. 6332 * </ul> 6333 * 6334 * @data_enum {@link EvChargeState} 6335 */ 6336 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_ENERGY)) 6337 public static final int EV_CHARGE_STATE = 289410881; 6338 6339 /** 6340 * Start or stop charging the EV battery. 6341 * 6342 * <p>The setting that the user wants. Setting this property to true starts the battery charging 6343 * and setting to false stops charging. 6344 * 6345 * <p>Property Config: 6346 * <ul> 6347 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6348 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6349 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6350 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6351 * <li>{@code Boolean} property type 6352 * </ul> 6353 * 6354 * <p>Required Permission: 6355 * <ul> 6356 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_ENERGY} or 6357 * dangerous permission {@link Car#PERMISSION_ENERGY} to read. 6358 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_CAR_ENERGY} to write 6359 * property. 6360 * </ul> 6361 */ 6362 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_ENERGY, 6363 Car.PERMISSION_CONTROL_CAR_ENERGY})) 6364 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_CAR_ENERGY)) 6365 public static final int EV_CHARGE_SWITCH = 287313730; 6366 6367 /** 6368 * Estimated charge time remaining in seconds. 6369 * 6370 * <p>Returns 0 if the vehicle is not charging. 6371 * 6372 * <p>Property Config: 6373 * <ul> 6374 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6375 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6376 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 6377 * <li>{@code Integer} property type 6378 * </ul> 6379 * 6380 * <p>Required Permission: 6381 * <ul> 6382 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} to read property. 6383 * <li>Property is not writable. 6384 * </ul> 6385 */ 6386 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_ENERGY)) 6387 public static final int EV_CHARGE_TIME_REMAINING = 289410883; 6388 6389 /** 6390 * Regenerative braking or one-pedal drive setting on the car. 6391 * 6392 * <p>Returns the current state associated with the regenerative braking 6393 * setting in the car. See {@link android.car.hardware.property.EvRegenerativeBrakingState} for 6394 * possible values for {@code EV_REGENERATIVE_BRAKING_STATE}. 6395 * 6396 * <p>If the {@link #EV_BRAKE_REGENERATION_LEVEL} property has been implemented, it is likely 6397 * that the OEM supports a more granular set of regeneration levels than those provided by this 6398 * property through {@link EvRegenerativeBrakingState}. 6399 * 6400 * <p>Property Config: 6401 * <ul> 6402 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6403 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6404 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6405 * <li>{@code Integer} property type 6406 * </ul> 6407 * 6408 * <p>Required Permission: 6409 * <ul> 6410 * <li>Dangerous permission {@link Car#PERMISSION_ENERGY} to read property. 6411 * <li>Property is not writable. 6412 * </ul> 6413 * 6414 * @data_enum {@link EvRegenerativeBrakingState} 6415 */ 6416 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_ENERGY)) 6417 public static final int EV_REGENERATIVE_BRAKING_STATE = 289410884; 6418 6419 /** 6420 * Vehicle’s curb weight in kilograms. 6421 * 6422 * <p>Returns the vehicle's curb weight in kilograms. This is the total weight of a vehicle, 6423 * inclusive of standard equipment and necessary operating fluids such as motor oil, 6424 * transmission oil and brake fluid, but without passengers or cargo. configArray[0] specifies 6425 * the vehicle’s gross weight in kilograms. This is the vehicle curb weight plus the maximum 6426 * payload (passengers + cargo) the vehicle can support. 6427 * 6428 * <p>Property Config: 6429 * <ul> 6430 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6431 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6432 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 6433 * <li>{@code Integer} property type 6434 * </ul> 6435 * 6436 * <p>Required Permission: 6437 * <ul> 6438 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} or Signature|Privileged permission 6439 * {@link Car#PERMISSION_PRIVILEGED_CAR_INFO} to read property. 6440 * <li>Property is not writable. 6441 * </ul> 6442 */ 6443 @FlaggedApi(FLAG_VEHICLE_PROPERTY_25Q2_3P_PERMISSIONS) 6444 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_CAR_INFO, 6445 Car.PERMISSION_PRIVILEGED_CAR_INFO})) 6446 public static final int VEHICLE_CURB_WEIGHT = 289410886; 6447 6448 /** 6449 * Indicates if there is a trailer present or not. 6450 * 6451 * <p>Returns the trailer state of the car. See {@code TrailerState} for possible values for 6452 * {@code TRAILER_PRESENT}. 6453 * 6454 * <p>Property Config: 6455 * <ul> 6456 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6457 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6458 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6459 * <li>{@code Integer} property type 6460 * </ul> 6461 * 6462 * <p>Required Permission: 6463 * <ul> 6464 * <li>Signature|Privileged permission {@link Car#PERMISSION_PRIVILEGED_CAR_INFO} to read 6465 * property. 6466 * <li>Property is not writable. 6467 * </ul> 6468 * 6469 * @data_enum {@link TrailerState} 6470 */ 6471 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_PRIVILEGED_CAR_INFO)) 6472 public static final int TRAILER_PRESENT = 289410885; 6473 6474 /** 6475 * EU's General security regulation compliance requirement. 6476 * 6477 * <p>Returns whether general security regulation compliance is required, if 6478 * so, what type of requirement. See {@link GsrComplianceType} for possible enums. 6479 * 6480 * <p>Property Config: 6481 * <ul> 6482 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6483 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6484 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_STATIC} 6485 * <li>{@code Integer} property type 6486 * </ul> 6487 * 6488 * <p>Required Permission: 6489 * <ul> 6490 * <li>Normal permission {@link Car#PERMISSION_CAR_INFO} to read property. 6491 * <li>Property is not writable. 6492 * </ul> 6493 * 6494 * @data_enum {@link GsrComplianceType} 6495 */ 6496 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_CAR_INFO)) 6497 public static final int GENERAL_SAFETY_REGULATION_COMPLIANCE = 289410887; 6498 6499 /** 6500 * Current state of vehicle autonomy. 6501 * 6502 * <p>Defines the level of autonomy currently engaged in the vehicle from the J3016_202104 6503 * revision of the SAE standard levels 0-5, with 0 representing no autonomy and 5 representing 6504 * full driving automation. 6505 * 6506 * <p>For the global area ID (0), the {@link 6507 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 6508 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 6509 * from {@link android.car.hardware.property.VehicleAutonomousState} are supported. 6510 * 6511 * <p>Property Config: 6512 * <ul> 6513 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6514 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6515 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6516 * <li>{@code Integer} property type 6517 * </ul> 6518 * 6519 * <p>Required Permission: 6520 * <ul> 6521 * <li>Dangerous permission {@link Car#PERMISSION_CAR_DRIVING_STATE_3P} or Signature|Privileged 6522 * permission {@link Car#PERMISSION_CAR_DRIVING_STATE} to read property. 6523 * <li>Property is not writable. 6524 * </ul> 6525 * 6526 * @data_enum {@link android.car.hardware.property.VehicleAutonomousState} 6527 */ 6528 @FlaggedApi(FLAG_VEHICLE_PROPERTY_25Q2_3P_PERMISSIONS) 6529 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_CAR_DRIVING_STATE_3P, 6530 Car.PERMISSION_CAR_DRIVING_STATE})) 6531 public static final int VEHICLE_DRIVING_AUTOMATION_CURRENT_LEVEL = 289410892; 6532 /** 6533 * Target state of vehicle autonomy. 6534 * 6535 * <p>Defines the level of autonomy being targeted by the vehicle from the J3016_202104 revision 6536 * of the SAE standard levels 0-5, with 0 representing no autonomy and 5 representing full 6537 * driving automation. 6538 * 6539 * <p>For example, suppose the vehicle is currently in a Level 3 state of automation and wants 6540 * to give the driver full manual control (i.e. Level 0) as soon as it's safe to do so. In this 6541 * scenario, this property will be set to {@link 6542 * android.car.hardware.property.VehicleAutonomousState#LEVEL_0}. Similarly, if the vehicle is 6543 * currently in Level 1 state of automation and wants to go up to Level 2, this property will be 6544 * set to {@link android.car.hardware.property.VehicleAutonomousState#LEVEL_2}. If the vehicle 6545 * has already reached and is currently in the target level of autonomy, this property will be 6546 * equal to the value of {@link #VEHICLE_DRIVING_AUTOMATION_CURRENT_LEVEL}. 6547 * 6548 * <p>For the global area ID (0), the {@link 6549 * android.car.hardware.property.CarPropertyManager#getSupportedValuesList(int, int)} array 6550 * specifies which states from {@link android.car.hardware.property.VehicleAutonomousState} are 6551 * supported. This will always match the value specified by {@link 6552 * android.car.hardware.property.CarPropertyManager#getSupportedValuesList(int, int)} for 6553 * {@link #VEHICLE_DRIVING_AUTOMATION_CURRENT_LEVEL}. 6554 * 6555 * <p>For the property that communicates the current state of autonomy, see 6556 * {@link #VEHICLE_DRIVING_AUTOMATION_CURRENT_LEVEL}. 6557 * 6558 * <p>Property Config: 6559 * <ul> 6560 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6561 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6562 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6563 * <li>{@code Integer} property type 6564 * </ul> 6565 * 6566 * <p>Required Permission: 6567 * <ul> 6568 * <li>Signature|Privileged permission "android.car.permission.CAR_DRIVING_STATE" to read 6569 * property. 6570 * <li>Property is not writable. 6571 * </ul> 6572 * 6573 * @data_enum {@link android.car.hardware.property.VehicleAutonomousState} 6574 */ 6575 @FlaggedApi(FLAG_ANDROID_B_VEHICLE_PROPERTIES) 6576 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_CAR_DRIVING_STATE)) 6577 public static final int VEHICLE_DRIVING_AUTOMATION_TARGET_LEVEL = 289410895; 6578 /** 6579 * Enable or disable Automatic Emergency Braking (AEB). 6580 * 6581 * <p>Returns true if AEB is enabled and false if AEB is disabled. When AEB is enabled, the ADAS 6582 * system in the vehicle should be turned on and monitoring to avoid potential collisions. This 6583 * property applies for higher speed applications only. For enabling low speed automatic 6584 * emergency braking, {@link LOW_SPEED_AUTOMATIC_EMERGENCY_BRAKING_ENABLED} will be used. 6585 * 6586 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 6587 * only. 6588 * 6589 * <p>Property Config: 6590 * <ul> 6591 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6592 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6593 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6594 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6595 * <li>{@code Boolean} property type 6596 * </ul> 6597 * 6598 * <p>Required Permissions: 6599 * <ul> 6600 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 6601 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 6602 * property. 6603 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 6604 * property. 6605 * </ul> 6606 */ 6607 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6608 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 6609 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 6610 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 6611 public static final int AUTOMATIC_EMERGENCY_BRAKING_ENABLED = 287313920; 6612 6613 /** 6614 * Automatic Emergency Braking (AEB) state. 6615 * 6616 * <p>Returns the current state of AEB. This property will always return a valid state defined 6617 * in {@link android.car.hardware.property.AutomaticEmergencyBrakingState} or {@link 6618 * android.car.hardware.property.ErrorState}. This property should apply for higher speed 6619 * applications only. For representing the state of the low speed automatic emergency braking 6620 * system, {@link LOW_SPEED_AUTOMATIC_EMERGENCY_BRAKING_STATE} should be used. 6621 * 6622 * <p>If AEB includes forward collision warnings before activating the brakes, those warnings 6623 * will be surfaced through the Forward Collision Warning (FCW) properties. 6624 * 6625 * <p>For the global area ID (0), the {@link 6626 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 6627 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 6628 * from {@link android.car.hardware.property.AutomaticEmergencyBrakingState} and {@link 6629 * android.car.hardware.property.ErrorState} are supported. 6630 * 6631 * <p>Property Config: 6632 * <ul> 6633 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6634 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6635 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6636 * <li>{@code Integer} property type 6637 * </ul> 6638 * 6639 * <p>Required Permission: 6640 * <ul> 6641 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 6642 * property. 6643 * <li>Property is not writable. 6644 * </ul> 6645 * 6646 * @data_enum {@link AutomaticEmergencyBrakingState} 6647 * @data_enum {@link ErrorState} 6648 */ 6649 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6650 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 6651 public static final int AUTOMATIC_EMERGENCY_BRAKING_STATE = 289411073; 6652 6653 /** 6654 * Enable or disable Forward Collision Warning (FCW). 6655 * 6656 * <p>Returns true if FCW is enabled and false if FCW is disabled. When FCW is enabled, the ADAS 6657 * system in the vehicle should be turned on and monitoring for potential collisions. 6658 * 6659 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 6660 * only. 6661 * 6662 * <p>Property Config: 6663 * <ul> 6664 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6665 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6666 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6667 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6668 * <li>{@code Boolean} property type 6669 * </ul> 6670 * 6671 * <p>Required Permissions: 6672 * <ul> 6673 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 6674 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 6675 * property. 6676 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 6677 * property. 6678 * </ul> 6679 */ 6680 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6681 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 6682 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 6683 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 6684 public static final int FORWARD_COLLISION_WARNING_ENABLED = 287313922; 6685 6686 /** 6687 * Forward Collision Warning State (FCW) state. 6688 * 6689 * <p>Returns the current state of FCW. This property will always return a valid state defined 6690 * in {@link android.car.hardware.property.ForwardCollisionWarningState} or {@link 6691 * android.car.hardware.property.ErrorState}. 6692 * 6693 * <p>For the global area ID (0), the {@link 6694 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 6695 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 6696 * from {@link android.car.hardware.property.ForwardCollisionWarningState} and {@link 6697 * android.car.hardware.property.ErrorState} are supported. 6698 * 6699 * <p>Property Config: 6700 * <ul> 6701 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6702 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6703 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6704 * <li>{@code Integer} property type 6705 * </ul> 6706 * 6707 * <p>Required Permission: 6708 * <ul> 6709 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 6710 * property. 6711 * <li>Property is not writable. 6712 * </ul> 6713 * 6714 * @data_enum {@link ForwardCollisionWarningState} 6715 * @data_enum {@link ErrorState} 6716 */ 6717 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6718 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 6719 public static final int FORWARD_COLLISION_WARNING_STATE = 289411075; 6720 6721 /** 6722 * Enable and disable Blind Spot Warning (BSW). 6723 * 6724 * <p>Returns true if BSW is enabled and false if BSW is disabled. When BSW is enabled, the ADAS 6725 * system in the vehicle should be turned on and monitoring for objects in the vehicle’s blind 6726 * spots. 6727 * 6728 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 6729 * only. 6730 * 6731 * <p>Property Config: 6732 * <ul> 6733 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6734 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6735 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6736 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6737 * <li>{@code Boolean} property type 6738 * </ul> 6739 * 6740 * <p>Required Permissions: 6741 * <ul> 6742 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 6743 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 6744 * property. 6745 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 6746 * property. 6747 * </ul> 6748 */ 6749 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6750 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 6751 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 6752 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 6753 public static final int BLIND_SPOT_WARNING_ENABLED = 287313924; 6754 6755 /** 6756 * Blind Spot Warning (BSW) state. 6757 * 6758 * <p>Returns the current state of BSW. This property will always return a valid state defined 6759 * in {@link android.car.hardware.property.BlindSpotWarningState} or {@link 6760 * android.car.hardware.property.ErrorState}. 6761 * 6762 * <p>For the global area ID (0), the {@link 6763 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 6764 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 6765 * from {@link android.car.hardware.property.BlindSpotWarningState} and {@link 6766 * android.car.hardware.property.ErrorState} are supported. 6767 * 6768 * <p>Property Config: 6769 * <ul> 6770 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6771 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_MIRROR} 6772 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6773 * <li>{@code Integer} property type 6774 * </ul> 6775 * 6776 * <p>Required Permission: 6777 * <ul> 6778 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 6779 * property. 6780 * <li>Property is not writable. 6781 * </ul> 6782 * 6783 * @data_enum {@link BlindSpotWarningState} 6784 * @data_enum {@link ErrorState} 6785 */ 6786 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6787 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 6788 public static final int BLIND_SPOT_WARNING_STATE = 339742725; 6789 6790 /** 6791 * Enable or disable Lane Departure Warning (LDW). 6792 * 6793 * <p>Returns true if LDW is enabled and false if LDW is disabled. When LDW is enabled, the ADAS 6794 * system in the vehicle should be turned on and monitoring if the vehicle is approaching or 6795 * crossing lane lines, in which case a warning will be given. 6796 * 6797 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 6798 * only. 6799 * 6800 * <p>Property Config: 6801 * <ul> 6802 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6803 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6804 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6805 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6806 * <li>{@code Boolean} property type 6807 * </ul> 6808 * 6809 * <p>Required Permissions: 6810 * <ul> 6811 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 6812 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 6813 * property. 6814 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 6815 * property. 6816 * </ul> 6817 */ 6818 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6819 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 6820 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 6821 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 6822 public static final int LANE_DEPARTURE_WARNING_ENABLED = 287313926; 6823 6824 /** 6825 * Lane Departure Warning (LDW) state. 6826 * 6827 * <p>Returns the current state of LDW. This property will always return a valid state defined 6828 * in {@link android.car.hardware.property.LaneDepartureWarningState} or {@link 6829 * android.car.hardware.property.ErrorState}. 6830 * 6831 * <p>For the global area ID (0), the {@link 6832 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 6833 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 6834 * from {@link android.car.hardware.property.LaneDepartureWarningState} and {@link 6835 * android.car.hardware.property.ErrorState} are supported. 6836 * 6837 * <p>Property Config: 6838 * <ul> 6839 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6840 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6841 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6842 * <li>{@code Integer} property type 6843 * </ul> 6844 * 6845 * <p>Required Permission: 6846 * <ul> 6847 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 6848 * property. 6849 * <li>Property is not writable. 6850 * </ul> 6851 * 6852 * @data_enum {@link LaneDepartureWarningState} 6853 * @data_enum {@link ErrorState} 6854 */ 6855 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6856 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 6857 public static final int LANE_DEPARTURE_WARNING_STATE = 289411079; 6858 6859 /** 6860 * Enable or disable Lane Keep Assist (LKA). 6861 * 6862 * <p>Returns true if LKA is enabled and false if LKA is disabled. When LKA is enabled, the ADAS 6863 * system in the vehicle should be turned on and monitoring if the driver unintentionally drifts 6864 * toward or over the lane marking. If an unintentional lane departure is detected, the system 6865 * applies steering control to return the vehicle into the current lane. 6866 * 6867 * <p>This is different from Lane Centering Assist (LCA) which, when activated, applies 6868 * continuous steering control to keep the vehicle centered in the current lane. 6869 * 6870 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 6871 * only. 6872 * 6873 * <p>Property Config: 6874 * <ul> 6875 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6876 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6877 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6878 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6879 * <li>{@code Boolean} property type 6880 * </ul> 6881 * 6882 * <p>Required Permissions: 6883 * <ul> 6884 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 6885 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 6886 * property. 6887 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 6888 * property. 6889 * </ul> 6890 */ 6891 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6892 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 6893 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 6894 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 6895 public static final int LANE_KEEP_ASSIST_ENABLED = 287313928; 6896 6897 /** 6898 * Lane Keep Assist (LKA) state. 6899 * 6900 * <p>Returns the current state of LKA. This property will always return a valid state defined 6901 * in {@link android.car.hardware.property.LaneKeepAssistState} or {@link 6902 * android.car.hardware.property.ErrorState}. 6903 * 6904 * <p>If LKA includes lane departure warnings before applying steering corrections, those 6905 * warnings will be surfaced through {@link #LANE_DEPARTURE_WARNING_STATE}. 6906 * 6907 * <p>For the global area ID (0), the {@link 6908 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 6909 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 6910 * from {@link android.car.hardware.property.LaneKeepAssistState} and {@link 6911 * android.car.hardware.property.ErrorState} are supported. 6912 * 6913 * <p>Property Config: 6914 * <ul> 6915 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6916 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6917 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6918 * <li>{@code Integer} property type 6919 * </ul> 6920 * 6921 * <p>Required Permission: 6922 * <ul> 6923 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 6924 * property. 6925 * <li>Property is not writable. 6926 * </ul> 6927 * 6928 * @data_enum {@link LaneKeepAssistState} 6929 * @data_enum {@link ErrorState} 6930 */ 6931 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6932 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 6933 public static final int LANE_KEEP_ASSIST_STATE = 289411081; 6934 6935 /** 6936 * Enable or disable Lane Centering Assist (LCA). 6937 * 6938 * <p>Returns true if LCA is enabled and false if LCA is disabled. When LCA is enabled, the ADAS 6939 * system in the vehicle should be turned on and waiting for an activation signal from the 6940 * driver. Once the feature is activated, the ADAS system should be steering the vehicle to keep 6941 * it centered in its current lane. 6942 * 6943 * <p>This is different from Lane Keep Assist (LKA) which monitors if the driver unintentionally 6944 * drifts toward or over the lane marking. If an unintentional lane departure is detected, the 6945 * system applies steering control to return the vehicle into the current lane. 6946 * 6947 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 6948 * only. 6949 * 6950 * <p>Property Config: 6951 * <ul> 6952 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 6953 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 6954 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 6955 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 6956 * <li>{@code Boolean} property type 6957 * </ul> 6958 * 6959 * <p>Required Permissions: 6960 * <ul> 6961 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 6962 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 6963 * property. 6964 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 6965 * property. 6966 * </ul> 6967 */ 6968 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 6969 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 6970 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 6971 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 6972 public static final int LANE_CENTERING_ASSIST_ENABLED = 287313930; 6973 6974 /** 6975 * Lane Centering Assist (LCA) commands. 6976 * 6977 * <p>Commands to activate and suspend LCA. They are only valid when {@link 6978 * #LANE_CENTERING_ASSIST_ENABLED} = {@code true}. Otherwise, these commands will throw a {@link 6979 * android.car.hardware.property.PropertyNotAvailableException}. 6980 * 6981 * <p>When the command {@link android.car.hardware.property.LaneCenteringAssistCommand#ACTIVATE} 6982 * is sent, {@link #LANE_CENTERING_ASSIST_STATE} will be set to {@link 6983 * android.car.hardware.property.LaneCenteringAssistState#ACTIVATION_REQUESTED}. When the 6984 * command {@link android.car.hardware.property.LaneCenteringAssistCommand#ACTIVATE} succeeds, 6985 * {@link #LANE_CENTERING_ASSIST_STATE} will be set to {@link 6986 * android.car.hardware.property.LaneCenteringAssistState#ACTIVATED}. When the command {@link 6987 * android.car.hardware.property.LaneCenteringAssistCommand#DEACTIVATE} succeeds, {@link 6988 * #LANE_CENTERING_ASSIST_STATE} will be set to {@link 6989 * android.car.hardware.property.LaneCenteringAssistState#ENABLED}. 6990 * 6991 * <p>For the global area ID (0), the {@link 6992 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 6993 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which enum 6994 * values from {@link android.car.hardware.property.LaneCenteringAssistCommand} are supported. 6995 * 6996 * <p>Property Config: 6997 * <ul> 6998 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 6999 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7000 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7001 * <li>{@code Integer} property type 7002 * </ul> 7003 * 7004 * <p>Required Permission: 7005 * <ul> 7006 * <li>Property is not readable. 7007 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_STATES} to write 7008 * property. 7009 * </ul> 7010 * 7011 * @data_enum {@link LaneCenteringAssistCommand} 7012 */ 7013 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7014 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_STATES)) 7015 public static final int LANE_CENTERING_ASSIST_COMMAND = 289411083; 7016 7017 /** 7018 * Lane Centering Assist (LCA) state. 7019 * 7020 * <p>Returns the current state of LCA. This property will always return a valid state defined 7021 * in {@link android.car.hardware.property.LaneCenteringAssistState} or {@link 7022 * android.car.hardware.property.ErrorState}. 7023 * 7024 * <p>If LCA includes lane departure warnings, those warnings will be surfaced through the Lane 7025 * Departure Warning (LDW) properties. 7026 * 7027 * <p>For the global area ID (0), the {@link 7028 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7029 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7030 * from {@link android.car.hardware.property.LaneCenteringAssistState} and {@link 7031 * android.car.hardware.property.ErrorState} are supported. 7032 * 7033 * <p>Property Config: 7034 * <ul> 7035 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7036 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7037 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7038 * <li>{@code Integer} property type 7039 * </ul> 7040 * 7041 * <p>Required Permission: 7042 * <ul> 7043 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 7044 * property. 7045 * <li>Property is not writable. 7046 * </ul> 7047 * 7048 * @data_enum {@link LaneCenteringAssistState} 7049 * @data_enum {@link ErrorState} 7050 */ 7051 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7052 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 7053 public static final int LANE_CENTERING_ASSIST_STATE = 289411084; 7054 7055 /** 7056 * Enable or disable Emergency Lane Keep Assist (ELKA). 7057 * 7058 * <p>Return true if ELKA is enabled and false if ELKA is disabled. When ELKA is enabled, the 7059 * ADAS system in the vehicle should be on and monitoring for unsafe lane changes by the driver. 7060 * When an unsafe maneuver is detected, ELKA alerts the driver and applies steering corrections 7061 * to keep the vehicle in its original lane. 7062 * 7063 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 7064 * only. 7065 * 7066 * <p>Property Config: 7067 * <ul> 7068 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7069 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7070 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7071 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7072 * <li>{@code Boolean} property type 7073 * </ul> 7074 * 7075 * <p>Required Permissions: 7076 * <ul> 7077 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 7078 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 7079 * property. 7080 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 7081 * property. 7082 * </ul> 7083 */ 7084 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7085 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 7086 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 7087 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 7088 public static final int EMERGENCY_LANE_KEEP_ASSIST_ENABLED = 287313933; 7089 7090 /** 7091 * Emergency Lane Keep Assist (ELKA) state. 7092 * 7093 * <p>Returns the current state of ELKA. Generally, this property should return a valid state 7094 * defined in the {@link android.car.hardware.property.EmergencyLaneKeepAssistState} or {@link 7095 * android.car.hardware.property.ErrorState}. For example, if the feature is not available due 7096 * to some temporary state, that information should be conveyed through {@link 7097 * android.car.hardware.property.ErrorState}. 7098 * 7099 * <p>For the global area ID (0), the {@link 7100 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7101 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7102 * from {@link android.car.hardware.property.EmergencyLaneKeepAssistState} and {@link 7103 * android.car.hardware.property.ErrorState} are supported. 7104 * 7105 * <p>Property Config: 7106 * <ul> 7107 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7108 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7109 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7110 * <li>{@code Integer} property type 7111 * </ul> 7112 * 7113 * <p>Required Permission: 7114 * <ul> 7115 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 7116 * property. 7117 * <li>Property is not writable. 7118 * </ul> 7119 * 7120 * @data_enum {@link EmergencyLaneKeepAssistState} 7121 * @data_enum {@link ErrorState} 7122 */ 7123 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7124 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 7125 public static final int EMERGENCY_LANE_KEEP_ASSIST_STATE = 289411086; 7126 7127 /** 7128 * Enable or disable Cruise Control (CC). 7129 * 7130 * <p>Return true if CC is enabled and false if CC is disabled. This property is shared by all 7131 * forms of {@link android.car.hardware.property.CruiseControlType}). 7132 * 7133 * <p>When CC is enabled, the ADAS system in the vehicle should be turned on and responding to 7134 * commands. 7135 * 7136 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 7137 * only. 7138 * 7139 * <p>Property Config: 7140 * <ul> 7141 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7142 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7143 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7144 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7145 * <li>{@code Boolean} property type 7146 * </ul> 7147 * 7148 * <p>Required Permissions: 7149 * <ul> 7150 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 7151 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 7152 * property. 7153 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 7154 * property. 7155 * </ul> 7156 */ 7157 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7158 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 7159 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 7160 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 7161 public static final int CRUISE_CONTROL_ENABLED = 287313935; 7162 7163 /** 7164 * Current type of Cruise Control (CC). 7165 * 7166 * <p>When {@link #CRUISE_CONTROL_ENABLED} is true, this property returns the type of CC that is 7167 * currently enabled (for example, standard CC, adaptive CC, etc.). Generally, this property 7168 * should return a valid state defined in the {@link 7169 * android.car.hardware.property.CruiseControlType} or {@link 7170 * android.car.hardware.property.ErrorState}. For example, if the feature is not available due 7171 * to some temporary state, that information should be conveyed through {@link 7172 * android.car.hardware.property.ErrorState}. 7173 * 7174 * <p>For the global area ID (0), the {@link 7175 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7176 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7177 * from {@link android.car.hardware.property.CruiseControlType} and {@link 7178 * android.car.hardware.property.ErrorState} are supported. 7179 * 7180 * Trying to write {@link android.car.hardware.property.CruiseControlType#OTHER} or an 7181 * {@link android.car.hardware.property.ErrorState} to this property will throw an {@code 7182 * IllegalArgumentException}. 7183 * 7184 * <p>Property Config: 7185 * <ul> 7186 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7187 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7188 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7189 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7190 * <li>{@code Integer} property type 7191 * </ul> 7192 * 7193 * <p>Required Permissions: 7194 * <ul> 7195 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} or 7196 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_STATES} to read 7197 * property. 7198 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_STATES} to write 7199 * property. 7200 * </ul> 7201 * 7202 * @data_enum {@link CruiseControlType} 7203 * @data_enum {@link ErrorState} 7204 */ 7205 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7206 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_STATES, 7207 Car.PERMISSION_CONTROL_ADAS_STATES})) 7208 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_STATES)) 7209 public static final int CRUISE_CONTROL_TYPE = 289411088; 7210 7211 /** 7212 * Current state of Cruise Control (CC). 7213 * 7214 * <p>This property returns the state of CC. Generally, this property should return a valid 7215 * state defined in the {@link android.car.hardware.property.CruiseControlState} or {@link 7216 * android.car.hardware.property.ErrorState}. For example, if the feature is not available due 7217 * to some temporary state, that information should be conveyed through {@link 7218 * android.car.hardware.property.ErrorState}. 7219 * 7220 * <p>For the global area ID (0), the {@link 7221 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7222 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7223 * from {@link android.car.hardware.property.CruiseControlState} and {@link 7224 * android.car.hardware.property.ErrorState} are supported. 7225 * 7226 * <p>Property Config: 7227 * <ul> 7228 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7229 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7230 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7231 * <li>{@code Integer} property type 7232 * </ul> 7233 * 7234 * <p>Required Permission: 7235 * <ul> 7236 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 7237 * property. 7238 * <li>Property is not writable. 7239 * </ul> 7240 * 7241 * @data_enum {@link CruiseControlState} 7242 * @data_enum {@link ErrorState} 7243 */ 7244 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7245 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 7246 public static final int CRUISE_CONTROL_STATE = 289411089; 7247 7248 /** 7249 * Write Cruise Control (CC) commands. 7250 * 7251 * <p>See {@link android.car.hardware.property.CruiseControlCommand} for the details about 7252 * each supported command. 7253 * 7254 * <p>For the global area ID (0), the {@link 7255 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7256 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7257 * from {@link android.car.hardware.property.CruiseControlCommand} are supported. 7258 * 7259 * <p>When this property is unavailable (for example when {@link #CRUISE_CONTROL_ENABLED} is 7260 * false), writing this property will throw a {@link 7261 * android.car.hardware.property.PropertyNotAvailableException}. 7262 * 7263 * <p>Property Config: 7264 * <ul> 7265 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_WRITE} 7266 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7267 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7268 * <li>{@code Integer} property type 7269 * </ul> 7270 * 7271 * <p>Required Permission: 7272 * <ul> 7273 * <li>Property is not readable. 7274 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_STATES} to write 7275 * property. 7276 * </ul> 7277 * 7278 * @data_enum {@link CruiseControlCommand} 7279 */ 7280 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7281 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_STATES)) 7282 public static final int CRUISE_CONTROL_COMMAND = 289411090; 7283 7284 /** 7285 * Current target speed for Cruise Control (CC) in meters per second. 7286 * 7287 * <p>{@link android.car.hardware.property.AreaIdConfig#getMinValue()} and {@link 7288 * android.car.hardware.property.AreaIdConfig#getMaxValue()} return the min and max target 7289 * speed values respectively. These values will be non-negative. 7290 * 7291 * <p>{@link android.car.hardware.property.AreaIdConfig#getMinValue()} represents the lower 7292 * bound of the target speed. 7293 * <p>{@link android.car.hardware.property.AreaIdConfig#getMaxValue()} represents the upper 7294 * bound of the target speed. 7295 * 7296 * <p>When this property is unavailable (for example when {@link #CRUISE_CONTROL_ENABLED} is 7297 * false), reading this property will throw a {@link 7298 * android.car.hardware.property.PropertyNotAvailableException}. 7299 * 7300 * <p>Property Config: 7301 * <ul> 7302 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7303 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7304 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7305 * <li>{@code Float} property type 7306 * </ul> 7307 * 7308 * <p>Required Permission: 7309 * <ul> 7310 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 7311 * property. 7312 * <li>Property is not writable. 7313 * </ul> 7314 */ 7315 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7316 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 7317 public static final int CRUISE_CONTROL_TARGET_SPEED = 291508243; 7318 7319 /** 7320 * Current target time gap for Adaptive Cruise Control (ACC) or Predictive Cruise Control in 7321 * milliseconds. 7322 * 7323 * <p>This property should specify the target time gap to a leading vehicle. This gap is defined 7324 * as the time to travel the distance between the leading vehicle's rear-most point to the ACC 7325 * vehicle's front-most point. The actual time gap from a leading vehicle can be above or below 7326 * this value. 7327 * 7328 * <p>The possible values to set for the target time gap should be specified in {@code 7329 * configArray} in ascending order. All values must be positive. If the property is writable, 7330 * all values must be writable. 7331 * 7332 * <p>When this property is unavailable (for example when {@link #CRUISE_CONTROL_ENABLED} is 7333 * false), reading or writing this property will throw a {@link 7334 * android.car.hardware.property.PropertyNotAvailableException}. 7335 * 7336 * <p>Property Config: 7337 * <ul> 7338 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7339 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7340 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7341 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7342 * <li>{@code Integer} property type 7343 * </ul> 7344 * 7345 * <p>Required Permissions: 7346 * <ul> 7347 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} or 7348 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_STATES} to read 7349 * property. 7350 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_STATES} to write 7351 * property. 7352 * </ul> 7353 */ 7354 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7355 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_STATES, 7356 Car.PERMISSION_CONTROL_ADAS_STATES})) 7357 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_STATES)) 7358 public static final int ADAPTIVE_CRUISE_CONTROL_TARGET_TIME_GAP = 289411092; 7359 7360 /** 7361 * Measured distance from leading vehicle when using Adaptive Cruise Control (ACC) or Predictive 7362 * Cruise Control in millimeters. 7363 * 7364 * <p>Returns the measured distance in meters from the lead vehicle for ACC between the 7365 * rear-most point of the leading vehicle and the front-most point of the ACC vehicle. 7366 * 7367 * <p>{@link CarPropertyConfig#getMinValue(int)} returns 0. 7368 * <p>{@link CarPropertyConfig#getMaxValue(int)} returns the maximum range the distance sensor 7369 * can support. This value will be non-negative. 7370 * 7371 * <p>When no lead vehicle is detected (that is, when there is no leading vehicle or the leading 7372 * vehicle is too far away for the sensor to detect), this property will throw a {@link 7373 * android.car.hardware.property.PropertyNotAvailableException}. 7374 * 7375 * <p>When this property is unavailable (for example when {@link #CRUISE_CONTROL_ENABLED} is 7376 * false), reading this property will throw a {@link 7377 * android.car.hardware.property.PropertyNotAvailableException}. 7378 * 7379 * <p>Property Config: 7380 * <ul> 7381 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7382 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7383 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS} 7384 * <li>{@code Integer} property type 7385 * </ul> 7386 * 7387 * <p>Required Permission: 7388 * <ul> 7389 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 7390 * property. 7391 * <li>Property is not writable. 7392 * </ul> 7393 */ 7394 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7395 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 7396 public static final int ADAPTIVE_CRUISE_CONTROL_LEAD_VEHICLE_MEASURED_DISTANCE = 289411093; 7397 7398 /** 7399 * Enable or disable Hands On Detection (HOD). 7400 * 7401 * <p>Return true if HOD is enabled and false if HOD is disabled. When HOD is enabled, a system 7402 * inside the vehicle should be monitoring the presence of the driver's hands on the steering 7403 * wheel and send a warning if it detects that the driver's hands are no longer on the steering 7404 * wheel. 7405 * 7406 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 7407 * only. 7408 * 7409 * <p>Property Config: 7410 * <ul> 7411 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7412 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7413 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7414 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7415 * <li>{@code Boolean} property type 7416 * </ul> 7417 * 7418 * <p>Required Permissions: 7419 * <ul> 7420 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_SETTINGS} 7421 * or Signature|Privileged permission {@link 7422 * Car#PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS} to read property. 7423 * <li>Signature|Privileged permission {@link 7424 * Car#PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS} to write property. 7425 * </ul> 7426 */ 7427 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7428 @RequiresPermission.Read(@RequiresPermission(anyOf = { 7429 Car.PERMISSION_READ_DRIVER_MONITORING_SETTINGS, 7430 Car.PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS})) 7431 @RequiresPermission.Write(@RequiresPermission( 7432 Car.PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS)) 7433 public static final int HANDS_ON_DETECTION_ENABLED = 287313942; 7434 7435 /** 7436 * Hands On Detection (HOD) driver state. 7437 * 7438 * <p>Returns whether the driver's hands are on the steering wheel. Generally, this property 7439 * should return a valid state defined in the {@link 7440 * android.car.hardware.property.HandsOnDetectionDriverState} or {@link 7441 * android.car.hardware.property.ErrorState}. For example, if the feature is not available due 7442 * to some temporary state, that information should be conveyed through {@link 7443 * android.car.hardware.property.ErrorState}. 7444 * 7445 * <p>If the vehicle is sending a warning to the user because the driver's hands have been off 7446 * the steering wheel for too long, the warning should be surfaced through 7447 * {@link #HANDS_ON_DETECTION_WARNING}. 7448 * 7449 * <p>For the global area ID (0), the {@link 7450 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7451 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7452 * from {@link android.car.hardware.property.HandsOnDetectionDriverState} and {@link 7453 * android.car.hardware.property.ErrorState} are supported. 7454 * 7455 * <p>Property Config: 7456 * <ul> 7457 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7458 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7459 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7460 * <li>{@code Integer} property type 7461 * </ul> 7462 * 7463 * <p>Required Permission: 7464 * <ul> 7465 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_STATES} to 7466 * read property. 7467 * <li>Property is not writable. 7468 * </ul> 7469 * 7470 * @data_enum {@link HandsOnDetectionDriverState} 7471 * @data_enum {@link ErrorState} 7472 */ 7473 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7474 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DRIVER_MONITORING_STATES)) 7475 public static final int HANDS_ON_DETECTION_DRIVER_STATE = 289411095; 7476 /** 7477 * Hands On Detection (HOD) warning. 7478 * 7479 * <p>Returns whether a warning is being sent to the driver for having their hands off the wheel 7480 * for too long a duration. 7481 * 7482 * <p>Generally, this property should return a valid state defined in the {@link 7483 * android.car.hardware.property.HandsOnDetectionWarning} or {@link 7484 * android.car.hardware.property.ErrorState}. For example, if the feature is not available due 7485 * to some temporary state, that information should be conveyed through an {@link 7486 * android.car.hardware.property.ErrorState}. 7487 * 7488 * <p>For the global area ID (0), the {@link 7489 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7490 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7491 * from {@link android.car.hardware.property.HandsOnDetectionWarning} and {@link 7492 * android.car.hardware.property.ErrorState} are supported. 7493 * 7494 * <p>Property Config: 7495 * <ul> 7496 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7497 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7498 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7499 * <li>{@code Integer} property type 7500 * </ul> 7501 * 7502 * <p>Required Permission: 7503 * <ul> 7504 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_STATES} to 7505 * read property. 7506 * <li>Property is not writable. 7507 * </ul> 7508 * 7509 * @data_enum {@link HandsOnDetectionWarning} 7510 * @data_enum {@link ErrorState} 7511 */ 7512 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7513 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DRIVER_MONITORING_STATES)) 7514 public static final int HANDS_ON_DETECTION_WARNING = 289411096; 7515 7516 /** 7517 * Enable or disable driver drowsiness and attention monitoring. 7518 * 7519 * <p>Set true to enable driver drowsiness and attention monitoring and false to disable driver 7520 * drowsiness and attention monitoring. When driver drowsiness and attention monitoring is 7521 * enabled, a system inside the vehicle will monitor the drowsiness and attention level of the 7522 * driver and warn the driver if needed. 7523 * 7524 * <p>Property Config: 7525 * <ul> 7526 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7527 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7528 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7529 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7530 * <li>{@code Boolean} property type 7531 * </ul> 7532 * 7533 * <p>Required Permissions: 7534 * <ul> 7535 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_SETTINGS} 7536 * or Signature|Privileged permission {@link 7537 * Car#PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS} to read property. 7538 * <li>Signature|Privileged permission {@link 7539 * Car#PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS} to write property. 7540 * </ul> 7541 */ 7542 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7543 @RequiresPermission.Read(@RequiresPermission(anyOf = { 7544 Car.PERMISSION_READ_DRIVER_MONITORING_SETTINGS, 7545 Car.PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS})) 7546 @RequiresPermission.Write(@RequiresPermission( 7547 Car.PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS)) 7548 public static final int DRIVER_DROWSINESS_ATTENTION_SYSTEM_ENABLED = 287313945; 7549 7550 /** 7551 * Driver drowsiness and attention level state. 7552 * 7553 * <p>Returns the current detected state of driver drowiness and attention level based on the 7554 * Karolinska Sleepiness Scale (KSS). 7555 * 7556 * <p>Generally, this property should return a valid state defined in the {@link 7557 * android.car.hardware.property.DriverDrowsinessAttentionState} or {@link 7558 * android.car.hardware.property.ErrorState}. For example, if the feature is not available due 7559 * to some temporary state, that information should be conveyed through {@link 7560 * android.car.hardware.property.ErrorState}. 7561 * 7562 * <p>If the vehicle is sending a warning to the user because the driver is too drowsy, the 7563 * warning should be surfaced through {@link #DRIVER_DROWSINESS_ATTENTION_WARNING}. 7564 * 7565 * <p>For the global area ID (0), the {@link 7566 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7567 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7568 * from {@link android.car.hardware.property.DriverDrowsinessAttentionState} and {@link 7569 * android.car.hardware.property.ErrorState} are supported. 7570 * 7571 * <p>Property Config: 7572 * <ul> 7573 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7574 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7575 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7576 * <li>{@code Integer} property type 7577 * </ul> 7578 * 7579 * <p>Required Permission: 7580 * <ul> 7581 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_STATES} to 7582 * read property. 7583 * <li>Property is not writable. 7584 * </ul> 7585 * 7586 * @data_enum {@link DriverDrowsinessAttentionState} 7587 * @data_enum {@link ErrorState} 7588 */ 7589 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7590 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DRIVER_MONITORING_STATES)) 7591 public static final int DRIVER_DROWSINESS_ATTENTION_STATE = 289411098; 7592 7593 /** 7594 * Enable or disable driver drowsiness and attention warnings. 7595 * 7596 * <p>Set true to enable driver drowsiness and attention warnings and false to disable driver 7597 * drowsiness and attention warnings. When driver drowsiness and attention warnings are enabled, 7598 * the driver drowsiness and attention monitoring system inside the vehicle should warn the 7599 * driver when it detects the driver is drowsy or not attentive. 7600 * 7601 * <p>Property Config: 7602 * <ul> 7603 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7604 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7605 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7606 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7607 * <li>{@code Boolean} property type 7608 * </ul> 7609 * 7610 * <p>Required Permissions: 7611 * <ul> 7612 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_SETTINGS} 7613 * or Signature|Privileged permission {@link 7614 * Car#PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS} to read property. 7615 * <li>Signature|Privileged permission {@link 7616 * Car#PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS} to write property. 7617 * </ul> 7618 */ 7619 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7620 @RequiresPermission.Read(@RequiresPermission(anyOf = { 7621 Car.PERMISSION_READ_DRIVER_MONITORING_SETTINGS, 7622 Car.PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS})) 7623 @RequiresPermission.Write(@RequiresPermission( 7624 Car.PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS)) 7625 public static final int DRIVER_DROWSINESS_ATTENTION_WARNING_ENABLED = 287313947; 7626 7627 /** 7628 * Driver drowsiness and attention warning. 7629 * 7630 * <p>Returns whether a warning is being sent to the driver for being drowsy or not attentive. 7631 * 7632 * <p>Generally, this property should return a valid state defined in the {@link 7633 * android.car.hardware.property.DriverDrowsinessAttentionWarning} or {@link 7634 * android.car.hardware.property.ErrorState}. For example, if the feature is not available due 7635 * to some temporary state, that information should be conveyed through an {@link 7636 * android.car.hardware.property.ErrorState}. 7637 * 7638 * <p>For the global area ID (0), the {@link 7639 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7640 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7641 * from {@link android.car.hardware.property.DriverDrowsinessAttentionWarning} and {@link 7642 * android.car.hardware.property.ErrorState} are supported. 7643 * 7644 * <p>Property Config: 7645 * <ul> 7646 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7647 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7648 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7649 * <li>{@code Integer} property type 7650 * </ul> 7651 * 7652 * <p>Required Permission: 7653 * <ul> 7654 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_STATES} to 7655 * read property. 7656 * <li>Property is not writable. 7657 * </ul> 7658 * 7659 * @data_enum {@link DriverDrowsinessAttentionWarning} 7660 * @data_enum {@link ErrorState} 7661 */ 7662 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7663 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DRIVER_MONITORING_STATES)) 7664 public static final int DRIVER_DROWSINESS_ATTENTION_WARNING = 289411100; 7665 7666 /** 7667 * Enable or disable driver distraction monitoring. 7668 * 7669 * <p>Set true to enable driver distraction monitoring and false to disable driver distraction 7670 * monitoring. When driver distraction monitoring is enabled, a system inside the vehicle should 7671 * be monitoring the distraction level of the driver and warn the driver if needed. 7672 * 7673 * <p>Property Config: 7674 * <ul> 7675 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7676 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7677 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7678 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7679 * <li>{@code Boolean} property type 7680 * </ul> 7681 * 7682 * <p>Required Permissions: 7683 * <ul> 7684 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_SETTINGS} 7685 * or Signature|Privileged permission {@link 7686 * Car#PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS} to read property. 7687 * <li>Signature|Privileged permission {@link 7688 * Car#PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS} to write property. 7689 * </ul> 7690 */ 7691 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7692 @RequiresPermission.Read(@RequiresPermission(anyOf = { 7693 Car.PERMISSION_READ_DRIVER_MONITORING_SETTINGS, 7694 Car.PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS})) 7695 @RequiresPermission.Write(@RequiresPermission( 7696 Car.PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS)) 7697 public static final int DRIVER_DISTRACTION_SYSTEM_ENABLED = 287313949; 7698 7699 /** 7700 * Driver distraction state. 7701 * 7702 * <p>Returns the current detected driver distraction state. 7703 * 7704 * <p>Generally, this property should return a valid state defined in the {@link 7705 * android.car.hardware.property.DriverDistractionState} or {@link 7706 * android.car.hardware.property.ErrorState}. For example, if the feature is not available due 7707 * to some temporary state, that information should be conveyed through {@link 7708 * android.car.hardware.property.ErrorState}. 7709 * 7710 * <p>If the vehicle is sending a warning to the user because the driver is too distracted, the 7711 * warning should be surfaced through {@link #DRIVER_DISTRACTION_WARNING}. 7712 * 7713 * <p>For the global area ID (0), the {@link 7714 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7715 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7716 * from {@link android.car.hardware.property.DriverDistractionState} and {@link 7717 * android.car.hardware.property.ErrorState} are supported. 7718 * 7719 * <p>Property Config: 7720 * <ul> 7721 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7722 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7723 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7724 * <li>{@code Integer} property type 7725 * </ul> 7726 * 7727 * <p>Required Permission: 7728 * <ul> 7729 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_STATES} to 7730 * read property. 7731 * <li>Property is not writable. 7732 * </ul> 7733 * 7734 * @data_enum {@link DriverDistractionState} 7735 * @data_enum {@link ErrorState} 7736 */ 7737 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7738 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DRIVER_MONITORING_STATES)) 7739 public static final int DRIVER_DISTRACTION_STATE = 289411102; 7740 7741 /** 7742 * Enable or disable driver distraction warnings. 7743 * 7744 * <p>Set true to enable driver distraction warnings and false to disable driver distraction 7745 * warnings. When driver distraction warnings are enabled, the driver distraction monitoring 7746 * system inside the vehicle should warn the driver when it detects the driver is distracted. 7747 * 7748 * <p>Property Config: 7749 * <ul> 7750 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7751 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7752 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7753 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7754 * <li>{@code Boolean} property type 7755 * </ul> 7756 * 7757 * <p>Required Permissions: 7758 * <ul> 7759 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_SETTINGS} 7760 * or Signature|Privileged permission {@link 7761 * Car#PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS} to read property. 7762 * <li>Signature|Privileged permission {@link 7763 * Car#PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS} to write property. 7764 * </ul> 7765 */ 7766 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7767 @RequiresPermission.Read(@RequiresPermission(anyOf = { 7768 Car.PERMISSION_READ_DRIVER_MONITORING_SETTINGS, 7769 Car.PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS})) 7770 @RequiresPermission.Write(@RequiresPermission( 7771 Car.PERMISSION_CONTROL_DRIVER_MONITORING_SETTINGS)) 7772 public static final int DRIVER_DISTRACTION_WARNING_ENABLED = 287313951; 7773 7774 /** 7775 * Driver distraction warning. 7776 * 7777 * <p>Returns whether a warning is being sent to the driver for being distracted. 7778 * 7779 * <p>Generally, this property should return a valid state defined in the {@link 7780 * android.car.hardware.property.DriverDistractionWarning} or {@link 7781 * android.car.hardware.property.ErrorState}. For example, if the feature is not available due 7782 * to some temporary state, that information should be conveyed through an {@link 7783 * android.car.hardware.property.ErrorState}. 7784 * 7785 * <p>For the global area ID (0), the {@link 7786 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7787 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7788 * from {@link android.car.hardware.property.DriverDistractionWarning} and {@link 7789 * android.car.hardware.property.ErrorState} are supported. 7790 * 7791 * <p>Property Config: 7792 * <ul> 7793 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7794 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7795 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7796 * <li>{@code Integer} property type 7797 * </ul> 7798 * 7799 * <p>Required Permission: 7800 * <ul> 7801 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_DRIVER_MONITORING_STATES} to 7802 * read property. 7803 * <li>Property is not writable. 7804 * </ul> 7805 * 7806 * @data_enum {@link DriverDistractionWarning} 7807 * @data_enum {@link ErrorState} 7808 */ 7809 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7810 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_DRIVER_MONITORING_STATES)) 7811 public static final int DRIVER_DISTRACTION_WARNING = 289411104; 7812 /** 7813 * Enable or disable Low Speed Collision Warning. 7814 * 7815 * <p>Returns true if low speed collision warning is enabled and false if low speed collision 7816 * warning is disabled. When low speed collision warning is enabled, the ADAS system in the 7817 * vehicle will warn the driver of potential collisions at low speeds. This property is 7818 * different from the pre-existing {@link VehiclePropertyIds#FORWARD_COLLISION_WARNING_ENABLED}, 7819 * which applies to higher speed applications only. If the vehicle doesn't have a separate 7820 * collision detection system for low speed environments, this property will not be implemented. 7821 * 7822 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 7823 * only. 7824 * 7825 * <p>Property Config: 7826 * <ul> 7827 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7828 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7829 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7830 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7831 * <li>{@code Boolean} property type 7832 * </ul> 7833 * 7834 * <p>Required Permissions: 7835 * <ul> 7836 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 7837 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 7838 * property. 7839 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 7840 * property. 7841 * </ul> 7842 */ 7843 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7844 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 7845 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 7846 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 7847 public static final int LOW_SPEED_COLLISION_WARNING_ENABLED = 287313953; 7848 7849 /** 7850 * Low Speed Collision Warning State state. 7851 * 7852 * <p>Returns the current state of Low Speed Collision Warning. This property will always return 7853 * a valid state defined in {@link android.car.hardware.property.LowSpeedCollisionWarningState} 7854 * or {@link android.car.hardware.property.ErrorState}. This property is different from the 7855 * pre-existing {@link VehiclePropertyIds#FORWARD_COLLISION_WARNING_ENABLED}, which applies to 7856 * higher speed applications only. If the vehicle doesn't have a separate collision detection 7857 * system for low speed environments, this property will not be implemented. 7858 * 7859 * <p>For the global area ID (0), the {@link 7860 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7861 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7862 * from {@link android.car.hardware.property.LowSpeedCollisionWarningState} and {@link 7863 * android.car.hardware.property.ErrorState} are supported. 7864 * 7865 * <p>Property Config: 7866 * <ul> 7867 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7868 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7869 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7870 * <li>{@code Integer} property type 7871 * </ul> 7872 * 7873 * <p>Required Permission: 7874 * <ul> 7875 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 7876 * property. 7877 * <li>Property is not writable. 7878 * </ul> 7879 * 7880 * @data_enum {@link android.car.hardware.property.LowSpeedCollisionWarningState} 7881 * @data_enum {@link ErrorState} 7882 */ 7883 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7884 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 7885 public static final int LOW_SPEED_COLLISION_WARNING_STATE = 289411106; 7886 7887 /** 7888 * Enable or disable Cross Traffic Monitoring. 7889 * 7890 * <p>Returns true if Cross Traffic Monitoring is enabled and false if Cross Traffic Monitoring 7891 * is disabled. When Cross Traffic Monitoring is enabled, the ADAS system in the vehicle should 7892 * be turned on and monitoring for potential sideways collisions. 7893 * 7894 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 7895 * only. 7896 * 7897 * <p>Property Config: 7898 * <ul> 7899 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7900 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7901 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7902 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7903 * <li>{@code Boolean} property type 7904 * </ul> 7905 * 7906 * <p>Required Permissions: 7907 * <ul> 7908 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 7909 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 7910 * property. 7911 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 7912 * property. 7913 * </ul> 7914 */ 7915 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7916 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 7917 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 7918 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 7919 public static final int CROSS_TRAFFIC_MONITORING_ENABLED = 287313955; 7920 7921 /** 7922 * Cross Traffic Monitoring Warning state. 7923 * 7924 * <p>Returns the current state of Cross Traffic Monitoring Warning. This property will always 7925 * return a valid state defined in {@link 7926 * android.car.hardware.property.CrossTrafficMonitoringWarningState} or {@link 7927 * android.car.hardware.property.ErrorState}. 7928 * 7929 * <p>For the global area ID (0), the {@link 7930 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 7931 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 7932 * from {@link android.car.hardware.property.CrossTrafficMonitoringWarningState} and {@link 7933 * android.car.hardware.property.ErrorState} are supported. 7934 * 7935 * <p>Property Config: 7936 * <ul> 7937 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7938 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7939 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7940 * <li>{@code Integer} property type 7941 * </ul> 7942 * 7943 * <p>Required Permission: 7944 * <ul> 7945 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 7946 * property. 7947 * <li>Property is not writable. 7948 * </ul> 7949 * 7950 * @data_enum {@link android.car.hardware.property.CrossTrafficMonitoringWarningState} 7951 * @data_enum {@link ErrorState} 7952 */ 7953 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7954 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 7955 public static final int CROSS_TRAFFIC_MONITORING_WARNING_STATE = 289411108; 7956 7957 /** 7958 * Enable or disable Low Speed Automatic Emergency Braking. 7959 * 7960 * <p>Returns true if Low Speed Automatic Emergency Braking is enabled or false if Low Speed 7961 * Automatic Emergency Braking is disabled. When Low Speed Automatic Emergency Braking is 7962 * enabled, the ADAS system in the vehicle will be turned on and monitoring to avoid potential 7963 * collisions in low speed conditions. This property is different from the pre-existing 7964 * AUTOMATIC_EMERGENCY_BRAKING_ENABLED, which should apply to higher speed applications only. If 7965 * the vehicle doesn't have a separate collision avoidance system for low speed environments, 7966 * this property will not be implemented. 7967 * 7968 * <p>This property is defined as read_write, but OEMs have the option to implement it as read 7969 * only. 7970 * 7971 * <p>Property Config: 7972 * <ul> 7973 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ_WRITE} or 7974 * {@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 7975 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 7976 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 7977 * <li>{@code Boolean} property type 7978 * </ul> 7979 * 7980 * <p>Required Permissions: 7981 * <ul> 7982 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_SETTINGS} or 7983 * Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to read 7984 * property. 7985 * <li>Signature|Privileged permission {@link Car#PERMISSION_CONTROL_ADAS_SETTINGS} to write 7986 * property. 7987 * </ul> 7988 */ 7989 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 7990 @RequiresPermission.Read(@RequiresPermission(anyOf = {Car.PERMISSION_READ_ADAS_SETTINGS, 7991 Car.PERMISSION_CONTROL_ADAS_SETTINGS})) 7992 @RequiresPermission.Write(@RequiresPermission(Car.PERMISSION_CONTROL_ADAS_SETTINGS)) 7993 public static final int LOW_SPEED_AUTOMATIC_EMERGENCY_BRAKING_ENABLED = 287313957; 7994 7995 /** 7996 * Low Speed Automatic Emergency Braking state. 7997 * 7998 * <p>Returns the current state of Low Speed Automatic Emergency Braking. This property will 7999 * always return a valid state defined in {@link 8000 * android.car.hardware.property.LowSpeedAutomaticEmergencyBrakingState} or {@link 8001 * android.car.hardware.property.ErrorState}. 8002 * 8003 * <p>If Low Speed Automatic Emergency Braking includes collision warnings before activating the 8004 * brakes, those warnings will be surfaced through use of {@link 8005 * android.car.VehiclePropertyIds#LOW_SPEED_COLLISION_WARNING_ENABLED} and {@link 8006 * android.car.VehiclePropertyIds#LOW_SPEED_COLLISION_WARNING_STATE}. 8007 * 8008 * <p>For the global area ID (0), the {@link 8009 * android.car.hardware.property.AreaIdConfig#getSupportedEnumValues()} array obtained from 8010 * {@link android.car.hardware.CarPropertyConfig#getAreaIdConfig(int)} specifies which states 8011 * from {@link android.car.hardware.property.LowSpeedAutomaticEmergencyBrakingState} and {@link 8012 * android.car.hardware.property.ErrorState} are supported. 8013 * 8014 * <p>Property Config: 8015 * <ul> 8016 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_ACCESS_READ} 8017 * <li>{@link VehicleAreaType#VEHICLE_AREA_TYPE_GLOBAL} 8018 * <li>{@link android.car.hardware.CarPropertyConfig#VEHICLE_PROPERTY_CHANGE_MODE_ONCHANGE} 8019 * <li>{@code Integer} property type 8020 * </ul> 8021 * 8022 * <p>Required Permission: 8023 * <ul> 8024 * <li>Signature|Privileged permission {@link Car#PERMISSION_READ_ADAS_STATES} to read 8025 * property. 8026 * <li>Property is not writable. 8027 * </ul> 8028 * 8029 * @data_enum {@link android.car.hardware.property.LowSpeedAutomaticEmergencyBrakingState} 8030 * @data_enum {@link ErrorState} 8031 */ 8032 @FlaggedApi(FLAG_VEHICLE_PROPERTY_REMOVE_SYSTEM_API_TAGS) 8033 @RequiresPermission.Read(@RequiresPermission(Car.PERMISSION_READ_ADAS_STATES)) 8034 public static final int LOW_SPEED_AUTOMATIC_EMERGENCY_BRAKING_STATE = 289411110; 8035 8036 /** 8037 * @deprecated to prevent others from instantiating this class 8038 */ 8039 @Deprecated 8040 @ExcludeFromCodeCoverageGeneratedReport(reason = BOILERPLATE_CODE) VehiclePropertyIds()8041 public VehiclePropertyIds() { 8042 } 8043 8044 /** 8045 * Gets a user-friendly representation of a property. 8046 */ toString(int propertyId)8047 public static String toString(int propertyId) { 8048 return isDefined(propertyId) ? toName(propertyId) : "0x" + Integer.toHexString(propertyId); 8049 } 8050 } 8051