Merge "Add vts for Aware interface" into main
diff --git a/audio/aidl/vts/EffectHelper.h b/audio/aidl/vts/EffectHelper.h
index eedac3d..8ceb56b 100644
--- a/audio/aidl/vts/EffectHelper.h
+++ b/audio/aidl/vts/EffectHelper.h
@@ -47,6 +47,7 @@
using aidl::android::hardware::audio::effect::getRange;
using aidl::android::hardware::audio::effect::IEffect;
using aidl::android::hardware::audio::effect::isRangeValid;
+using aidl::android::hardware::audio::effect::kDrainSupportedVersion;
using aidl::android::hardware::audio::effect::kEffectTypeUuidSpatializer;
using aidl::android::hardware::audio::effect::kEventFlagDataMqNotEmpty;
using aidl::android::hardware::audio::effect::kEventFlagDataMqUpdate;
@@ -195,8 +196,11 @@
ASSERT_TRUE(expectState(effect, State::PROCESSING));
break;
case CommandId::STOP:
- ASSERT_TRUE(expectState(effect, State::IDLE) ||
- expectState(effect, State::DRAINING));
+ // Enforce the state checking after kDrainSupportedVersion
+ if (getHalVersion(effect) >= kDrainSupportedVersion) {
+ ASSERT_TRUE(expectState(effect, State::IDLE) ||
+ expectState(effect, State::DRAINING));
+ }
break;
case CommandId::RESET:
ASSERT_TRUE(expectState(effect, State::IDLE));
@@ -518,6 +522,11 @@
}
}
+ static int getHalVersion(const std::shared_ptr<IEffect>& effect) {
+ int version = 0;
+ return (effect && effect->getInterfaceVersion(&version).isOk()) ? version : 0;
+ }
+
bool mIsSpatializer;
Descriptor mDescriptor;
size_t mInputFrameSize, mOutputFrameSize;
diff --git a/audio/aidl/vts/VtsHalAECTargetTest.cpp b/audio/aidl/vts/VtsHalAECTargetTest.cpp
index 53b6757..c007f18 100644
--- a/audio/aidl/vts/VtsHalAECTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalAECTargetTest.cpp
@@ -139,12 +139,12 @@
};
TEST_P(AECParamTest, SetAndGetEchoDelay) {
- EXPECT_NO_FATAL_FAILURE(addEchoDelayParam(mEchoDelay));
+ addEchoDelayParam(mEchoDelay);
SetAndGetParameters();
}
TEST_P(AECParamTest, SetAndGetMobileMode) {
- EXPECT_NO_FATAL_FAILURE(addMobileModeParam(mMobileMode));
+ addMobileModeParam(mMobileMode);
SetAndGetParameters();
}
diff --git a/audio/aidl/vts/VtsHalAGC1TargetTest.cpp b/audio/aidl/vts/VtsHalAGC1TargetTest.cpp
index f14afbc..72a2d5e 100644
--- a/audio/aidl/vts/VtsHalAGC1TargetTest.cpp
+++ b/audio/aidl/vts/VtsHalAGC1TargetTest.cpp
@@ -139,17 +139,17 @@
};
TEST_P(AGC1ParamTest, SetAndGetTargetPeakLevelParam) {
- EXPECT_NO_FATAL_FAILURE(addTargetPeakLevelParam(mTargetPeakLevel));
+ addTargetPeakLevelParam(mTargetPeakLevel);
SetAndGetParameters();
}
TEST_P(AGC1ParamTest, SetAndGetMaxCompressionGain) {
- EXPECT_NO_FATAL_FAILURE(addMaxCompressionGainParam(mMaxCompressionGain));
+ addMaxCompressionGainParam(mMaxCompressionGain);
SetAndGetParameters();
}
TEST_P(AGC1ParamTest, SetAndGetEnableLimiter) {
- EXPECT_NO_FATAL_FAILURE(addEnableLimiterParam(mEnableLimiter));
+ addEnableLimiterParam(mEnableLimiter);
SetAndGetParameters();
}
diff --git a/audio/aidl/vts/VtsHalAGC2TargetTest.cpp b/audio/aidl/vts/VtsHalAGC2TargetTest.cpp
index 048d540..ccac8c5 100644
--- a/audio/aidl/vts/VtsHalAGC2TargetTest.cpp
+++ b/audio/aidl/vts/VtsHalAGC2TargetTest.cpp
@@ -145,17 +145,17 @@
};
TEST_P(AGC2ParamTest, SetAndGetDigitalGainParam) {
- EXPECT_NO_FATAL_FAILURE(addDigitalGainParam(mGain));
+ addDigitalGainParam(mGain);
SetAndGetParameters();
}
TEST_P(AGC2ParamTest, SetAndGetSaturationMargin) {
- EXPECT_NO_FATAL_FAILURE(addSaturationMarginParam(mMargin));
+ addSaturationMarginParam(mMargin);
SetAndGetParameters();
}
TEST_P(AGC2ParamTest, SetAndGetLevelEstimator) {
- EXPECT_NO_FATAL_FAILURE(addLevelEstimatorParam(mLevelEstimator));
+ addLevelEstimatorParam(mLevelEstimator);
SetAndGetParameters();
}
diff --git a/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp b/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
index 3b1f3d9..37441f0 100644
--- a/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
+++ b/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
@@ -542,7 +542,7 @@
};
TEST_P(DynamicsProcessingTestEngineArchitecture, SetAndGetEngineArch) {
- EXPECT_NO_FATAL_FAILURE(addEngineConfig(mCfg));
+ addEngineConfig(mCfg);
ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());
}
@@ -594,7 +594,7 @@
};
TEST_P(DynamicsProcessingTestInputGain, SetAndGetInputGain) {
- EXPECT_NO_FATAL_FAILURE(addInputGain(mInputGain));
+ addInputGain(mInputGain);
ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());
}
@@ -652,7 +652,7 @@
mInputGain.push_back(DynamicsProcessing::InputGain(i, gainDb));
}
std::vector<float> output(mInput.size());
- EXPECT_NO_FATAL_FAILURE(addInputGain(mInputGain));
+ addInputGain(mInputGain);
EXPECT_NO_FATAL_FAILURE(setParamsAndProcess(mInput, output));
if (!isAllParamsValid()) {
continue;
@@ -719,8 +719,8 @@
};
TEST_P(DynamicsProcessingTestLimiterConfig, SetAndGetLimiterConfig) {
- EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
- EXPECT_NO_FATAL_FAILURE(addLimiterConfig(mLimiterConfigList));
+ addEngineConfig(mEngineConfigPreset);
+ addLimiterConfig(mLimiterConfigList);
ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());
}
@@ -782,8 +782,8 @@
}
void setLimiterParamsAndProcess(std::vector<float>& input, std::vector<float>& output) {
- EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
- EXPECT_NO_FATAL_FAILURE(addLimiterConfig(mLimiterConfigList));
+ addEngineConfig(mEngineConfigPreset);
+ addLimiterConfig(mLimiterConfigList);
EXPECT_NO_FATAL_FAILURE(setParamsAndProcess(input, output));
}
@@ -937,20 +937,20 @@
};
TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetPreEqChannelConfig) {
- EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
- EXPECT_NO_FATAL_FAILURE(addPreEqChannelConfig(mCfg));
+ addEngineConfig(mEngineConfigPreset);
+ addPreEqChannelConfig(mCfg);
ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());
}
TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetPostEqChannelConfig) {
- EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
- EXPECT_NO_FATAL_FAILURE(addPostEqChannelConfig(mCfg));
+ addEngineConfig(mEngineConfigPreset);
+ addPostEqChannelConfig(mCfg);
ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());
}
TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetMbcChannelConfig) {
- EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
- EXPECT_NO_FATAL_FAILURE(addMbcChannelConfig(mCfg));
+ addEngineConfig(mEngineConfigPreset);
+ addMbcChannelConfig(mCfg);
ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());
}
@@ -1018,27 +1018,27 @@
TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPreEqBandConfig) {
mEngineConfigPreset.preEqStage.bandCount = mCfgs.size();
- EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
+ addEngineConfig(mEngineConfigPreset);
std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
for (int i = 0; i < mChannelCount; i++) {
cfgs[i].channel = i;
cfgs[i].enable = true;
}
- EXPECT_NO_FATAL_FAILURE(addPreEqChannelConfig(cfgs));
- EXPECT_NO_FATAL_FAILURE(addPreEqBandConfigs(mCfgs));
+ addPreEqChannelConfig(cfgs);
+ addPreEqBandConfigs(mCfgs);
ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());
}
TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPostEqBandConfig) {
mEngineConfigPreset.postEqStage.bandCount = mCfgs.size();
- EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
+ addEngineConfig(mEngineConfigPreset);
std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
for (int i = 0; i < mChannelCount; i++) {
cfgs[i].channel = i;
cfgs[i].enable = true;
}
- EXPECT_NO_FATAL_FAILURE(addPostEqChannelConfig(cfgs));
- EXPECT_NO_FATAL_FAILURE(addPostEqBandConfigs(mCfgs));
+ addPostEqChannelConfig(cfgs);
+ addPostEqBandConfigs(mCfgs);
ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());
}
@@ -1185,14 +1185,14 @@
TEST_P(DynamicsProcessingTestMbcBandConfig, SetAndGetMbcBandConfig) {
mEngineConfigPreset.mbcStage.bandCount = mCfgs.size();
- EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
+ addEngineConfig(mEngineConfigPreset);
std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
for (int i = 0; i < mChannelCount; i++) {
cfgs[i].channel = i;
cfgs[i].enable = true;
}
- EXPECT_NO_FATAL_FAILURE(addMbcChannelConfig(cfgs));
- EXPECT_NO_FATAL_FAILURE(addMbcBandConfigs(mCfgs));
+ addMbcChannelConfig(cfgs);
+ addMbcBandConfigs(mCfgs);
ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());
}
diff --git a/audio/aidl/vts/VtsHalNSTargetTest.cpp b/audio/aidl/vts/VtsHalNSTargetTest.cpp
index a50e1b4..c5a9bad 100644
--- a/audio/aidl/vts/VtsHalNSTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalNSTargetTest.cpp
@@ -140,12 +140,12 @@
};
TEST_P(NSParamTest, SetAndGetLevel) {
- EXPECT_NO_FATAL_FAILURE(addLevelParam(mLevel));
+ addLevelParam(mLevel);
SetAndGetParameters();
}
TEST_P(NSParamTest, SetAndGetType) {
- EXPECT_NO_FATAL_FAILURE(addLevelParam(mLevel));
+ addLevelParam(mLevel);
SetAndGetParameters();
}
diff --git a/audio/aidl/vts/VtsHalVisualizerTargetTest.cpp b/audio/aidl/vts/VtsHalVisualizerTargetTest.cpp
index a942521..3b07809 100644
--- a/audio/aidl/vts/VtsHalVisualizerTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalVisualizerTargetTest.cpp
@@ -189,22 +189,22 @@
};
TEST_P(VisualizerParamTest, SetAndGetCaptureSize) {
- ASSERT_NO_FATAL_FAILURE(addCaptureSizeParam(mCaptureSize));
+ addCaptureSizeParam(mCaptureSize);
ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
TEST_P(VisualizerParamTest, SetAndGetScalingMode) {
- ASSERT_NO_FATAL_FAILURE(addScalingModeParam(mScalingMode));
+ addScalingModeParam(mScalingMode);
ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
TEST_P(VisualizerParamTest, SetAndGetMeasurementMode) {
- ASSERT_NO_FATAL_FAILURE(addMeasurementModeParam(mMeasurementMode));
+ addMeasurementModeParam(mMeasurementMode);
ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
TEST_P(VisualizerParamTest, SetAndGetLatency) {
- ASSERT_NO_FATAL_FAILURE(addLatencyParam(mLatency));
+ addLatencyParam(mLatency);
ASSERT_NO_FATAL_FAILURE(SetAndGetParameters());
}
@@ -212,10 +212,10 @@
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
bool allParamsValid = true;
- ASSERT_NO_FATAL_FAILURE(addCaptureSizeParam(mCaptureSize));
- ASSERT_NO_FATAL_FAILURE(addScalingModeParam(mScalingMode));
- ASSERT_NO_FATAL_FAILURE(addMeasurementModeParam(mMeasurementMode));
- ASSERT_NO_FATAL_FAILURE(addLatencyParam(mLatency));
+ addCaptureSizeParam(mCaptureSize);
+ addScalingModeParam(mScalingMode);
+ addMeasurementModeParam(mMeasurementMode);
+ addLatencyParam(mLatency);
ASSERT_NO_FATAL_FAILURE(SetAndGetParameters(&allParamsValid));
Parameter getParam;
@@ -276,9 +276,9 @@
for (float maxAudioSampleValue : testMaxAudioSampleValueList) {
bool allParamsValid = true;
- ASSERT_NO_FATAL_FAILURE(addCaptureSizeParam(mCaptureSize));
- ASSERT_NO_FATAL_FAILURE(addScalingModeParam(mScalingMode));
- ASSERT_NO_FATAL_FAILURE(addLatencyParam(mLatency));
+ addCaptureSizeParam(mCaptureSize);
+ addScalingModeParam(mScalingMode);
+ addLatencyParam(mLatency);
ASSERT_NO_FATAL_FAILURE(SetAndGetParameters(&allParamsValid));
generateSineWave(std::vector<int>{1000}, mInputBuffer, maxAudioSampleValue,
diff --git a/automotive/vehicle/aidl/aidl_api/android.hardware.automotive.vehicle/current/android/hardware/automotive/vehicle/VehicleAreaConfig.aidl b/automotive/vehicle/aidl/aidl_api/android.hardware.automotive.vehicle/current/android/hardware/automotive/vehicle/VehicleAreaConfig.aidl
index e3f8605..465d9d4 100644
--- a/automotive/vehicle/aidl/aidl_api/android.hardware.automotive.vehicle/current/android/hardware/automotive/vehicle/VehicleAreaConfig.aidl
+++ b/automotive/vehicle/aidl/aidl_api/android.hardware.automotive.vehicle/current/android/hardware/automotive/vehicle/VehicleAreaConfig.aidl
@@ -35,33 +35,12 @@
@JavaDerive(equals=true, toString=true) @RustDerive(Clone=true) @VintfStability
parcelable VehicleAreaConfig {
int areaId;
- /**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead. Only applicable for {@code INT32} type property. Ignored for other types. The optional minimum value at boot time. For backward compatibility, if {@code HasSupportedValueInfo.hasMinSupportedValue} is {@code true}, and {@code HasSupportedValueInfo.hasMaxSupportedValue} is {@code true}, this must be equal to the min supported value ({@code MinMaxSupportedValueResult.minSupportedValue}) at boot time. If no minimum or maximum value is available at boot time, both {@code minInt32Value} and {@code maxInt32Value} must be set to 0. If either one is not 0, then we assume min and max both take effect.
- */
int minInt32Value;
- /**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead. Only applicable for {@code INT32} type property. Ignored for other types. The optional maximum value at boot time. For backward compatibility, if {@code HasSupportedValueInfo.hasMinSupportedValue} is {@code true}, and {@code HasSupportedValueInfo.hasMaxSupportedValue} is {@code true}, this must be equal to the max supported value ({@code MinMaxSupportedValueResult.maxSupportedValue}) at boot time. If no minimum or maximum value is available at boot time, both {@code minInt32Value} and {@code maxInt32Value} must be set to 0. If either one is not 0, then we assume min and max both take effect.
- */
int maxInt32Value;
- /**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead. Only applicable for {@code INT64} type property. Ignored for other types. The optional minimum value at boot time. For backward compatibility, if {@code HasSupportedValueInfo.hasMinSupportedValue} is {@code true}, and {@code HasSupportedValueInfo.hasMaxSupportedValue} is {@code true}, this must be equal to the min supported value ({@code MinMaxSupportedValueResult.minSupportedValue}) at boot time. If no minimum or maximum value is available at boot time, both {@code minInt64Value} and {@code maxInt64Value} must be set to 0. If either one is not 0, then we assume min and max both take effect.
- */
long minInt64Value;
- /**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead. Only applicable for {@code INT64} type property. Ignored for other types. The optional maximum value at boot time. For backward compatibility, if {@code HasSupportedValueInfo.hasMinSupportedValue} is {@code true}, and {@code HasSupportedValueInfo.hasMaxSupportedValue} is {@code true}, this must be equal to the max supported value ({@code MinMaxSupportedValueResult.maxSupportedValue}) at boot time. If no minimum or maximum value is available at boot time, both {@code minInt64Value} and {@code maxInt64Value} must be set to 0. If either one is not 0, then we assume min and max both take effect.
- */
long maxInt64Value;
- /**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead. Only applicable for {@code FLOAT} type property. Ignored for other types. The optional minimum value at boot time. For backward compatibility, if {@code HasSupportedValueInfo.hasMinSupportedValue} is {@code true}, and {@code HasSupportedValueInfo.hasMaxSupportedValue} is {@code true}, this must be equal to the min supported value ({@code MinMaxSupportedValueResult.minSupportedValue}) at boot time. If no minimum or maximum value is available at boot time, both {@code minFloatValue} and {@code maxFloatValue} must be set to 0. If either one is not 0, then we assume min and max both take effect.
- */
float minFloatValue;
- /**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead. Only applicable for {@code FLOAT} type property. Ignored for other types. The optional maximum value at boot time. For backward compatibility, if {@code HasSupportedValueInfo.hasMinSupportedValue} is {@code true}, and {@code HasSupportedValueInfo.hasMaxSupportedValue} is {@code true}, this must be equal to the max supported value ({@code MinMaxSupportedValueResult.maxSupportedValue}) at boot time. If no minimum or maximum value is available at boot time, both {@code minFloatValue} and {@code maxFloatValue} must be set to 0. If either one is not 0, then we assume min and max both take effect.
- */
float maxFloatValue;
- /**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead. Only applicable for property with {@code @data_enum} annotation. Ignored for other properties. Optional supported subset of supported values at boot time. If the property has a @data_enum and supportedEnumValues is {@code null}, then it is assumed all @data_enum values are supported unless specified through another mechanism. For backward compatibility, if {@code HasSupportedValueInfo.hasSupportedValuesList} is {@code true} and this property has {@code data_enum} annotation, this must be set to the same as {@code SupportedValuesListResult.supportedValuesList} at boot time.
- */
@nullable long[] supportedEnumValues;
android.hardware.automotive.vehicle.VehiclePropertyAccess access = android.hardware.automotive.vehicle.VehiclePropertyAccess.NONE;
boolean supportVariableUpdateRate;
diff --git a/automotive/vehicle/aidl/android/hardware/automotive/vehicle/VehicleAreaConfig.aidl b/automotive/vehicle/aidl/android/hardware/automotive/vehicle/VehicleAreaConfig.aidl
index c6b8cd1..1720628 100644
--- a/automotive/vehicle/aidl/android/hardware/automotive/vehicle/VehicleAreaConfig.aidl
+++ b/automotive/vehicle/aidl/android/hardware/automotive/vehicle/VehicleAreaConfig.aidl
@@ -29,7 +29,7 @@
int areaId;
/**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead.
+ * client should use {@code getMinMaxSupportedValue} instead.
*
* Only applicable for {@code INT32} type property. Ignored for other types.
*
@@ -49,7 +49,7 @@
int minInt32Value;
/**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead.
+ * client should use {@code getMinMaxSupportedValue} instead.
*
* Only applicable for {@code INT32} type property. Ignored for other types.
*
@@ -69,7 +69,7 @@
int maxInt32Value;
/**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead.
+ * client should use {@code getMinMaxSupportedValue} instead.
*
* Only applicable for {@code INT64} type property. Ignored for other types.
*
@@ -89,7 +89,7 @@
long minInt64Value;
/**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead.
+ * client should use {@code getMinMaxSupportedValue} instead.
*
* Only applicable for {@code INT64} type property. Ignored for other types.
*
@@ -109,7 +109,7 @@
long maxInt64Value;
/**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead.
+ * client should use {@code getMinMaxSupportedValue} instead.
*
* Only applicable for {@code FLOAT} type property. Ignored for other types.
*
@@ -129,7 +129,7 @@
float minFloatValue;
/**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead.
+ * client should use {@code getMinMaxSupportedValue} instead.
*
* Only applicable for {@code FLOAT} type property. Ignored for other types.
*
@@ -149,7 +149,7 @@
float maxFloatValue;
/**
- * @deprecated client should use {@code getMinMaxSupportedValue} instead.
+ * client should use {@code getMinMaxSupportedValue} instead.
*
* Only applicable for property with {@code @data_enum} annotation. Ignored
* for other properties.
diff --git a/automotive/vehicle/aidl/emu_metadata/android.hardware.automotive.vehicle-types-meta.json b/automotive/vehicle/aidl/emu_metadata/android.hardware.automotive.vehicle-types-meta.json
index e0d450b..da73b03 100644
--- a/automotive/vehicle/aidl/emu_metadata/android.hardware.automotive.vehicle-types-meta.json
+++ b/automotive/vehicle/aidl/emu_metadata/android.hardware.automotive.vehicle-types-meta.json
@@ -882,27 +882,27 @@
{
"name": "SEAT_CUSHION_SIDE_SUPPORT_POS",
"value": 356518815,
- "description": "Represents property for seat’s hipside (bottom cushion’s side) support position.\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe maxInt32Value indicates the seat cushion side support is in its widest position (i.e. least support). The minInt32Value indicates the seat cushion side support is in its thinnest position (i.e. most support).\nValues in between minInt32Value and maxInt32Value indicate a transition state between the thinnest and widest positions.\nThis property is not in any particular unit but in a specified range of relative positions.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Represents property for seat’s hipside (bottom cushion’s side) support position.\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the seat cushion side support is in its thinnest position (i.e. most support).\nThe maxInt32Value indicates the seat cushion side support is in its widest position (i.e. least support).\nValues in between minInt32Value and maxInt32Value indicate a transition state between the thinnest and widest positions.\nIf {@code HasSupportedValueInfo} for a specific area ID is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative positions.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "SEAT_CUSHION_SIDE_SUPPORT_MOVE",
"value": 356518816,
- "description": "Represents property for movement direction and speed of seat cushion side support.\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe maxInt32Value represents the maximum movement speed of the seat cushion side support when growing wider (i.e. support is decreasing). The minInt32Value represents the maximum movement speed of the seat cushion side support when growing thinner (i.e. support is increasing).\nLarger absolute values, either positive or negative, indicate a faster movement speed. Once the seat cushion side support reaches the positional limit, the value must reset to 0. If SEAT_CUSHION_SIDE_SUPPORT_MOVE's value is currently 0, then that means there is no movement currently occurring.\nThis property is not in any particular unit but in a specified range of relative movement speeds.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Represents property for movement direction and speed of seat cushion side support.\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value represents the maximum movement speed of the seat cushion side support when growing thinner (i.e. support is increasing).\nThe maxInt32Value represents the maximum movement speed of the seat cushion side support when growing wider (i.e. support is decreasing).\nLarger absolute values, either positive or negative, indicate a faster movement speed. Once the seat cushion side support reaches the positional limit, the value must reset to 0. If SEAT_CUSHION_SIDE_SUPPORT_MOVE's value is currently 0, then that means there is no movement currently occurring.\nIf {@code HasSupportedValueInfo} for a specific area ID is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative movement speeds.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "SEAT_LUMBAR_VERTICAL_POS",
"value": 356518817,
- "description": "Represents property for seat’s lumbar support vertical position.\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe maxInt32Value indicates the lumbar support's highest position. The minInt32Value indicates the lumbar support's lowest position.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the lowest and highest positions.\nThis property is not in any particular unit but in a specified range of relative positions.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Represents property for seat’s lumbar support vertical position.\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the lumbar support's lowest position.\nThe maxInt32Value indicates the lumbar support's highest position.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the lowest and highest positions.\nIf {@code HasSupportedValueInfo} for a specific area ID is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative positions.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "SEAT_LUMBAR_VERTICAL_MOVE",
"value": 356518818,
- "description": "Represents property for vertical movement direction and speed of seat lumbar support.\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe maxInt32Value indicates the lumbar support is moving at the fastest upward speed. The minInt32Value indicates the lumbar support is moving at the fastest downward speed.\nLarger absolute values, either positive or negative, indicate a faster movement speed. Once the seat cushion side support reaches the positional limit, the value must reset to 0. If SEAT_LUMBAR_VERTICAL_MOVE's value is currently 0, then that means there is no movement currently occurring.\nThis property is not in any particular unit but in a specified range of relative movement speeds.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Represents property for vertical movement direction and speed of seat lumbar support.\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the lumbar support is moving at the fastest downward speed.\nThe maxInt32Value indicates the lumbar support is moving at the fastest upward speed.\nLarger absolute values, either positive or negative, indicate a faster movement speed. Once the seat cushion side support reaches the positional limit, the value must reset to 0. If SEAT_LUMBAR_VERTICAL_MOVE's value is currently 0, then that means there is no movement currently occurring.\nIf {@code HasSupportedValueInfo} for a specific area ID is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative movement speeds.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "SEAT_WALK_IN_POS",
"value": 356518819,
- "description": "Represents property that indicates the current walk-in position of the seat.\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the normal seat position. The minInt32Value must be 0. The maxInt32Value indicates the seat is in the full walk-in position.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the normal and walk-in positions.\nThis property is not in any particular unit but in a specified range of relative positions.\nThe area ID must match the seat that actually moves when the walk-in feature activates, not the intended seat the passengers will sit in.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Represents property that indicates the current walk-in position of the seat.\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the normal seat position. The minInt32Value must be 0.\nThe maxInt32Value indicates the seat is in the full walk-in position.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the normal and walk-in positions.\nIf {@code HasSupportedValueInfo} for a specific area ID is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative positions.\nThe area ID must match the seat that actually moves when the walk-in feature activates, not the intended seat the passengers will sit in.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "SEAT_BELT_PRETENSIONER_DEPLOYED",
@@ -921,12 +921,12 @@
{
"name": "Window Position",
"value": 322964416,
- "description": "Window Position\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the window is closed\/fully open out of plane. If the window cannot open out of plane, then minInt32Value is the position of the window when fully closed and must be 0. If the window can open out of plane, the minInt32Value indicates the window is fully open in its position out of plane and will be a negative value. See the example below for a more detailed explanation. The maxInt32Value indicates the window is fully open.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the closed\/fully open out-of-plane and fully open positions.\nThis property is not in any particular unit but in a specified range of relative positions.\nFor example, this is how the property should work for a window that can move out of plane: For a window that may open out of plane (i.e. vent mode of sunroof) this parameter will work with negative values as follows: Max = sunroof completely open 0 = sunroof closed. Min = sunroof vent completely open\nNote that in this mode, 0 indicates the window is closed.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Window Position\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined.\nAll integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the window is closed\/fully open out of plane. If the window cannot open out of plane, then minInt32Value is the position of the window when fully closed and must be 0. If the window can open out of plane, the minInt32Value indicates the window is fully open in its position out of plane and will be a negative value. See the example below for a more detailed explanation.\nThe maxInt32Value indicates the window is fully open.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the closed\/fully open out-of-plane and fully open positions.\nThis property is not in any particular unit but in a specified range of relative positions.\nFor example, this is how the property should work for a window that can move out of plane: For a window that may open out of plane (i.e. vent mode of sunroof) this parameter will work with negative values as follows: Max = sunroof completely open 0 = sunroof closed. Min = sunroof vent completely open\nNote that in this mode, 0 indicates the window is closed.\nIf {@code HasSupportedValueInfo} for a specific area ID is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "Window Move",
"value": 322964417,
- "description": "Window Move\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe maxInt32Value indicates the window is opening in plane\/closing in the out of plane direction at the fastest speed. The minInt32Value indicates the window is closing in plane\/opening in the out of plane direction at the fastest speed.\nLarger absolute values, either positive or negative, indicate a faster movement speed. Once the window reaches the positional limit, the value must reset to 0. If WINDOW_MOVE's value is currently 0, then that means there is no movement currently occurring.\nThis property is not in any particular unit but in a specified range of relative movement speeds.\nFor a window that may open out of plane (i.e. vent mode of sunroof) this parameter will work as follows:\nIf sunroof is open: Max = open the sunroof further, automatically stop when fully open. Min = close the sunroof, automatically stop when sunroof is closed.\nIf vent is open: Max = close the vent, automatically stop when vent is closed. Min = open the vent further, automatically stop when vent is fully open.\nIf sunroof is in the closed position: Max = open the sunroof, automatically stop when sunroof is fully open. Min = open the vent, automatically stop when vent is fully open.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Window Move\nThe maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the window is closing in plane\/opening in the out of plane direction at the fastest speed.\nThe maxInt32Value indicates the window is opening in plane\/closing in the out of plane direction at the fastest speed.\nLarger absolute values, either positive or negative, indicate a faster movement speed. Once the window reaches the positional limit, the value must reset to 0. If WINDOW_MOVE's value is currently 0, then that means there is no movement currently occurring.\nThis property is not in any particular unit but in a specified range of relative movement speeds.\nFor a window that may open out of plane (i.e. vent mode of sunroof) this parameter will work as follows:\nIf sunroof is open: Max = open the sunroof further, automatically stop when fully open. Min = close the sunroof, automatically stop when sunroof is closed.\nIf vent is open: Max = close the vent, automatically stop when vent is closed. Min = open the vent further, automatically stop when vent is fully open.\nIf sunroof is in the closed position: Max = open the sunroof, automatically stop when sunroof is fully open. Min = open the vent, automatically stop when vent is fully open.\nIf {@code HasSupportedValueInfo} for a specific area ID is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "Window Child Lock",
@@ -936,7 +936,7 @@
{
"name": "WINDSHIELD_WIPERS_PERIOD",
"value": 322964421,
- "description": "Windshield wipers period (milliseconds).\nReturns the instantaneous time period for 1 full cycle of the windshield wipers in milliseconds. A full cycle is defined as a wiper moving from and returning to its rest position.\nWhen an intermittent wiper setting is selected, this property value must be set to 0 during the \"pause\" period of the intermittent wiping.\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. The maxInt32Value for each area ID must specify the longest wiper period. The minInt32Value must be set to 0 for each area ID."
+ "description": "Windshield wipers period (milliseconds).\nReturns the instantaneous time period for 1 full cycle of the windshield wipers in milliseconds. A full cycle is defined as a wiper moving from and returning to its rest position.\nWhen an intermittent wiper setting is selected, this property value must be set to 0 during the \"pause\" period of the intermittent wiping.\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined.\nThe minInt32Value must be set to 0 for each area ID.\nThe maxInt32Value for each area ID must specify the longest wiper period.\nIf {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue."
},
{
"name": "Windshield wipers state.",
@@ -959,22 +959,22 @@
{
"name": "Steering wheel depth position",
"value": 289410016,
- "description": "Steering wheel depth position\nAll steering wheel properties' unique ids start from 0x0BE0.\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between minInt32Value and maxInt32Value must be supported.\nThe maxInt32Value indicates the steering wheel position furthest from the driver. The minInt32Value indicates the steering wheel position closest to the driver.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the closest and furthest positions.\nThis property is not in any particular unit but in a specified range of relative positions.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Steering wheel depth position\nAll steering wheel properties' unique ids start from 0x0BE0.\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the steering wheel position closest to the driver.\nThe maxInt32Value indicates the steering wheel position furthest from the driver.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the closest and furthest positions.\nIf {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative positions.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "Steering wheel depth movement",
"value": 289410017,
- "description": "Steering wheel depth movement\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between minInt32Value and maxInt32Value must be supported.\nThe maxInt32Value indicates the steering wheel moving away from the driver. The minInt32Value indicates the steering wheel moving towards the driver.\nLarger integers, either positive or negative, indicate a faster movement speed. Once the steering wheel reaches the positional limit, the value must reset to 0. If STEERING_WHEEL_DEPTH_MOVE's value is currently 0, then that means there is no movement currently occurring.\nThis property is not in any particular unit but in a specified range of relative movement speeds.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Steering wheel depth movement\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the steering wheel moving towards the driver.\nThe maxInt32Value indicates the steering wheel moving away from the driver.\nLarger integers, either positive or negative, indicate a faster movement speed. Once the steering wheel reaches the positional limit, the value must reset to 0. If STEERING_WHEEL_DEPTH_MOVE's value is currently 0, then that means there is no movement currently occurring.\nIf {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative movement speeds.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "Steering wheel height position",
"value": 289410018,
- "description": "Steering wheel height position\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between minInt32Value and maxInt32Value must be supported.\nThe maxInt32Value indicates the steering wheel being in the highest position. The minInt32Value indicates the steering wheel being in the lowest position.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the lowest and highest positions.\nThis property is not in any particular unit but in a specified range of relative positions.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Steering wheel height position\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the steering wheel being in the lowest position.\nThe maxInt32Value indicates the steering wheel being in the highest position.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the lowest and highest positions.\nIf {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative positions.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "Steering wheel height movement",
"value": 289410019,
- "description": "Steering wheel height movement\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between minInt32Value and maxInt32Value must be supported.\nThe maxInt32Value indicates the steering wheel moving upwards. The minInt32Value indicates the steering wheel moving downwards.\nLarger integers, either positive or negative, indicate a faster movement speed. Once the steering wheel reaches the positional limit, the value must reset to 0. If STEERING_WHEEL_HEIGHT_MOVE's value is currently 0, then that means there is no movement currently occurring.\nThis property is not in any particular unit but in a specified range of relative movement speeds.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Steering wheel height movement\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the steering wheel moving downwards.\nThe maxInt32Value indicates the steering wheel moving upwards.\nLarger integers, either positive or negative, indicate a faster movement speed. Once the steering wheel reaches the positional limit, the value must reset to 0. If STEERING_WHEEL_HEIGHT_MOVE's value is currently 0, then that means there is no movement currently occurring.\nIf {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative movement speeds.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "STEERING_WHEEL_THEFT_LOCK_ENABLED",
@@ -994,7 +994,7 @@
{
"name": "GLOVE_BOX_DOOR_POS",
"value": 356518896,
- "description": "Property that represents the current position of the glove box door.\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates that the glove box door is closed. The minInt32Value must be 0. The maxInt32Value indicates that the glove box door is in the fully open position.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the closed and fully open positions.\nThis property is not in any particular unit but in a specified range of relative positions.\nThe area ID must match the seat by which the glove box is intended to be used (e.g. if the front right dashboard has a glove box embedded in it, then the area ID should be SEAT_1_RIGHT).\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
+ "description": "Property that represents the current position of the glove box door.\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates that the glove box door is closed. The minInt32Value must be 0.\nThe maxInt32Value indicates that the glove box door is in the fully open position.\nValues in between minInt32Value and maxInt32Value indicate a transition state between the closed and fully open positions.\nIf {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}: {@code HasSupportedValueInfo.hasMinSupportedValue} and {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}. {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative positions.\nThe area ID must match the seat by which the glove box is intended to be used (e.g. if the front right dashboard has a glove box embedded in it, then the area ID should be SEAT_1_RIGHT).\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
"name": "Lock or unlock the glove box.",
diff --git a/automotive/vehicle/aidl/impl/current/default_config/JsonConfigLoader/src/JsonConfigLoader.cpp b/automotive/vehicle/aidl/impl/current/default_config/JsonConfigLoader/src/JsonConfigLoader.cpp
index 7a1f0e0..f910beb 100644
--- a/automotive/vehicle/aidl/impl/current/default_config/JsonConfigLoader/src/JsonConfigLoader.cpp
+++ b/automotive/vehicle/aidl/impl/current/default_config/JsonConfigLoader/src/JsonConfigLoader.cpp
@@ -58,6 +58,7 @@
using ::aidl::android::hardware::automotive::vehicle::GsrComplianceRequirementType;
using ::aidl::android::hardware::automotive::vehicle::HandsOnDetectionDriverState;
using ::aidl::android::hardware::automotive::vehicle::HandsOnDetectionWarning;
+using ::aidl::android::hardware::automotive::vehicle::HasSupportedValueInfo;
using ::aidl::android::hardware::automotive::vehicle::ImpactSensorLocation;
using ::aidl::android::hardware::automotive::vehicle::LaneCenteringAssistCommand;
using ::aidl::android::hardware::automotive::vehicle::LaneCenteringAssistState;
@@ -600,6 +601,22 @@
if (!supportedEnumValues.empty()) {
areaConfig.supportedEnumValues = std::move(supportedEnumValues);
}
+
+ if (jsonAreaConfig.isMember("hasSupportedValueInfo")) {
+ HasSupportedValueInfo hasSupportedValueInfo = HasSupportedValueInfo{};
+ const Json::Value& jsonHasSupportedValueInfo = jsonAreaConfig["hasSupportedValueInfo"];
+ tryParseJsonValueToVariable(jsonHasSupportedValueInfo, "hasMinSupportedValue",
+ /*optional=*/true,
+ &hasSupportedValueInfo.hasMinSupportedValue, errors);
+ tryParseJsonValueToVariable(jsonHasSupportedValueInfo, "hasMaxSupportedValue",
+ /*optional=*/true,
+ &hasSupportedValueInfo.hasMaxSupportedValue, errors);
+ tryParseJsonValueToVariable(jsonHasSupportedValueInfo, "hasSupportedValuesList",
+ /*optional=*/true,
+ &hasSupportedValueInfo.hasSupportedValuesList, errors);
+ areaConfig.hasSupportedValueInfo = std::move(hasSupportedValueInfo);
+ }
+
config->config.areaConfigs.push_back(std::move(areaConfig));
RawPropValues areaValue = {};
diff --git a/automotive/vehicle/aidl/impl/current/default_config/JsonConfigLoader/test/JsonConfigLoaderUnitTest.cpp b/automotive/vehicle/aidl/impl/current/default_config/JsonConfigLoader/test/JsonConfigLoaderUnitTest.cpp
index 54afbd4..595c2ed 100644
--- a/automotive/vehicle/aidl/impl/current/default_config/JsonConfigLoader/test/JsonConfigLoaderUnitTest.cpp
+++ b/automotive/vehicle/aidl/impl/current/default_config/JsonConfigLoader/test/JsonConfigLoaderUnitTest.cpp
@@ -26,6 +26,7 @@
namespace automotive {
namespace vehicle {
+using ::aidl::android::hardware::automotive::vehicle::HasSupportedValueInfo;
using ::aidl::android::hardware::automotive::vehicle::RawPropValues;
using ::aidl::android::hardware::automotive::vehicle::VehicleAreaConfig;
using ::aidl::android::hardware::automotive::vehicle::VehiclePropConfig;
@@ -803,6 +804,108 @@
ASSERT_EQ(areaConfig2.areaId, 1);
}
+TEST_F(JsonConfigLoaderUnitTest, testHasSupportedValueInfo_allTrue) {
+ std::istringstream iss(R"(
+ {
+ "properties": [{
+ "property": "VehicleProperty::CABIN_LIGHTS_SWITCH",
+ "areas": [{
+ "access": "VehiclePropertyAccess::WRITE",
+ "areaId": 0,
+ "hasSupportedValueInfo": {
+ "hasMinSupportedValue": true,
+ "hasMaxSupportedValue": true,
+ "hasSupportedValuesList": true
+ }
+ }],
+ "access": "VehiclePropertyAccess::READ",
+ }]
+ }
+ )");
+
+ auto result = mLoader.loadPropConfig(iss);
+ ASSERT_TRUE(result.ok());
+
+ auto configs = result.value();
+ ASSERT_EQ(configs.size(), 1u);
+
+ const VehiclePropConfig& config = configs.begin()->second.config;
+ ASSERT_EQ(config.access, VehiclePropertyAccess::READ);
+ ASSERT_EQ(config.areaConfigs.size(), 1u);
+
+ const VehicleAreaConfig& areaConfig = config.areaConfigs[0];
+ ASSERT_EQ(areaConfig.hasSupportedValueInfo, HasSupportedValueInfo({
+ .hasMinSupportedValue = true,
+ .hasMaxSupportedValue = true,
+ .hasSupportedValuesList = true,
+ }));
+}
+
+TEST_F(JsonConfigLoaderUnitTest, testHasSupportedValueInfo_allFalse) {
+ std::istringstream iss(R"(
+ {
+ "properties": [{
+ "property": "VehicleProperty::CABIN_LIGHTS_SWITCH",
+ "areas": [{
+ "access": "VehiclePropertyAccess::WRITE",
+ "areaId": 0,
+ "hasSupportedValueInfo": {
+ "hasMinSupportedValue": false,
+ "hasMaxSupportedValue": false,
+ "hasSupportedValuesList": false
+ }
+ }],
+ "access": "VehiclePropertyAccess::READ",
+ }]
+ }
+ )");
+
+ auto result = mLoader.loadPropConfig(iss);
+ ASSERT_TRUE(result.ok());
+
+ auto configs = result.value();
+ ASSERT_EQ(configs.size(), 1u);
+
+ const VehiclePropConfig& config = configs.begin()->second.config;
+ ASSERT_EQ(config.access, VehiclePropertyAccess::READ);
+ ASSERT_EQ(config.areaConfigs.size(), 1u);
+
+ const VehicleAreaConfig& areaConfig = config.areaConfigs[0];
+ ASSERT_EQ(areaConfig.hasSupportedValueInfo, HasSupportedValueInfo({
+ .hasMinSupportedValue = false,
+ .hasMaxSupportedValue = false,
+ .hasSupportedValuesList = false,
+ }));
+}
+
+TEST_F(JsonConfigLoaderUnitTest, testHasSupportedValueInfo_unspecified) {
+ std::istringstream iss(R"(
+ {
+ "properties": [{
+ "property": "VehicleProperty::CABIN_LIGHTS_SWITCH",
+ "areas": [{
+ "access": "VehiclePropertyAccess::WRITE",
+ "areaId": 0
+ }],
+ "access": "VehiclePropertyAccess::READ",
+ }]
+ }
+ )");
+
+ auto result = mLoader.loadPropConfig(iss);
+ ASSERT_TRUE(result.ok());
+
+ auto configs = result.value();
+ ASSERT_EQ(configs.size(), 1u);
+
+ const VehiclePropConfig& config = configs.begin()->second.config;
+ ASSERT_EQ(config.access, VehiclePropertyAccess::READ);
+ ASSERT_EQ(config.areaConfigs.size(), 1u);
+
+ const VehicleAreaConfig& areaConfig = config.areaConfigs[0];
+ ASSERT_EQ(areaConfig.hasSupportedValueInfo, std::nullopt);
+}
+
} // namespace vehicle
} // namespace automotive
} // namespace hardware
diff --git a/automotive/vehicle/aidl/impl/current/default_config/config/TestProperties.json b/automotive/vehicle/aidl/impl/current/default_config/config/TestProperties.json
index 73e4d44..83debf7 100644
--- a/automotive/vehicle/aidl/impl/current/default_config/config/TestProperties.json
+++ b/automotive/vehicle/aidl/impl/current/default_config/config/TestProperties.json
@@ -99,12 +99,15 @@
{
"defaultValue": {
"int32Values": [
- 1
+ 2
]
},
"areaId": "VehicleAreaWindow::FRONT_WINDSHIELD",
- "minInt32Value": -100,
- "maxInt32Value": 100
+ "hasSupportedValueInfo": {
+ "hasMinSupportedValue": true,
+ "hasMaxSupportedValue": true,
+ "hasSupportedValuesList": true
+ }
},
{
"defaultValue": {
diff --git a/automotive/vehicle/aidl/impl/current/fake_impl/hardware/include/FakeVehicleHardware.h b/automotive/vehicle/aidl/impl/current/fake_impl/hardware/include/FakeVehicleHardware.h
index 5916307..b7ada62 100644
--- a/automotive/vehicle/aidl/impl/current/fake_impl/hardware/include/FakeVehicleHardware.h
+++ b/automotive/vehicle/aidl/impl/current/fake_impl/hardware/include/FakeVehicleHardware.h
@@ -108,6 +108,12 @@
aidl::android::hardware::automotive::vehicle::StatusCode unsubscribe(int32_t propId,
int32_t areaId) override;
+ std::vector<aidlvhal::MinMaxSupportedValueResult> getMinMaxSupportedValues(
+ const std::vector<PropIdAreaId>& propIdAreaIds) override;
+
+ std::vector<aidlvhal::SupportedValuesListResult> getSupportedValuesLists(
+ const std::vector<PropIdAreaId>& propIdAreaIds) override;
+
protected:
// mValuePool is also used in mServerSidePropStore.
const std::shared_ptr<VehiclePropValuePool> mValuePool;
diff --git a/automotive/vehicle/aidl/impl/current/fake_impl/hardware/src/FakeVehicleHardware.cpp b/automotive/vehicle/aidl/impl/current/fake_impl/hardware/src/FakeVehicleHardware.cpp
index 52daf68..f1aaefc 100644
--- a/automotive/vehicle/aidl/impl/current/fake_impl/hardware/src/FakeVehicleHardware.cpp
+++ b/automotive/vehicle/aidl/impl/current/fake_impl/hardware/src/FakeVehicleHardware.cpp
@@ -62,11 +62,13 @@
using ::aidl::android::hardware::automotive::vehicle::ErrorState;
using ::aidl::android::hardware::automotive::vehicle::GetValueRequest;
using ::aidl::android::hardware::automotive::vehicle::GetValueResult;
+using ::aidl::android::hardware::automotive::vehicle::MinMaxSupportedValueResult;
using ::aidl::android::hardware::automotive::vehicle::RawPropValues;
using ::aidl::android::hardware::automotive::vehicle::SetValueRequest;
using ::aidl::android::hardware::automotive::vehicle::SetValueResult;
using ::aidl::android::hardware::automotive::vehicle::StatusCode;
using ::aidl::android::hardware::automotive::vehicle::SubscribeOptions;
+using ::aidl::android::hardware::automotive::vehicle::SupportedValuesListResult;
using ::aidl::android::hardware::automotive::vehicle::toString;
using ::aidl::android::hardware::automotive::vehicle::VehicleApPowerStateReport;
using ::aidl::android::hardware::automotive::vehicle::VehicleApPowerStateReq;
@@ -2299,6 +2301,62 @@
return StatusCode::OK;
}
+std::vector<MinMaxSupportedValueResult> FakeVehicleHardware::getMinMaxSupportedValues(
+ const std::vector<PropIdAreaId>& propIdAreaIds) {
+ std::vector<MinMaxSupportedValueResult> results;
+ // We only support VENDOR_EXTENSION_INT_PROPERTY
+ for (const auto& propIdAreaId : propIdAreaIds) {
+ int propId = propIdAreaId.propId;
+ int areaId = propIdAreaId.areaId;
+ if (propId != toInt(TestVendorProperty::VENDOR_EXTENSION_INT_PROPERTY)) {
+ results.push_back(MinMaxSupportedValueResult{
+ .status = StatusCode::INVALID_ARG,
+ });
+ continue;
+ }
+ results.push_back(MinMaxSupportedValueResult{
+ .status = StatusCode::OK,
+ .minSupportedValue =
+ RawPropValues{
+ .int32Values = {0},
+ },
+ .maxSupportedValue =
+ RawPropValues{
+ .int32Values = {10},
+ },
+ });
+ }
+ return results;
+}
+
+std::vector<SupportedValuesListResult> FakeVehicleHardware::getSupportedValuesLists(
+ const std::vector<PropIdAreaId>& propIdAreaIds) {
+ std::vector<SupportedValuesListResult> results;
+ // We only support VENDOR_EXTENSION_INT_PROPERTY
+ for (const auto& propIdAreaId : propIdAreaIds) {
+ int propId = propIdAreaId.propId;
+ int areaId = propIdAreaId.areaId;
+ if (propId != toInt(TestVendorProperty::VENDOR_EXTENSION_INT_PROPERTY)) {
+ results.push_back(SupportedValuesListResult{
+ .status = StatusCode::INVALID_ARG,
+ });
+ continue;
+ }
+ results.push_back(SupportedValuesListResult{
+ .status = StatusCode::OK,
+ .supportedValuesList = std::vector<std::optional<RawPropValues>>({
+ RawPropValues{.int32Values = {0}},
+ RawPropValues{.int32Values = {2}},
+ RawPropValues{.int32Values = {4}},
+ RawPropValues{.int32Values = {6}},
+ RawPropValues{.int32Values = {8}},
+ RawPropValues{.int32Values = {10}},
+ }),
+ });
+ }
+ return results;
+}
+
bool FakeVehicleHardware::isVariableUpdateRateSupported(const VehiclePropConfig& vehiclePropConfig,
int32_t areaId) {
for (size_t i = 0; i < vehiclePropConfig.areaConfigs.size(); i++) {
diff --git a/automotive/vehicle/aidl/impl/current/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp b/automotive/vehicle/aidl/impl/current/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp
index f6098ca..29a690b 100644
--- a/automotive/vehicle/aidl/impl/current/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp
+++ b/automotive/vehicle/aidl/impl/current/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp
@@ -3884,6 +3884,44 @@
}
}
+TEST_F(FakeVehicleHardwareTest, testGetMinMaxSupportedValues) {
+ auto results = getHardware()->getMinMaxSupportedValues({
+ PropIdAreaId{.propId = toInt(TestVendorProperty::VENDOR_EXTENSION_INT_PROPERTY),
+ .areaId = 0},
+ PropIdAreaId{.propId = toInt(VehicleProperty::HVAC_TEMPERATURE_SET), .areaId = 0},
+ });
+
+ ASSERT_EQ(results.size(), 2u);
+ EXPECT_EQ(results[0].status, StatusCode::OK);
+ EXPECT_NE(results[0].minSupportedValue, std::nullopt);
+ EXPECT_EQ(results[0].minSupportedValue.value(), RawPropValues{.int32Values = {0}});
+ EXPECT_NE(results[0].maxSupportedValue, std::nullopt);
+ EXPECT_EQ(results[0].maxSupportedValue.value(), RawPropValues{.int32Values = {10}});
+ EXPECT_EQ(results[1].status, StatusCode::INVALID_ARG);
+}
+
+TEST_F(FakeVehicleHardwareTest, testGetSupportedValuesLists) {
+ auto results = getHardware()->getSupportedValuesLists({
+ PropIdAreaId{.propId = toInt(TestVendorProperty::VENDOR_EXTENSION_INT_PROPERTY),
+ .areaId = 0},
+ PropIdAreaId{.propId = toInt(VehicleProperty::HVAC_TEMPERATURE_SET), .areaId = 0},
+ });
+
+ ASSERT_EQ(results.size(), 2u);
+ EXPECT_EQ(results[0].status, StatusCode::OK);
+ EXPECT_NE(results[0].supportedValuesList, std::nullopt);
+ EXPECT_NE((results[0].supportedValuesList)->size(), 0u);
+ EXPECT_EQ(results[0].supportedValuesList.value(), std::vector<std::optional<RawPropValues>>({
+ RawPropValues{.int32Values = {0}},
+ RawPropValues{.int32Values = {2}},
+ RawPropValues{.int32Values = {4}},
+ RawPropValues{.int32Values = {6}},
+ RawPropValues{.int32Values = {8}},
+ RawPropValues{.int32Values = {10}},
+ }));
+ EXPECT_EQ(results[1].status, StatusCode::INVALID_ARG);
+}
+
} // namespace fake
} // namespace vehicle
} // namespace automotive
diff --git a/automotive/vehicle/aidl/impl/current/vhal/include/DefaultVehicleHal.h b/automotive/vehicle/aidl/impl/current/vhal/include/DefaultVehicleHal.h
index 42902fe..d360be0 100644
--- a/automotive/vehicle/aidl/impl/current/vhal/include/DefaultVehicleHal.h
+++ b/automotive/vehicle/aidl/impl/current/vhal/include/DefaultVehicleHal.h
@@ -219,7 +219,7 @@
// mBinderEvents.
void onBinderDiedUnlinkedHandler();
- size_t countSubscribeClients();
+ size_t countClients();
// Handles the property change events in batch.
void handleBatchedPropertyEvents(std::vector<aidlvhal::VehiclePropValue>&& batchedEvents);
diff --git a/automotive/vehicle/aidl/impl/current/vhal/include/SubscriptionManager.h b/automotive/vehicle/aidl/impl/current/vhal/include/SubscriptionManager.h
index fa438ec..f4e6ced 100644
--- a/automotive/vehicle/aidl/impl/current/vhal/include/SubscriptionManager.h
+++ b/automotive/vehicle/aidl/impl/current/vhal/include/SubscriptionManager.h
@@ -146,6 +146,7 @@
private:
// Friend class for testing.
friend class DefaultVehicleHalTest;
+ friend class SubscriptionManagerTest;
IVehicleHardware* mVehicleHardware;
diff --git a/automotive/vehicle/aidl/impl/current/vhal/src/DefaultVehicleHal.cpp b/automotive/vehicle/aidl/impl/current/vhal/src/DefaultVehicleHal.cpp
index 050f88d..ea0c215 100644
--- a/automotive/vehicle/aidl/impl/current/vhal/src/DefaultVehicleHal.cpp
+++ b/automotive/vehicle/aidl/impl/current/vhal/src/DefaultVehicleHal.cpp
@@ -1336,15 +1336,19 @@
dprintf(fd, "Containing %zu property configs\n", configsByPropIdCopy.size());
dprintf(fd, "Currently have %zu getValues clients\n", mGetValuesClients.size());
dprintf(fd, "Currently have %zu setValues clients\n", mSetValuesClients.size());
- dprintf(fd, "Currently have %zu subscribe clients\n", countSubscribeClients());
+ dprintf(fd, "Currently have %zu subscribe clients\n",
+ mSubscriptionManager->countPropertyChangeClients());
dprintf(fd, "Currently have %zu supported values change subscribe clients\n",
mSubscriptionManager->countSupportedValueChangeClients());
}
return STATUS_OK;
}
-size_t DefaultVehicleHal::countSubscribeClients() {
- return mSubscriptionManager->countPropertyChangeClients();
+size_t DefaultVehicleHal::countClients() {
+ std::scoped_lock<std::mutex> lockGuard(mLock);
+ return mGetValuesClients.size() + mSetValuesClients.size() +
+ mSubscriptionManager->countPropertyChangeClients() +
+ mSubscriptionManager->countSupportedValueChangeClients();
}
} // namespace vehicle
diff --git a/automotive/vehicle/aidl/impl/current/vhal/src/SubscriptionManager.cpp b/automotive/vehicle/aidl/impl/current/vhal/src/SubscriptionManager.cpp
index 946c217..64c46c9 100644
--- a/automotive/vehicle/aidl/impl/current/vhal/src/SubscriptionManager.cpp
+++ b/automotive/vehicle/aidl/impl/current/vhal/src/SubscriptionManager.cpp
@@ -414,7 +414,6 @@
std::scoped_lock<std::mutex> lockGuard(mLock);
ClientIdType clientId = callback->asBinder().get();
- ALOGE("ClientId: %p", clientId);
// It is possible that some of the [propId, areaId]s are already subscribed, IVehicleHardware
// will ignore them.
@@ -479,7 +478,7 @@
mSupportedValueChangeClientsByPropIdAreaId.end()) {
mSupportedValueChangeClientsByPropIdAreaId[propIdAreaId].erase(clientId);
}
- if (mSupportedValueChangeClientsByPropIdAreaId.empty()) {
+ if (mSupportedValueChangeClientsByPropIdAreaId[propIdAreaId].empty()) {
mSupportedValueChangeClientsByPropIdAreaId.erase(propIdAreaId);
}
mSupportedValueChangePropIdAreaIdsByClient[clientId].erase(propIdAreaId);
diff --git a/automotive/vehicle/aidl/impl/current/vhal/test/DefaultVehicleHalTest.cpp b/automotive/vehicle/aidl/impl/current/vhal/test/DefaultVehicleHalTest.cpp
index 90b34c4..3b89e5f 100644
--- a/automotive/vehicle/aidl/impl/current/vhal/test/DefaultVehicleHalTest.cpp
+++ b/automotive/vehicle/aidl/impl/current/vhal/test/DefaultVehicleHalTest.cpp
@@ -445,11 +445,7 @@
size_t countPendingRequests() { return mVhal->mPendingRequestPool->countPendingRequests(); }
- size_t countClients() {
- std::scoped_lock<std::mutex> lockGuard(mVhal->mLock);
- return mVhal->mGetValuesClients.size() + mVhal->mSetValuesClients.size() +
- mVhal->countSubscribeClients();
- }
+ size_t countClients() { return mVhal->countClients(); }
std::shared_ptr<PendingRequestPool> getPool() { return mVhal->mPendingRequestPool; }
@@ -1878,8 +1874,8 @@
auto maybeResults = getCallback()->nextOnPropertyEventResults();
size_t retryCount = 0;
- // Add a 1s (100ms * 10) buffer time.
- while (!maybeResults.has_value() && retryCount < 10) {
+ // Add a 10s (100ms * 100) buffer time.
+ while (!maybeResults.has_value() && retryCount < 100) {
retryCount++;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
@@ -2575,8 +2571,10 @@
ASSERT_TRUE(status.isOk()) << "Get non-okay status from unregisterSupportedValueChangeCallback"
<< status.getMessage();
- ASSERT_TRUE(getHardware()->getSubscribedSupportedValueChangePropIdAreaIds().empty())
+ EXPECT_TRUE(getHardware()->getSubscribedSupportedValueChangePropIdAreaIds().empty())
<< "All registered [propId, areaId]s must be unregistered";
+ EXPECT_EQ(countClients(), static_cast<size_t>(0)) << "subscribe clients must be cleared";
+ EXPECT_TRUE(hasNoSubscriptions()) << "subscribe clients must be cleared";
}
TEST_F(DefaultVehicleHalTest, testUnregisterSupportedValueChangeCallback_errorFromHardware) {
diff --git a/automotive/vehicle/aidl/impl/current/vhal/test/SubscriptionManagerTest.cpp b/automotive/vehicle/aidl/impl/current/vhal/test/SubscriptionManagerTest.cpp
index 6d0844a..d624cce 100644
--- a/automotive/vehicle/aidl/impl/current/vhal/test/SubscriptionManagerTest.cpp
+++ b/automotive/vehicle/aidl/impl/current/vhal/test/SubscriptionManagerTest.cpp
@@ -124,6 +124,8 @@
std::shared_ptr<MockVehicleHardware> getHardware() { return mHardware; }
+ bool isEmpty() { return mManager->isEmpty(); }
+
private:
std::unique_ptr<SubscriptionManager> mManager;
std::shared_ptr<PropertyCallback> mCallback;
@@ -946,6 +948,19 @@
<< "Incorrect supported value change events for client1";
ASSERT_THAT(clients[client2], UnorderedElementsAre(propIdAreaId2))
<< "Incorrect supported value change events for client2";
+
+ result = getManager()->unsubscribeSupportedValueChange(binder2.get(), {propIdAreaId2});
+
+ ASSERT_TRUE(result.ok()) << "failed to call unsubscribeSupportedValueChange"
+ << result.error().message();
+
+ result = getManager()->unsubscribeSupportedValueChange(binder1.get(), {propIdAreaId1});
+
+ ASSERT_TRUE(result.ok()) << "failed to call unsubscribeSupportedValueChange"
+ << result.error().message();
+
+ EXPECT_EQ(getManager()->countSupportedValueChangeClients(), 0u) << "All clients cleared";
+ EXPECT_TRUE(isEmpty()) << "All clients cleared";
}
} // namespace vehicle
diff --git a/automotive/vehicle/aidl_property/android/hardware/automotive/vehicle/VehicleProperty.aidl b/automotive/vehicle/aidl_property/android/hardware/automotive/vehicle/VehicleProperty.aidl
index 09f7941..856d38c 100644
--- a/automotive/vehicle/aidl_property/android/hardware/automotive/vehicle/VehicleProperty.aidl
+++ b/automotive/vehicle/aidl_property/android/hardware/automotive/vehicle/VehicleProperty.aidl
@@ -3915,14 +3915,24 @@
* The maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers
* between minInt32Value and maxInt32Value must be supported.
*
- * The maxInt32Value indicates the seat cushion side support is in its widest position (i.e.
- * least support).
* The minInt32Value indicates the seat cushion side support is in its thinnest position (i.e.
* most support).
*
+ * The maxInt32Value indicates the seat cushion side support is in its widest position (i.e.
+ * least support).
+ *
* Values in between minInt32Value and maxInt32Value indicate a transition state between the
* thinnest and widest positions.
*
+ * If {@code HasSupportedValueInfo} for a specific area ID is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is not in any particular unit but in a specified range of relative positions.
*
* This property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to
@@ -3931,6 +3941,7 @@
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
SEAT_CUSHION_SIDE_SUPPORT_POS =
@@ -3941,16 +3952,26 @@
* The maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers
* between minInt32Value and maxInt32Value must be supported.
*
- * The maxInt32Value represents the maximum movement speed of the seat cushion side support when
- * growing wider (i.e. support is decreasing).
* The minInt32Value represents the maximum movement speed of the seat cushion side support when
* growing thinner (i.e. support is increasing).
*
+ * The maxInt32Value represents the maximum movement speed of the seat cushion side support when
+ * growing wider (i.e. support is decreasing).
+ *
* Larger absolute values, either positive or negative, indicate a faster movement speed. Once
* the seat cushion side support reaches the positional limit, the value must reset to 0. If
* SEAT_CUSHION_SIDE_SUPPORT_MOVE's value is currently 0, then that means there is no movement
* currently occurring.
*
+ * If {@code HasSupportedValueInfo} for a specific area ID is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is not in any particular unit but in a specified range of relative movement
* speeds.
*
@@ -3960,6 +3981,7 @@
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
SEAT_CUSHION_SIDE_SUPPORT_MOVE =
@@ -3970,12 +3992,22 @@
* The maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers
* between minInt32Value and maxInt32Value must be supported.
*
- * The maxInt32Value indicates the lumbar support's highest position.
* The minInt32Value indicates the lumbar support's lowest position.
*
+ * The maxInt32Value indicates the lumbar support's highest position.
+ *
* Values in between minInt32Value and maxInt32Value indicate a transition state between the
* lowest and highest positions.
*
+ * If {@code HasSupportedValueInfo} for a specific area ID is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is not in any particular unit but in a specified range of relative positions.
*
* This property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to
@@ -3984,6 +4016,7 @@
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
SEAT_LUMBAR_VERTICAL_POS =
@@ -3994,14 +4027,24 @@
* The maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers
* between minInt32Value and maxInt32Value must be supported.
*
- * The maxInt32Value indicates the lumbar support is moving at the fastest upward speed.
* The minInt32Value indicates the lumbar support is moving at the fastest downward speed.
*
+ * The maxInt32Value indicates the lumbar support is moving at the fastest upward speed.
+ *
* Larger absolute values, either positive or negative, indicate a faster movement speed. Once
* the seat cushion side support reaches the positional limit, the value must reset to 0. If
* SEAT_LUMBAR_VERTICAL_MOVE's value is currently 0, then that means there is no movement
* currently occurring.
*
+ * If {@code HasSupportedValueInfo} for a specific area ID is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is not in any particular unit but in a specified range of relative movement
* speeds.
*
@@ -4011,6 +4054,7 @@
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
SEAT_LUMBAR_VERTICAL_MOVE =
@@ -4022,11 +4066,21 @@
* All integers between minInt32Value and maxInt32Value must be supported.
*
* The minInt32Value indicates the normal seat position. The minInt32Value must be 0.
+ *
* The maxInt32Value indicates the seat is in the full walk-in position.
*
* Values in between minInt32Value and maxInt32Value indicate a transition state between the
* normal and walk-in positions.
*
+ * If {@code HasSupportedValueInfo} for a specific area ID is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is not in any particular unit but in a specified range of relative positions.
*
* The area ID must match the seat that actually moves when the walk-in feature activates, not
@@ -4038,6 +4092,7 @@
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
SEAT_WALK_IN_POS =
@@ -4078,6 +4133,7 @@
* Window Position
*
* The maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined.
+ *
* All integers between minInt32Value and maxInt32Value must be supported.
*
* The minInt32Value indicates the window is closed/fully open out of plane. If the window
@@ -4085,6 +4141,7 @@
* and must be 0. If the window can open out of plane, the minInt32Value indicates the window
* is fully open in its position out of plane and will be a negative value. See the example
* below for a more detailed explanation.
+ *
* The maxInt32Value indicates the window is fully open.
*
* Values in between minInt32Value and maxInt32Value indicate a transition state between the
@@ -4101,12 +4158,22 @@
*
* Note that in this mode, 0 indicates the window is closed.
*
+ * If {@code HasSupportedValueInfo} for a specific area ID is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to
* implement it as VehiclePropertyAccess.READ only.
*
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
WINDOW_POS = 0x0BC0 + 0x10000000 + 0x03000000
@@ -4117,11 +4184,12 @@
* The maxInt32Value and minInt32Value in each VehicleAreaConfig must be defined. All integers
* between minInt32Value and maxInt32Value must be supported.
*
- * The maxInt32Value indicates the window is opening in plane/closing in the out of plane
- * direction at the fastest speed.
* The minInt32Value indicates the window is closing in plane/opening in the out of plane
* direction at the fastest speed.
*
+ * The maxInt32Value indicates the window is opening in plane/closing in the out of plane
+ * direction at the fastest speed.
+ *
* Larger absolute values, either positive or negative, indicate a faster movement speed. Once
* the window reaches the positional limit, the value must reset to 0. If WINDOW_MOVE's value is
* currently 0, then that means there is no movement currently occurring.
@@ -4144,12 +4212,22 @@
* Max = open the sunroof, automatically stop when sunroof is fully open.
* Min = open the vent, automatically stop when vent is fully open.
*
+ * If {@code HasSupportedValueInfo} for a specific area ID is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true} for the area ID.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to
* implement it as VehiclePropertyAccess.READ only.
*
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
WINDOW_MOVE = 0x0BC1 + 0x10000000 + 0x03000000
@@ -4179,13 +4257,25 @@
* When an intermittent wiper setting is selected, this property value must be set to 0 during
* the "pause" period of the intermittent wiping.
*
- * The maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. The maxInt32Value
- * for each area ID must specify the longest wiper period. The minInt32Value must be set to 0
- * for each area ID.
+ * The maxInt32Value and minInt32Value in VehicleAreaConfig must be defined.
+ *
+ * The minInt32Value must be set to 0 for each area ID.
+ *
+ * The maxInt32Value for each area ID must specify the longest wiper period.
+ *
+ * If {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
*
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ
* @unit VehicleUnit.MILLI_SECS
+ * @require_min_max_supported_value
* @version 2
*/
WINDSHIELD_WIPERS_PERIOD =
@@ -4260,12 +4350,22 @@
* The maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between
* minInt32Value and maxInt32Value must be supported.
*
- * The maxInt32Value indicates the steering wheel position furthest from the driver.
* The minInt32Value indicates the steering wheel position closest to the driver.
*
+ * The maxInt32Value indicates the steering wheel position furthest from the driver.
+ *
* Values in between minInt32Value and maxInt32Value indicate a transition state between the
* closest and furthest positions.
*
+ * If {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is not in any particular unit but in a specified range of relative positions.
*
* This property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to
@@ -4274,6 +4374,7 @@
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
STEERING_WHEEL_DEPTH_POS =
@@ -4284,14 +4385,24 @@
* The maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between
* minInt32Value and maxInt32Value must be supported.
*
- * The maxInt32Value indicates the steering wheel moving away from the driver.
* The minInt32Value indicates the steering wheel moving towards the driver.
*
+ * The maxInt32Value indicates the steering wheel moving away from the driver.
+ *
* Larger integers, either positive or negative, indicate a faster movement speed. Once the
* steering wheel reaches the positional limit, the value must reset to 0. If
* STEERING_WHEEL_DEPTH_MOVE's value is currently 0, then that means there is no movement
* currently occurring.
*
+ * If {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is not in any particular unit but in a specified range of relative movement
* speeds.
*
@@ -4301,6 +4412,7 @@
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
STEERING_WHEEL_DEPTH_MOVE =
@@ -4311,12 +4423,22 @@
* The maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between
* minInt32Value and maxInt32Value must be supported.
*
- * The maxInt32Value indicates the steering wheel being in the highest position.
* The minInt32Value indicates the steering wheel being in the lowest position.
*
+ * The maxInt32Value indicates the steering wheel being in the highest position.
+ *
* Values in between minInt32Value and maxInt32Value indicate a transition state between the
* lowest and highest positions.
*
+ * If {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is not in any particular unit but in a specified range of relative positions.
*
* This property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to
@@ -4325,6 +4447,7 @@
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
STEERING_WHEEL_HEIGHT_POS =
@@ -4335,14 +4458,24 @@
* The maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All values between
* minInt32Value and maxInt32Value must be supported.
*
- * The maxInt32Value indicates the steering wheel moving upwards.
* The minInt32Value indicates the steering wheel moving downwards.
*
+ * The maxInt32Value indicates the steering wheel moving upwards.
+ *
* Larger integers, either positive or negative, indicate a faster movement speed. Once the
* steering wheel reaches the positional limit, the value must reset to 0. If
* STEERING_WHEEL_HEIGHT_MOVE's value is currently 0, then that means there is no movement
* currently occurring.
*
+ * If {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is not in any particular unit but in a specified range of relative movement
* speeds.
*
@@ -4352,6 +4485,7 @@
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
STEERING_WHEEL_HEIGHT_MOVE =
@@ -4410,11 +4544,21 @@
* All integers between minInt32Value and maxInt32Value must be supported.
*
* The minInt32Value indicates that the glove box door is closed. The minInt32Value must be 0.
+ *
* The maxInt32Value indicates that the glove box door is in the fully open position.
*
* Values in between minInt32Value and maxInt32Value indicate a transition state between the
* closed and fully open positions.
*
+ * If {@code HasSupportedValueInfo} for the global area ID (0) is not {@code null}:
+ * {@code HasSupportedValueInfo.hasMinSupportedValue} and
+ * {@code HasSupportedValueInfo.hasMaxSupportedValue} must be {@code true}.
+ * {@code MinMaxSupportedValueResult.minSupportedValue} has the same meaning as minInt32Value.
+ * {@code MinMaxSupportedValueResult.maxSupportedValue} has the same meaning as maxInt32Value.
+ * All integers between minSupportedValue and maxSupportedValue must be supported.
+ * At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to
+ * maxSupportedValue.
+ *
* This property is not in any particular unit but in a specified range of relative positions.
*
* The area ID must match the seat by which the glove box is intended to be used (e.g. if the
@@ -4427,6 +4571,7 @@
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
+ * @require_min_max_supported_value
* @version 2
*/
GLOVE_BOX_DOOR_POS =
diff --git a/biometrics/face/aidl/default/apex/Android.bp b/biometrics/face/aidl/default/apex/Android.bp
index c4632d4..0561145 100644
--- a/biometrics/face/aidl/default/apex/Android.bp
+++ b/biometrics/face/aidl/default/apex/Android.bp
@@ -19,7 +19,7 @@
apex {
name: "com.android.hardware.biometrics.face.virtual",
manifest: "manifest.json",
- file_contexts: "file_contexts",
+ file_contexts: ":com.android.biometrics.virtual.face-file_contexts",
key: "com.android.hardware.key",
certificate: ":com.android.hardware.certificate",
updatable: false,
diff --git a/biometrics/face/aidl/default/apex/file_contexts b/biometrics/face/aidl/default/apex/file_contexts
deleted file mode 100644
index 4f935c1..0000000
--- a/biometrics/face/aidl/default/apex/file_contexts
+++ /dev/null
@@ -1,3 +0,0 @@
-(/.*)? u:object_r:vendor_file:s0
-/etc(/.*)? u:object_r:vendor_configs_file:s0
-/bin/hw/android\.hardware\.biometrics\.face-service\.example u:object_r:hal_face_default_exec:s0
\ No newline at end of file
diff --git a/radio/aidl/aidl_api/android.hardware.radio.network/current/android/hardware/radio/network/IRadioNetwork.aidl b/radio/aidl/aidl_api/android.hardware.radio.network/current/android/hardware/radio/network/IRadioNetwork.aidl
index ad7473b..be76497 100644
--- a/radio/aidl/aidl_api/android.hardware.radio.network/current/android/hardware/radio/network/IRadioNetwork.aidl
+++ b/radio/aidl/aidl_api/android.hardware.radio.network/current/android/hardware/radio/network/IRadioNetwork.aidl
@@ -104,7 +104,7 @@
oneway void setCellularIdentifierTransparencyEnabled(in int serial, in boolean enabled);
oneway void setSecurityAlgorithmsUpdatedEnabled(in int serial, boolean enable);
oneway void isSecurityAlgorithmsUpdatedEnabled(in int serial);
- oneway void setSatellitePlmn(in int serial, in int simSlot, in String[] carrierPlmnArray, in String[] allSatellitePlmnArray);
- oneway void setSatelliteEnabledForCarrier(in int serial, in int simSlot, boolean satelliteEnabled);
- oneway void isSatelliteEnabledForCarrier(in int serial, in int simSlot);
+ oneway void setSatellitePlmn(in int serial, in String[] carrierPlmnArray, in String[] allSatellitePlmnArray);
+ oneway void setSatelliteEnabledForCarrier(in int serial, boolean satelliteEnabled);
+ oneway void isSatelliteEnabledForCarrier(in int serial);
}
diff --git a/radio/aidl/android/hardware/radio/network/IRadioNetwork.aidl b/radio/aidl/android/hardware/radio/network/IRadioNetwork.aidl
index 2509b6d..dce9865 100644
--- a/radio/aidl/android/hardware/radio/network/IRadioNetwork.aidl
+++ b/radio/aidl/android/hardware/radio/network/IRadioNetwork.aidl
@@ -734,8 +734,6 @@
* satellite LTE service.
*
* @param serial Serial number of request
- * @param simSlot Indicates the SIM slot to which this API will be applied. The modem will use
- * this information to determine the relevant carrier.
* @param carrierPlmnArray Array of roaming PLMN used for connecting to satellite networks
* supported by user subscription.
* @param allSatellitePlmnArray allSatellitePlmnArray contains all the PLMNs present in
@@ -749,8 +747,8 @@
*
* This is available when android.hardware.telephony.radio.access is defined.
*/
- void setSatellitePlmn(in int serial, in int simSlot, in String[] carrierPlmnArray,
- in String[] allSatellitePlmnArray);
+ void setSatellitePlmn(
+ in int serial, in String[] carrierPlmnArray, in String[] allSatellitePlmnArray);
/**
* Enable or disable satellite in the cellular modem associated with a carrier.
@@ -760,25 +758,22 @@
* If modem is enabled, modem should attach to only PLMNs present in carrierPlmnArray.
*
* @param serial Serial number of request
- * @param simSlot Indicates the SIM slot to which this API will be applied. The modem will use
- * this information to determine the relevant carrier.
* @param satelliteEnabled {@code true} to enable satellite, {@code false} to disable satellite.
*
* Response function is IRadioNetworkResponse.setSatelliteEnabledForCarrier()
*
* This is available when android.hardware.telephony.radio.access is defined.
*/
- void setSatelliteEnabledForCarrier(in int serial, in int simSlot, boolean satelliteEnabled);
+ void setSatelliteEnabledForCarrier(in int serial, boolean satelliteEnabled);
/**
* Check whether satellite is enabled in the cellular modem associated with a carrier.
*
* @param serial Serial number of request
- * @param simSlot Indicates the SIM slot to which this API will be applied.
*
* Response function is IRadioNetworkResponse.isSatelliteEnabledForCarrier()
*
* This is available when android.hardware.telephony.radio.access is defined.
*/
- void isSatelliteEnabledForCarrier(in int serial, in int simSlot);
+ void isSatelliteEnabledForCarrier(in int serial);
}
diff --git a/radio/aidl/compat/libradiocompat/include/libradiocompat/RadioNetwork.h b/radio/aidl/compat/libradiocompat/include/libradiocompat/RadioNetwork.h
index c9a3270..ae76808 100644
--- a/radio/aidl/compat/libradiocompat/include/libradiocompat/RadioNetwork.h
+++ b/radio/aidl/compat/libradiocompat/include/libradiocompat/RadioNetwork.h
@@ -115,11 +115,11 @@
::ndk::ScopedAStatus isSecurityAlgorithmsUpdatedEnabled(int32_t serial) override;
::ndk::ScopedAStatus setSatellitePlmn(
- int32_t serial, int32_t simSlot, const std::vector<std::string>& carrierPlmnArray,
+ int32_t serial, const std::vector<std::string>& carrierPlmnArray,
const std::vector<std::string>& allSatellitePlmnArray) override;
- ::ndk::ScopedAStatus setSatelliteEnabledForCarrier(int32_t serial, int32_t simSlot,
+ ::ndk::ScopedAStatus setSatelliteEnabledForCarrier(int32_t serial,
bool satelliteEnabled) override;
- ::ndk::ScopedAStatus isSatelliteEnabledForCarrier(int32_t serial, int32_t simSlot) override;
+ ::ndk::ScopedAStatus isSatelliteEnabledForCarrier(int32_t serial) override;
protected:
std::shared_ptr<::aidl::android::hardware::radio::network::IRadioNetworkResponse> respond();
diff --git a/radio/aidl/compat/libradiocompat/network/RadioNetwork.cpp b/radio/aidl/compat/libradiocompat/network/RadioNetwork.cpp
index b5aee5c..2359034 100644
--- a/radio/aidl/compat/libradiocompat/network/RadioNetwork.cpp
+++ b/radio/aidl/compat/libradiocompat/network/RadioNetwork.cpp
@@ -403,7 +403,7 @@
}
ScopedAStatus RadioNetwork::setSatellitePlmn(
- int32_t serial, int32_t /*simSlot*/, const std::vector<std::string>& /*carrierPlmnArray*/,
+ int32_t serial, const std::vector<std::string>& /*carrierPlmnArray*/,
const std::vector<std::string>& /*allSatellitePlmnArray*/) {
LOG_CALL << serial;
LOG(ERROR) << " setSatellitePlmn is unsupported by HIDL HALs";
@@ -411,15 +411,14 @@
return ok();
}
-ScopedAStatus RadioNetwork::setSatelliteEnabledForCarrier(int32_t serial, int32_t /*simSlot*/,
- bool /*enable*/) {
+ScopedAStatus RadioNetwork::setSatelliteEnabledForCarrier(int32_t serial, bool /*enable*/) {
LOG_CALL << serial;
LOG(ERROR) << " setSatelliteEnabledForCarrier is unsupported by HIDL HALs";
respond()->setSatelliteEnabledForCarrierResponse(notSupported(serial));
return ok();
}
-ScopedAStatus RadioNetwork::isSatelliteEnabledForCarrier(int32_t serial, int32_t /*simSlot*/) {
+ScopedAStatus RadioNetwork::isSatelliteEnabledForCarrier(int32_t serial) {
LOG_CALL << serial;
LOG(ERROR) << " isSatelliteEnabledForCarrier is unsupported by HIDL HALs";
respond()->isSatelliteEnabledForCarrierResponse(notSupported(serial), false);
diff --git a/radio/aidl/vts/radio_network_test.cpp b/radio/aidl/vts/radio_network_test.cpp
index 1778c3f..6b0b33a 100644
--- a/radio/aidl/vts/radio_network_test.cpp
+++ b/radio/aidl/vts/radio_network_test.cpp
@@ -2629,7 +2629,7 @@
}
serial = GetRandomSerialNumber();
- radio_network->setSatellitePlmn(serial, 0, {"123456"}, {"123456, 3456789"});
+ radio_network->setSatellitePlmn(serial, {"123456"}, {"123456, 3456789"});
EXPECT_EQ(std::cv_status::no_timeout, wait());
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
@@ -2654,7 +2654,7 @@
// Get current value
serial = GetRandomSerialNumber();
- radio_network->isSatelliteEnabledForCarrier(serial, 0);
+ radio_network->isSatelliteEnabledForCarrier(serial);
EXPECT_EQ(std::cv_status::no_timeout, wait());
bool originalSatelliteEnabledSetting = radioRsp_network->isSatelliteEnabledForCarrier;
@@ -2663,7 +2663,7 @@
// for the right default value.
bool valueToSet = !originalSatelliteEnabledSetting;
serial = GetRandomSerialNumber();
- radio_network->setSatelliteEnabledForCarrier(serial, 0, valueToSet);
+ radio_network->setSatelliteEnabledForCarrier(serial, valueToSet);
EXPECT_EQ(std::cv_status::no_timeout, wait());
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
@@ -2675,7 +2675,7 @@
if (radioRsp_network->rspInfo.error == RadioError::NONE) {
// Assert the value has changed
serial = GetRandomSerialNumber();
- ndk::ScopedAStatus res = radio_network->isSatelliteEnabledForCarrier(serial, 0);
+ ndk::ScopedAStatus res = radio_network->isSatelliteEnabledForCarrier(serial);
ASSERT_OK(res);
EXPECT_EQ(std::cv_status::no_timeout, wait());
@@ -2687,7 +2687,7 @@
EXPECT_EQ(valueToSet, radioRsp_network->isSatelliteEnabledForCarrier);
// Reset original state
- radio_network->setSatelliteEnabledForCarrier(serial, 0, originalSatelliteEnabledSetting);
+ radio_network->setSatelliteEnabledForCarrier(serial, originalSatelliteEnabledSetting);
EXPECT_EQ(std::cv_status::no_timeout, wait());
EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
diff --git a/security/keymint/aidl/android/hardware/security/keymint/Tag.aidl b/security/keymint/aidl/android/hardware/security/keymint/Tag.aidl
index e56c193..7ea5f5d 100644
--- a/security/keymint/aidl/android/hardware/security/keymint/Tag.aidl
+++ b/security/keymint/aidl/android/hardware/security/keymint/Tag.aidl
@@ -904,6 +904,9 @@
* Tag::MODULE_HASH specifies the SHA-256 hash of the DER-encoded module information (see
* KeyCreationResult.aidl for the ASN.1 schema).
*
+ * KeyStore clients can retrieve the unhashed DER-encoded module information from Android
+ * via KeyStoreManager.getSupplementaryAttestationInfo.
+ *
* This tag is never provided or returned from KeyMint in the key characteristics. It exists
* only to define the tag for use in the attestation record.
*
diff --git a/security/keymint/aidl/default/hal/lib.rs b/security/keymint/aidl/default/hal/lib.rs
index 359890d..fad807f 100644
--- a/security/keymint/aidl/default/hal/lib.rs
+++ b/security/keymint/aidl/default/hal/lib.rs
@@ -20,39 +20,22 @@
use kmr_hal::env::get_property;
use log::error;
-/// Retrieve the most significant attestation property for `name`.
-fn attestation_property(name: &str) -> Vec<u8> {
- let prop_val =
- get_property(&format!("ro.product.{}_for_attestation", name)).unwrap_or_default();
- if !prop_val.is_empty() {
- prop_val
- } else {
- let prop_val = get_property(&format!("ro.product.vendor.{}", name)).unwrap_or_default();
- if !prop_val.is_empty() {
- prop_val
- } else {
- get_property(&format!("ro.product.{}", name))
- .unwrap_or_else(|prop_name| format!("{} unavailable", prop_name))
- }
- }
- .as_bytes()
- .to_vec()
-}
-
/// Populate attestation ID information based on properties (where available).
/// Retrieving the serial number requires SELinux permission.
pub fn attestation_id_info() -> kmr_wire::AttestationIdInfo {
-
- kmr_wire::AttestationIdInfo {
- brand: attestation_property("brand"),
- device: attestation_property("device"),
- product: attestation_property("name"),
- serial: get_property("ro.serialno")
- .unwrap_or_else(|_| format!("ro.serialno unavailable"))
+ let prop = |name| {
+ get_property(name)
+ .unwrap_or_else(|_| format!("{} unavailable", name))
.as_bytes()
- .to_vec(),
- manufacturer: attestation_property("manufacturer"),
- model: attestation_property("model"),
+ .to_vec()
+ };
+ kmr_wire::AttestationIdInfo {
+ brand: prop("ro.product.brand"),
+ device: prop("ro.product.device"),
+ product: prop("ro.product.name"),
+ serial: prop("ro.serialno"),
+ manufacturer: prop("ro.product.manufacturer"),
+ model: prop("ro.product.model"),
// Currently modem_simulator always returns one fixed value. See `handleGetIMEI` in
// device/google/cuttlefish/host/commands/modem_simulator/misc_service.cpp for more details.
// TODO(b/263188546): Use device-specific IMEI values when available.
diff --git a/tv/tuner/aidl/vts/functional/VtsHalTvTunerTargetTest.cpp b/tv/tuner/aidl/vts/functional/VtsHalTvTunerTargetTest.cpp
index 158e4f1..59d9593 100644
--- a/tv/tuner/aidl/vts/functional/VtsHalTvTunerTargetTest.cpp
+++ b/tv/tuner/aidl/vts/functional/VtsHalTvTunerTargetTest.cpp
@@ -214,9 +214,7 @@
ASSERT_TRUE(mFilterTests.startFilter(filterId));
// tune test
ASSERT_TRUE(mFrontendTests.tuneFrontend(frontendConf, true /*testWithDemux*/));
- if (!isPassthroughFilter(filterConf)) {
- ASSERT_TRUE(filterDataOutputTest());
- }
+ ASSERT_TRUE(filterDataOutputTest());
ASSERT_TRUE(mFrontendTests.stopTuneFrontend(true /*testWithDemux*/));
ASSERT_TRUE(mFilterTests.stopFilter(filterId));
ASSERT_TRUE(mFilterTests.releaseShareAvHandle(filterId));
@@ -1383,6 +1381,10 @@
auto live_configs = generateLiveConfigurations();
for (auto& configuration : live_configs) {
live = configuration;
+ // shared memory handle is not used by a passthrough filter at all
+ if (isPassthroughFilter(filterMap[live.videoFilterId])) {
+ continue;
+ }
mediaFilterUsingSharedMemoryTest(filterMap[live.videoFilterId],
frontendMap[live.frontendId]);
}
diff --git a/virtualization/OWNERS b/virtualization/OWNERS
new file mode 100644
index 0000000..316145b
--- /dev/null
+++ b/virtualization/OWNERS
@@ -0,0 +1 @@
+include platform/packages/modules/Virtualization:/OWNERS
diff --git a/wifi/supplicant/aidl/vts/functional/supplicant_p2p_iface_aidl_test.cpp b/wifi/supplicant/aidl/vts/functional/supplicant_p2p_iface_aidl_test.cpp
index 778e20a..3522014 100644
--- a/wifi/supplicant/aidl/vts/functional/supplicant_p2p_iface_aidl_test.cpp
+++ b/wifi/supplicant/aidl/vts/functional/supplicant_p2p_iface_aidl_test.cpp
@@ -986,15 +986,16 @@
* Test the P2P network management functions.
*/
TEST_P(SupplicantP2pIfaceAidlTest, ManageNetworks) {
- std::shared_ptr<ISupplicantP2pNetwork> network;
- EXPECT_TRUE(p2p_iface_->addNetwork(&network).isOk());
- ASSERT_NE(network, nullptr);
+ // Create a persistent group to bring up a network
+ EXPECT_TRUE(p2p_iface_->addGroup(true /* persistent */, -1).isOk());
+ sleep(2);
std::vector<int32_t> networkList;
EXPECT_TRUE(p2p_iface_->listNetworks(&networkList).isOk());
ASSERT_FALSE(networkList.empty());
int networkId = networkList[0];
+ std::shared_ptr<ISupplicantP2pNetwork> network;
EXPECT_TRUE(p2p_iface_->getNetwork(networkId, &network).isOk());
ASSERT_NE(network, nullptr);
EXPECT_TRUE(p2p_iface_->removeNetwork(networkId).isOk());
diff --git a/wifi/supplicant/aidl/vts/functional/supplicant_p2p_network_aidl_test.cpp b/wifi/supplicant/aidl/vts/functional/supplicant_p2p_network_aidl_test.cpp
index c5a73f1..165a01a 100644
--- a/wifi/supplicant/aidl/vts/functional/supplicant_p2p_network_aidl_test.cpp
+++ b/wifi/supplicant/aidl/vts/functional/supplicant_p2p_network_aidl_test.cpp
@@ -48,11 +48,22 @@
EXPECT_TRUE(supplicant_->getP2pInterface(getP2pIfaceName(), &p2p_iface_).isOk());
ASSERT_NE(p2p_iface_, nullptr);
- EXPECT_TRUE(p2p_iface_->addNetwork(&p2p_network_).isOk());
+
+ // Create a persistent group to bring up a network
+ EXPECT_TRUE(p2p_iface_->addGroup(true /* persistent */, -1).isOk());
+ sleep(2);
+
+ std::vector<int32_t> networkList;
+ EXPECT_TRUE(p2p_iface_->listNetworks(&networkList).isOk());
+ ASSERT_FALSE(networkList.empty());
+
+ network_id_ = networkList[0];
+ EXPECT_TRUE(p2p_iface_->getNetwork(network_id_, &p2p_network_).isOk());
ASSERT_NE(p2p_network_, nullptr);
}
void TearDown() override {
+ EXPECT_TRUE(p2p_iface_->removeNetwork(network_id_).isOk());
stopSupplicantService();
startWifiFramework();
}
@@ -61,6 +72,7 @@
std::shared_ptr<ISupplicant> supplicant_;
std::shared_ptr<ISupplicantP2pIface> p2p_iface_;
std::shared_ptr<ISupplicantP2pNetwork> p2p_network_;
+ int network_id_;
};
/*
@@ -130,7 +142,8 @@
TEST_P(SupplicantP2pNetworkAidlTest, IsGroupOwner) {
bool isGroupOwner;
EXPECT_TRUE(p2p_network_->isGroupOwner(&isGroupOwner).isOk());
- EXPECT_FALSE(isGroupOwner);
+ // Configured network is a group owner
+ EXPECT_TRUE(isGroupOwner);
}
/*
@@ -139,7 +152,8 @@
TEST_P(SupplicantP2pNetworkAidlTest, IsPersistent) {
bool isPersistent;
EXPECT_TRUE(p2p_network_->isPersistent(&isPersistent).isOk());
- EXPECT_FALSE(isPersistent);
+ // Configured network is persistent
+ EXPECT_TRUE(isPersistent);
}
/*
diff --git a/wifi/supplicant/aidl/vts/functional/supplicant_sta_network_aidl_test.cpp b/wifi/supplicant/aidl/vts/functional/supplicant_sta_network_aidl_test.cpp
index 5e6069f..2f0053a 100644
--- a/wifi/supplicant/aidl/vts/functional/supplicant_sta_network_aidl_test.cpp
+++ b/wifi/supplicant/aidl/vts/functional/supplicant_sta_network_aidl_test.cpp
@@ -862,6 +862,20 @@
EXPECT_TRUE(sta_network_->setVendorData(kTestVendorData).isOk());
}
+/*
+ * Set/Get EDMG
+ */
+TEST_P(SupplicantStaNetworkAidlTest, SetGetEdmg) {
+ bool retrievedValue = false;
+ EXPECT_TRUE(sta_network_->setEdmg(true).isOk());
+ EXPECT_TRUE(sta_network_->getEdmg(&retrievedValue).isOk());
+ EXPECT_EQ(retrievedValue, true);
+
+ EXPECT_TRUE(sta_network_->setEdmg(false).isOk());
+ EXPECT_TRUE(sta_network_->getEdmg(&retrievedValue).isOk());
+ EXPECT_EQ(retrievedValue, false);
+}
+
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SupplicantStaNetworkAidlTest);
INSTANTIATE_TEST_SUITE_P(Supplicant, SupplicantStaNetworkAidlTest,
testing::ValuesIn(android::getAidlHalInstanceNames(