Merge "Fix driving state for manual transmission." into pi-dev
diff --git a/service/src/com/android/car/CarDrivingStateService.java b/service/src/com/android/car/CarDrivingStateService.java
index 7f0eeea..bc0fbc1 100644
--- a/service/src/com/android/car/CarDrivingStateService.java
+++ b/service/src/com/android/car/CarDrivingStateService.java
@@ -17,6 +17,7 @@
package com.android.car;
import android.annotation.Nullable;
+import android.car.VehicleAreaType;
import android.car.drivingstate.CarDrivingStateEvent;
import android.car.drivingstate.CarDrivingStateEvent.CarDrivingState;
import android.car.drivingstate.ICarDrivingState;
@@ -53,10 +54,11 @@
// List of clients listening to driving state events.
private final List<DrivingStateClient> mDrivingStateClients = new ArrayList<>();
// Array of properties that the service needs to listen to from CarPropertyService for deriving
- // the driving state. ToDo (ramperry@) - fine tune this list - b/69859926
+ // the driving state.
private static final int[] REQUIRED_PROPERTIES = {
VehicleProperty.PERF_VEHICLE_SPEED,
- VehicleProperty.GEAR_SELECTION};
+ VehicleProperty.GEAR_SELECTION,
+ VehicleProperty.PARKING_BRAKE_ON};
private CarDrivingStateEvent mCurrentDrivingState;
// For dumpsys logging
private final LinkedList<Utils.TransitionLog> mTransitionLogs = new LinkedList<>();
@@ -64,6 +66,9 @@
private long mLastGearTimestamp = NOT_RECEIVED;
private float mLastSpeed;
private long mLastSpeedTimestamp = NOT_RECEIVED;
+ private boolean mLastParkingBrakeState;
+ private long mLastParkingBrakeTimestamp = NOT_RECEIVED;
+ private List<Integer> mSupportedGears;
public CarDrivingStateService(Context context, CarPropertyService propertyService) {
mContext = context;
@@ -72,12 +77,15 @@
}
@Override
- public void init() {
+ public synchronized void init() {
if (!checkPropertySupport()) {
Log.e(TAG, "init failure. Driving state will always be fully restrictive");
return;
}
subscribeToProperties();
+ mCurrentDrivingState = createDrivingStateEvent(inferDrivingStateLocked());
+ addTransitionLog(TAG + " Boot", CarDrivingStateEvent.DRIVING_STATE_UNKNOWN,
+ mCurrentDrivingState.eventValue, mCurrentDrivingState.timeStamp);
}
@Override
@@ -269,11 +277,17 @@
@Override
public void dump(PrintWriter writer) {
- writer.println("Driving state chane log:");
+ writer.println("Driving state change log:");
for (Utils.TransitionLog tLog : mTransitionLogs) {
writer.println(tLog);
}
writer.println("Current Driving State: " + mCurrentDrivingState.eventValue);
+ if (mSupportedGears != null) {
+ writer.println("Supported gears:");
+ for (Integer gear : mSupportedGears) {
+ writer.print("Gear:" + gear);
+ }
+ }
}
/**
@@ -315,6 +329,9 @@
}
break;
case VehicleProperty.GEAR_SELECTION:
+ if (mSupportedGears == null) {
+ mSupportedGears = getSupportedGears();
+ }
int curGear = (Integer) value.getValue();
if (DBG) {
Log.d(TAG, "Gear: " + curGear + "@" + curTimestamp);
@@ -326,6 +343,19 @@
Log.d(TAG, "Ignoring Gear with older timestamp:" + curTimestamp);
}
break;
+ case VehicleProperty.PARKING_BRAKE_ON:
+ boolean curParkingBrake = (boolean) value.getValue();
+ if (DBG) {
+ Log.d(TAG, "Parking Brake: " + curParkingBrake + "@" + curTimestamp);
+ }
+ if (curTimestamp > mLastParkingBrakeTimestamp) {
+ mLastParkingBrakeTimestamp = curTimestamp;
+ mLastParkingBrakeState = curParkingBrake;
+ } else if (DBG) {
+ Log.d(TAG, "Ignoring Parking Brake status with an older timestamp:"
+ + curTimestamp);
+ }
+ break;
default:
Log.e(TAG, "Received property event for unhandled propId=" + propId);
break;
@@ -357,6 +387,16 @@
}
}
+ private List<Integer> getSupportedGears() {
+ List<CarPropertyConfig> properyList = mPropertyService.getPropertyList();
+ for (CarPropertyConfig p : properyList) {
+ if (p.getPropertyId() == VehicleProperty.GEAR_SELECTION) {
+ return p.getConfigArray();
+ }
+ }
+ return null;
+ }
+
private void addTransitionLog(String name, int from, int to, long timestamp) {
if (mTransitionLogs.size() >= MAX_TRANSITION_LOG_SIZE) {
mTransitionLogs.remove();
@@ -369,31 +409,35 @@
/**
* Infers the current driving state of the car from the other Car Sensor properties like
* Current Gear, Speed etc.
- * ToDo (ramperry@) - Fine tune this - b/69859926
*
* @return Current driving state
*/
@CarDrivingState
private int inferDrivingStateLocked() {
- /*
- Simple logic to start off deriving driving state:
- 1. If gear == parked, then Driving State is parked.
- 2. If gear != parked,
- 2a. if speed == 0, then driving state is idling
- 2b. if speed != 0, then driving state is moving
- 2c. if speed unavailable, then driving state is unknown
- This logic needs to be tested and iterated on. Tracked in b/69859926
- */
+ updateVehiclePropertiesIfNeeded();
if (DBG) {
Log.d(TAG, "Last known Gear:" + mLastGear + " Last known speed:" + mLastSpeed);
}
- if (mLastGearTimestamp == NOT_RECEIVED) {
- return CarDrivingStateEvent.DRIVING_STATE_UNKNOWN;
- } else if (mLastGear == VehicleGear.GEAR_PARK) {
+
+ /*
+ Logic to start off deriving driving state:
+ 1. If gear == parked, then Driving State is parked.
+ 2. If gear != parked,
+ 2a. if parking brake is applied, then Driving state is parked.
+ 2b. if parking brake is not applied or unknown/unavailable, then driving state
+ is still unknown.
+ 3. If driving state is unknown at the end of step 2,
+ 3a. if speed == 0, then driving state is idling
+ 3b. if speed != 0, then driving state is moving
+ 3c. if speed unavailable, then driving state is unknown
+ */
+
+ if (isVehicleKnownToBeParked()) {
return CarDrivingStateEvent.DRIVING_STATE_PARKED;
}
- if (mLastSpeedTimestamp == NOT_RECEIVED) {
+ // We don't know if the vehicle is parked, let's look at the speed.
+ if (mLastSpeedTimestamp == NOT_RECEIVED || mLastSpeed < 0) {
return CarDrivingStateEvent.DRIVING_STATE_UNKNOWN;
} else if (mLastSpeed == 0f) {
return CarDrivingStateEvent.DRIVING_STATE_IDLING;
@@ -402,6 +446,89 @@
}
}
+ /**
+ * Find if we have signals to know if the vehicle is parked
+ *
+ * @return true if we have enough information to say the vehicle is parked.
+ * false, if the vehicle is either not parked or if we don't have any information.
+ */
+ private boolean isVehicleKnownToBeParked() {
+ // If we know the gear is in park, return true
+ if (mLastGearTimestamp != NOT_RECEIVED && mLastGear == VehicleGear.GEAR_PARK) {
+ return true;
+ } else if (mLastParkingBrakeTimestamp != NOT_RECEIVED) {
+ // if gear is not in park or unknown, look for status of parking brake if transmission
+ // type is manual.
+ if (isCarManualTransmissionType()) {
+ return mLastParkingBrakeState;
+ }
+ }
+ // if neither information is available, return false to indicate we can't determine
+ // if the vehicle is parked.
+ return false;
+ }
+
+ /**
+ * If Supported gears information is available and GEAR_PARK is not one of the supported gears,
+ * transmission type is considered to be Manual. Automatic transmission is assumed otherwise.
+ */
+ private boolean isCarManualTransmissionType() {
+ if (mSupportedGears != null
+ && !mSupportedGears.isEmpty()
+ && !mSupportedGears.contains(VehicleGear.GEAR_PARK)) {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Try querying the gear selection and parking brake if we haven't received the event yet.
+ * This could happen if the gear change occurred before car service booted up like in the
+ * case of a HU restart in the middle of a drive. Since gear and parking brake are
+ * on-change only properties, we could be in this situation where we will have to query
+ * VHAL.
+ */
+ private void updateVehiclePropertiesIfNeeded() {
+ if (mLastGearTimestamp == NOT_RECEIVED) {
+ CarPropertyValue propertyValue = mPropertyService.getProperty(
+ VehicleProperty.GEAR_SELECTION,
+ VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL);
+ if (propertyValue != null) {
+ mLastGear = (Integer) propertyValue.getValue();
+ mLastGearTimestamp = propertyValue.getTimestamp();
+ if (DBG) {
+ Log.d(TAG, "updateVehiclePropertiesIfNeeded: gear:" + mLastGear);
+ }
+ }
+ }
+
+ if (mLastParkingBrakeTimestamp == NOT_RECEIVED) {
+ CarPropertyValue propertyValue = mPropertyService.getProperty(
+ VehicleProperty.PARKING_BRAKE_ON,
+ VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL);
+ if (propertyValue != null) {
+ mLastParkingBrakeState = (boolean) propertyValue.getValue();
+ mLastParkingBrakeTimestamp = propertyValue.getTimestamp();
+ if (DBG) {
+ Log.d(TAG, "updateVehiclePropertiesIfNeeded: brake:" + mLastParkingBrakeState);
+ }
+ }
+ }
+
+ if (mLastSpeedTimestamp == NOT_RECEIVED) {
+ CarPropertyValue propertyValue = mPropertyService.getProperty(
+ VehicleProperty.PERF_VEHICLE_SPEED,
+ VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL);
+ if (propertyValue != null) {
+ mLastSpeed = (float) propertyValue.getValue();
+ mLastSpeedTimestamp = propertyValue.getTimestamp();
+ if (DBG) {
+ Log.d(TAG, "updateVehiclePropertiesIfNeeded: speed:" + mLastSpeed);
+ }
+ }
+ }
+ }
+
private static CarDrivingStateEvent createDrivingStateEvent(int eventValue) {
return new CarDrivingStateEvent(eventValue, SystemClock.elapsedRealtimeNanos());
}
diff --git a/service/src/com/android/car/CarUxRestrictionsManagerService.java b/service/src/com/android/car/CarUxRestrictionsManagerService.java
index 449a485..23c4d32 100644
--- a/service/src/com/android/car/CarUxRestrictionsManagerService.java
+++ b/service/src/com/android/car/CarUxRestrictionsManagerService.java
@@ -50,6 +50,7 @@
private static final boolean DBG = false;
private static final int MAX_TRANSITION_LOG_SIZE = 20;
private static final int PROPERTY_UPDATE_RATE = 5; // Update rate in Hz
+ private static final float SPEED_NOT_AVAILABLE = -1.0F;
private final Context mContext;
private final CarDrivingStateService mDrivingStateService;
private final CarPropertyService mCarPropertyService;
@@ -77,7 +78,7 @@
}
@Override
- public void init() {
+ public synchronized void init() {
try {
if (!mHelper.loadUxRestrictionsFromXml()) {
Log.e(TAG, "Error reading Ux Restrictions Mapping. Falling back to defaults");
@@ -93,6 +94,38 @@
// subscribe to property service for speed
mCarPropertyService.registerListener(VehicleProperty.PERF_VEHICLE_SPEED,
PROPERTY_UPDATE_RATE, mICarPropertyEventListener);
+ initializeUxRestrictions();
+ }
+
+ // Update current restrictions by getting the current driving state and speed.
+ private void initializeUxRestrictions() {
+ CarDrivingStateEvent currentDrivingStateEvent =
+ mDrivingStateService.getCurrentDrivingState();
+ // if we don't have enough information from the CarPropertyService to compute the UX
+ // restrictions, then leave the UX restrictions unchanged from what it was initialized to
+ // in the constructor.
+ if (currentDrivingStateEvent == null || currentDrivingStateEvent.eventValue
+ == CarDrivingStateEvent.DRIVING_STATE_UNKNOWN) {
+ return;
+ }
+ int currentDrivingState = currentDrivingStateEvent.eventValue;
+ Float currentSpeed = getCurrentSpeed();
+ if (currentSpeed == SPEED_NOT_AVAILABLE) {
+ return;
+ }
+ // At this point the underlying CarPropertyService has provided us enough information to
+ // compute the UX restrictions that could be potentially different from the initial UX
+ // restrictions.
+ handleDispatchUxRestrictions(currentDrivingState, currentSpeed);
+ }
+
+ private Float getCurrentSpeed() {
+ CarPropertyValue value = mCarPropertyService.getProperty(VehicleProperty.PERF_VEHICLE_SPEED,
+ 0);
+ if (value != null) {
+ return (Float) value.getValue();
+ }
+ return SPEED_NOT_AVAILABLE;
}
@Override
@@ -156,7 +189,6 @@
return null;
}
-
/**
* Unregister the given UX Restrictions listener
*
@@ -282,10 +314,10 @@
return;
}
int drivingState = event.eventValue;
- CarPropertyValue value = mCarPropertyService.getProperty(VehicleProperty.PERF_VEHICLE_SPEED,
- 0);
- if (value != null) {
- mCurrentMovingSpeed = (Float) value.getValue();
+ Float speed = getCurrentSpeed();
+
+ if (speed != SPEED_NOT_AVAILABLE) {
+ mCurrentMovingSpeed = speed;
} else if (drivingState == CarDrivingStateEvent.DRIVING_STATE_PARKED
|| drivingState == CarDrivingStateEvent.DRIVING_STATE_UNKNOWN) {
// If speed is unavailable, but the driving state is parked or unknown, it can still be
@@ -352,7 +384,6 @@
uxRestrictions = getDefaultRestrictions(currentDrivingState);
} else {
uxRestrictions = mHelper.getUxRestrictions(currentDrivingState, speed);
-
}
if (DBG) {
diff --git a/tests/carservice_test/src/com/android/car/CarDrivingRestrictionsTest.java b/tests/carservice_test/src/com/android/car/CarDrivingRestrictionsTest.java
index 9be9b10..31ed4b2 100644
--- a/tests/carservice_test/src/com/android/car/CarDrivingRestrictionsTest.java
+++ b/tests/carservice_test/src/com/android/car/CarDrivingRestrictionsTest.java
@@ -19,6 +19,7 @@
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import android.car.Car;
@@ -82,13 +83,8 @@
mCarUxRManager.registerListener(listener);
// With no gear value available, driving state should be unknown
listener.reset();
- getMockedVehicleHal().injectEvent(
- VehiclePropValueBuilder.newBuilder(VehicleProperty.PERF_VEHICLE_SPEED)
- .addFloatValue(0.0f)
- .setTimestamp(SystemClock.elapsedRealtimeNanos())
- .build());
-
// Test Parked state and corresponding restrictions based on car_ux_restrictions_map.xml
+ Log.d(TAG, "Injecting gear park");
getMockedVehicleHal().injectEvent(
VehiclePropValueBuilder.newBuilder(VehicleProperty.GEAR_SELECTION)
.addIntValue(VehicleGear.GEAR_PARK)
@@ -98,9 +94,17 @@
assertNotNull(drivingEvent);
assertThat(drivingEvent.eventValue).isEqualTo(CarDrivingStateEvent.DRIVING_STATE_PARKED);
+ Log.d(TAG, "Injecting speed 0");
+ getMockedVehicleHal().injectEvent(
+ VehiclePropValueBuilder.newBuilder(VehicleProperty.PERF_VEHICLE_SPEED)
+ .addFloatValue(0.0f)
+ .setTimestamp(SystemClock.elapsedRealtimeNanos())
+ .build());
+
// Switch gear to drive. Driving state changes to Idling but the UX restrictions don't
// change between parked and idling.
listener.reset();
+ Log.d(TAG, "Injecting gear drive");
getMockedVehicleHal().injectEvent(
VehiclePropValueBuilder.newBuilder(VehicleProperty.GEAR_SELECTION)
.addIntValue(VehicleGear.GEAR_DRIVE)
@@ -112,6 +116,7 @@
// Test Moving state and corresponding restrictions based on car_ux_restrictions_map.xml
listener.reset();
+ Log.d(TAG, "Injecting speed 30");
getMockedVehicleHal().injectEvent(
VehiclePropValueBuilder.newBuilder(VehicleProperty.PERF_VEHICLE_SPEED)
.addFloatValue(30.0f)
@@ -128,6 +133,7 @@
// Test Idling state and corresponding restrictions based on car_ux_restrictions_map.xml
listener.reset();
+ Log.d(TAG, "Injecting speed 0");
getMockedVehicleHal().injectEvent(
VehiclePropValueBuilder.newBuilder(VehicleProperty.PERF_VEHICLE_SPEED)
.addFloatValue(0.0f)
@@ -142,6 +148,83 @@
assertThat(restrictions.getActiveRestrictions())
.isEqualTo(CarUxRestrictions.UX_RESTRICTIONS_BASELINE);
+ // Apply Parking brake. Supported gears is not provided in this test and hence
+ // Automatic transmission should be assumed and hence parking brake state should not
+ // make a difference to the driving state.
+ listener.reset();
+ Log.d(TAG, "Injecting parking brake on");
+ getMockedVehicleHal().injectEvent(
+ VehiclePropValueBuilder.newBuilder(VehicleProperty.PARKING_BRAKE_ON)
+ .setBooleanValue(true)
+ .setTimestamp(SystemClock.elapsedRealtimeNanos())
+ .build());
+ drivingEvent = listener.waitForDrivingStateChange();
+ assertNull(drivingEvent);
+
+ mCarDrivingStateManager.unregisterListener();
+ mCarUxRManager.unregisterListener();
+ }
+
+ @Test
+ public void testDrivingStateChangeForMalformedInputs()
+ throws CarNotConnectedException, InterruptedException {
+ CarDrivingStateEvent drivingEvent;
+ CarUxRestrictions restrictions;
+ DrivingStateListener listener = new DrivingStateListener();
+ mCarDrivingStateManager.registerListener(listener);
+ mCarUxRManager.registerListener(listener);
+
+ // Start with gear = park and speed = 0 to begin with a known state.
+ listener.reset();
+ Log.d(TAG, "Injecting gear park");
+ getMockedVehicleHal().injectEvent(
+ VehiclePropValueBuilder.newBuilder(VehicleProperty.GEAR_SELECTION)
+ .addIntValue(VehicleGear.GEAR_PARK)
+ .setTimestamp(SystemClock.elapsedRealtimeNanos())
+ .build());
+ drivingEvent = listener.waitForDrivingStateChange();
+ assertNotNull(drivingEvent);
+ assertThat(drivingEvent.eventValue).isEqualTo(CarDrivingStateEvent.DRIVING_STATE_PARKED);
+
+ Log.d(TAG, "Injecting speed 0");
+ getMockedVehicleHal().injectEvent(
+ VehiclePropValueBuilder.newBuilder(VehicleProperty.PERF_VEHICLE_SPEED)
+ .addFloatValue(0.0f)
+ .setTimestamp(SystemClock.elapsedRealtimeNanos())
+ .build());
+
+ // Inject an invalid gear. Since speed is still valid, idling will be the expected
+ // driving state
+ listener.reset();
+ Log.d(TAG, "Injecting gear -1");
+ getMockedVehicleHal().injectEvent(
+ VehiclePropValueBuilder.newBuilder(VehicleProperty.GEAR_SELECTION)
+ .addIntValue(-1)
+ .setTimestamp(SystemClock.elapsedRealtimeNanos())
+ .build());
+ drivingEvent = listener.waitForDrivingStateChange();
+ assertNotNull(drivingEvent);
+ assertThat(drivingEvent.eventValue).isEqualTo(CarDrivingStateEvent.DRIVING_STATE_IDLING);
+
+ // Now, send in an invalid speed value as well, now the driving state will be unknown and
+ // the UX restrictions will change to fully restricted.
+ listener.reset();
+ Log.d(TAG, "Injecting speed -1");
+ getMockedVehicleHal().injectEvent(
+ VehiclePropValueBuilder.newBuilder(VehicleProperty.PERF_VEHICLE_SPEED)
+ .addFloatValue(-1.0f)
+ .setTimestamp(SystemClock.elapsedRealtimeNanos())
+ .build());
+ drivingEvent = listener.waitForDrivingStateChange();
+ assertNotNull(drivingEvent);
+ assertThat(drivingEvent.eventValue).isEqualTo(CarDrivingStateEvent.DRIVING_STATE_UNKNOWN);
+ restrictions = listener.waitForUxRestrictionsChange();
+ assertNotNull(restrictions);
+ assertTrue(restrictions.isRequiresDistractionOptimization());
+ assertThat(restrictions.getActiveRestrictions())
+ .isEqualTo(CarUxRestrictions.UX_RESTRICTIONS_FULLY_RESTRICTED);
+ mCarDrivingStateManager.unregisterListener();
+ mCarUxRManager.unregisterListener();
}
/**
