Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Exit doze during an emergency call." into udc-dev

Browse Source
This commit is contained in:
Kweku Adams
2023-03-03 19:15:36 +00:00
committed by Android (Google) Code Review
parent c55dbe72cb 27ed45f3a6
commit cfd25ee586
2 changed files with 232 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
apex/jobscheduler/service/java/com/android/server/DeviceIdleController.java
View File

@@ -79,6 +79,9 @@ import android.os.SystemClock;
import android.os.Trace;
import android.os.UserHandle;
import android.provider.DeviceConfig;
import android.telephony.TelephonyCallback;
import android.telephony.TelephonyManager;
import android.telephony.emergency.EmergencyNumber;
import android.util.ArrayMap;
import android.util.ArraySet;
import android.util.AtomicFile;
@@ -146,15 +149,17 @@ import java.util.stream.Collectors;
label="deep";
STATE_ACTIVE [
label="STATE_ACTIVE\nScreen on OR Charging OR Alarm going off soon",
label="STATE_ACTIVE\nScreen on OR charging OR alarm going off soon\n"
+ "OR active emergency call",
color=black,shape=diamond
]
STATE_INACTIVE [
label="STATE_INACTIVE\nScreen off AND Not charging",color=black,shape=diamond
label="STATE_INACTIVE\nScreen off AND not charging AND no active emergency call",
color=black,shape=diamond
]
STATE_QUICK_DOZE_DELAY [
label="STATE_QUICK_DOZE_DELAY\n"
+ "Screen off AND Not charging\n"
+ "Screen off AND not charging AND no active emergency call\n"
+ "Location, motion detection, and significant motion monitoring turned off",
color=black,shape=diamond
]
@@ -237,11 +242,12 @@ import java.util.stream.Collectors;
label="light"
LIGHT_STATE_ACTIVE [
label="LIGHT_STATE_ACTIVE\nScreen on OR Charging OR Alarm going off soon",
label="LIGHT_STATE_ACTIVE\n"
+ "Screen on OR charging OR alarm going off soon OR active emergency call",
color=black,shape=diamond
]
LIGHT_STATE_INACTIVE [
label="LIGHT_STATE_INACTIVE\nScreen off AND Not charging",
label="LIGHT_STATE_INACTIVE\nScreen off AND not charging AND no active emergency call",
color=black,shape=diamond
]
LIGHT_STATE_IDLE [label="LIGHT_STATE_IDLE\n",color=red,shape=box]
@@ -411,6 +417,7 @@ public class DeviceIdleController extends SystemService
private static final int ACTIVE_REASON_FROM_BINDER_CALL = 5;
private static final int ACTIVE_REASON_FORCED = 6;
private static final int ACTIVE_REASON_ALARM = 7;
private static final int ACTIVE_REASON_EMERGENCY_CALL = 8;
@VisibleForTesting
static final int SET_IDLE_FACTOR_RESULT_UNINIT = -1;
@VisibleForTesting
@@ -765,6 +772,8 @@ public class DeviceIdleController extends SystemService
}
};
private final EmergencyCallListener mEmergencyCallListener = new EmergencyCallListener();
/** Post stationary status only to this listener. */
private void postStationaryStatus(DeviceIdleInternal.StationaryListener listener) {
mHandler.obtainMessage(MSG_REPORT_STATIONARY_STATUS, listener).sendToTarget();
@@ -2323,6 +2332,39 @@ public class DeviceIdleController extends SystemService
}
}
private class EmergencyCallListener extends TelephonyCallback implements
TelephonyCallback.OutgoingEmergencyCallListener,
TelephonyCallback.CallStateListener {
private volatile boolean mIsEmergencyCallActive;
@Override
public void onOutgoingEmergencyCall(EmergencyNumber placedEmergencyNumber,
int subscriptionId) {
mIsEmergencyCallActive = true;
if (DEBUG) Slog.d(TAG, "onOutgoingEmergencyCall(): subId = " + subscriptionId);
synchronized (DeviceIdleController.this) {
mActiveReason = ACTIVE_REASON_EMERGENCY_CALL;
becomeActiveLocked("emergency call", Process.myUid());
}
}
@Override
public void onCallStateChanged(int state) {
if (DEBUG) Slog.d(TAG, "onCallStateChanged(): state is " + state);
// An emergency call just finished
if (state == TelephonyManager.CALL_STATE_IDLE && mIsEmergencyCallActive) {
mIsEmergencyCallActive = false;
synchronized (DeviceIdleController.this) {
becomeInactiveIfAppropriateLocked();
}
}
}
boolean isEmergencyCallActive() {
return mIsEmergencyCallActive;
}
}
static class Injector {
private final Context mContext;
private ConnectivityManager mConnectivityManager;
@@ -2406,6 +2448,10 @@ public class DeviceIdleController extends SystemService
return mContext.getSystemService(SensorManager.class);
}
TelephonyManager getTelephonyManager() {
return mContext.getSystemService(TelephonyManager.class);
}
ConstraintController getConstraintController(Handler handler,
DeviceIdleInternal localService) {
if (mContext.getPackageManager()
@@ -2634,6 +2680,9 @@ public class DeviceIdleController extends SystemService
mLocalActivityTaskManager.registerScreenObserver(mScreenObserver);
mInjector.getTelephonyManager().registerTelephonyCallback(
JobSchedulerBackgroundThread.getExecutor(), mEmergencyCallListener);
passWhiteListsToForceAppStandbyTrackerLocked();
updateInteractivityLocked();
}
@@ -3435,6 +3484,7 @@ public class DeviceIdleController extends SystemService
final boolean isScreenBlockingInactive =
mScreenOn && (!mConstants.WAIT_FOR_UNLOCK || !mScreenLocked);
final boolean isEmergencyCallActive = mEmergencyCallListener.isEmergencyCallActive();
if (DEBUG) {
Slog.d(TAG, "becomeInactiveIfAppropriateLocked():"
+ " isScreenBlockingInactive=" + isScreenBlockingInactive
@@ -3442,10 +3492,11 @@ public class DeviceIdleController extends SystemService
+ ", WAIT_FOR_UNLOCK=" + mConstants.WAIT_FOR_UNLOCK
+ ", mScreenLocked=" + mScreenLocked + ")"
+ " mCharging=" + mCharging
+ " emergencyCall=" + isEmergencyCallActive
+ " mForceIdle=" + mForceIdle
);
}
if (!mForceIdle && (mCharging || isScreenBlockingInactive)) {
if (!mForceIdle && (mCharging || isScreenBlockingInactive || isEmergencyCallActive)) {
return;
}
// Become inactive and determine if we will ultimately go idle.
@@ -3568,6 +3619,17 @@ public class DeviceIdleController extends SystemService
}
EventLogTags.writeDeviceIdleLightStep();
if (mEmergencyCallListener.isEmergencyCallActive()) {
// The emergency call should have raised the state to ACTIVE and kept it there,
// so this method shouldn't be called. Don't proceed further.
Slog.wtf(TAG, "stepLightIdleStateLocked called when emergency call is active");
if (mLightState != LIGHT_STATE_ACTIVE) {
mActiveReason = ACTIVE_REASON_EMERGENCY_CALL;
becomeActiveLocked("emergency", Process.myUid());
}
return;
}
switch (mLightState) {
case LIGHT_STATE_INACTIVE:
mCurLightIdleBudget = mConstants.LIGHT_IDLE_MAINTENANCE_MIN_BUDGET;
@@ -3650,6 +3712,17 @@ public class DeviceIdleController extends SystemService
if (DEBUG) Slog.d(TAG, "stepIdleStateLocked: mState=" + mState);
EventLogTags.writeDeviceIdleStep();
if (mEmergencyCallListener.isEmergencyCallActive()) {
// The emergency call should have raised the state to ACTIVE and kept it there,
// so this method shouldn't be called. Don't proceed further.
Slog.wtf(TAG, "stepIdleStateLocked called when emergency call is active");
if (mState != STATE_ACTIVE) {
mActiveReason = ACTIVE_REASON_EMERGENCY_CALL;
becomeActiveLocked("emergency", Process.myUid());
}
return;
}
if (isUpcomingAlarmClock()) {
// Whoops, there is an upcoming alarm. We don't actually want to go idle.
if (mState != STATE_ACTIVE) {
@@ -3984,6 +4057,11 @@ public class DeviceIdleController extends SystemService
}
}
@VisibleForTesting
boolean isEmergencyCallActive() {
return mEmergencyCallListener.isEmergencyCallActive();
}
@GuardedBy("this")
boolean isOpsInactiveLocked() {
return mActiveIdleOpCount <= 0 && !mJobsActive && !mAlarmsActive;

148
services/tests/mockingservicestests/src/com/android/server/DeviceIdleControllerTest.java
View File

@@ -86,6 +86,9 @@ import android.os.PowerManagerInternal;
import android.os.PowerSaveState;
import android.os.SystemClock;
import android.provider.DeviceConfig;
import android.telephony.TelephonyCallback;
import android.telephony.TelephonyManager;
import android.telephony.emergency.EmergencyNumber;
import androidx.test.runner.AndroidJUnit4;
@@ -119,6 +122,8 @@ public class DeviceIdleControllerTest {
private AnyMotionDetectorForTest mAnyMotionDetector;
private AppStateTrackerForTest mAppStateTracker;
private DeviceIdleController.Constants mConstants;
private TelephonyCallback.OutgoingEmergencyCallListener mEmergencyCallListener;
private TelephonyCallback.CallStateListener mCallStateListener;
private InjectorForTest mInjector;
private MockitoSession mMockingSession;
@@ -140,6 +145,8 @@ public class DeviceIdleControllerTest {
private Sensor mMotionSensor;
@Mock
private SensorManager mSensorManager;
@Mock
private TelephonyManager mTelephonyManager;
class InjectorForTest extends DeviceIdleController.Injector {
ConnectivityManager connectivityManager;
@@ -231,6 +238,11 @@ public class DeviceIdleControllerTest {
return constraintController;
}
@Override
TelephonyManager getTelephonyManager() {
return mTelephonyManager;
}
@Override
boolean useMotionSensor() {
return true;
@@ -343,6 +355,15 @@ public class DeviceIdleControllerTest {
// Get the same Constants object that mDeviceIdleController got.
mConstants = mInjector.getConstants(mDeviceIdleController);
final ArgumentCaptor<TelephonyCallback> telephonyCallbackCaptor =
ArgumentCaptor.forClass(TelephonyCallback.class);
verify(mTelephonyManager)
.registerTelephonyCallback(any(), telephonyCallbackCaptor.capture());
mEmergencyCallListener = (TelephonyCallback.OutgoingEmergencyCallListener)
telephonyCallbackCaptor.getValue();
mCallStateListener =
(TelephonyCallback.CallStateListener) telephonyCallbackCaptor.getValue();
}
@After
@@ -531,6 +552,16 @@ public class DeviceIdleControllerTest {
mDeviceIdleController.becomeInactiveIfAppropriateLocked();
verifyStateConditions(STATE_ACTIVE);
// All other conditions allow for going INACTIVE...
setAlarmSoon(false);
setChargingOn(false);
setScreenOn(false);
// ...except the emergency call.
setEmergencyCallActive(true);
mDeviceIdleController.becomeInactiveIfAppropriateLocked();
verifyStateConditions(STATE_ACTIVE);
}
@Test
@@ -559,6 +590,15 @@ public class DeviceIdleControllerTest {
mDeviceIdleController.becomeInactiveIfAppropriateLocked();
verifyLightStateConditions(LIGHT_STATE_ACTIVE);
// All other conditions allow for going INACTIVE...
setChargingOn(false);
setScreenOn(false);
// ...except the emergency call.
setEmergencyCallActive(true);
mDeviceIdleController.becomeInactiveIfAppropriateLocked();
verifyLightStateConditions(LIGHT_STATE_ACTIVE);
}
@Test
@@ -569,6 +609,7 @@ public class DeviceIdleControllerTest {
setAlarmSoon(false);
setChargingOn(false);
setScreenOn(false);
setEmergencyCallActive(false);
mDeviceIdleController.becomeInactiveIfAppropriateLocked();
verifyStateConditions(STATE_INACTIVE);
@@ -613,6 +654,7 @@ public class DeviceIdleControllerTest {
setChargingOn(false);
setScreenOn(false);
setEmergencyCallActive(false);
mDeviceIdleController.becomeInactiveIfAppropriateLocked();
verifyLightStateConditions(LIGHT_STATE_INACTIVE);
@@ -1147,6 +1189,22 @@ public class DeviceIdleControllerTest {
eq(true));
}
@Test
public void testEmergencyCallEndTriggersInactive() {
setAlarmSoon(false);
setChargingOn(false);
setScreenOn(false);
setEmergencyCallActive(true);
verifyStateConditions(STATE_ACTIVE);
verifyLightStateConditions(LIGHT_STATE_ACTIVE);
setEmergencyCallActive(false);
verifyStateConditions(STATE_INACTIVE);
verifyLightStateConditions(LIGHT_STATE_INACTIVE);
}
///////////////// EXIT conditions ///////////////////
@Test
@@ -2096,6 +2154,75 @@ public class DeviceIdleControllerTest {
.onDeviceStationaryChanged(eq(true));
}
@Test
public void testEmergencyEndsIdle() {
enterDeepState(STATE_ACTIVE);
setEmergencyCallActive(true);
verifyStateConditions(STATE_ACTIVE);
enterDeepState(STATE_INACTIVE);
setEmergencyCallActive(true);
verifyStateConditions(STATE_ACTIVE);
enterDeepState(STATE_IDLE_PENDING);
setEmergencyCallActive(true);
verifyStateConditions(STATE_ACTIVE);
enterDeepState(STATE_SENSING);
setEmergencyCallActive(true);
verifyStateConditions(STATE_ACTIVE);
enterDeepState(STATE_LOCATING);
setEmergencyCallActive(true);
verifyStateConditions(STATE_ACTIVE);
// Quick doze enabled or not shouldn't affect the end state.
enterDeepState(STATE_QUICK_DOZE_DELAY);
setQuickDozeEnabled(true);
setEmergencyCallActive(true);
verifyStateConditions(STATE_ACTIVE);
enterDeepState(STATE_QUICK_DOZE_DELAY);
setQuickDozeEnabled(false);
setEmergencyCallActive(true);
verifyStateConditions(STATE_ACTIVE);
enterDeepState(STATE_IDLE);
setEmergencyCallActive(true);
verifyStateConditions(STATE_ACTIVE);
enterDeepState(STATE_IDLE_MAINTENANCE);
setEmergencyCallActive(true);
verifyStateConditions(STATE_ACTIVE);
}
@Test
public void testEmergencyEndsLightIdle() {
enterLightState(LIGHT_STATE_ACTIVE);
setEmergencyCallActive(true);
verifyLightStateConditions(LIGHT_STATE_ACTIVE);
enterLightState(LIGHT_STATE_INACTIVE);
setEmergencyCallActive(true);
verifyLightStateConditions(LIGHT_STATE_ACTIVE);
enterLightState(LIGHT_STATE_WAITING_FOR_NETWORK);
setEmergencyCallActive(true);
verifyLightStateConditions(LIGHT_STATE_ACTIVE);
enterLightState(LIGHT_STATE_IDLE);
setEmergencyCallActive(true);
verifyLightStateConditions(LIGHT_STATE_ACTIVE);
enterLightState(LIGHT_STATE_IDLE_MAINTENANCE);
setEmergencyCallActive(true);
verifyLightStateConditions(LIGHT_STATE_ACTIVE);
enterLightState(LIGHT_STATE_OVERRIDE);
setEmergencyCallActive(true);
verifyLightStateConditions(LIGHT_STATE_ACTIVE);
}
private void enterDeepState(int state) {
switch (state) {
case STATE_ACTIVE:
@@ -2108,6 +2235,7 @@ public class DeviceIdleControllerTest {
setQuickDozeEnabled(true);
setScreenOn(false);
setChargingOn(false);
setEmergencyCallActive(false);
mDeviceIdleController.becomeInactiveIfAppropriateLocked();
break;
case STATE_LOCATING:
@@ -2128,6 +2256,7 @@ public class DeviceIdleControllerTest {
setQuickDozeEnabled(false);
setScreenOn(false);
setChargingOn(false);
setEmergencyCallActive(false);
mDeviceIdleController.becomeInactiveIfAppropriateLocked();
int count = 0;
while (mDeviceIdleController.getState() != state) {
@@ -2159,6 +2288,7 @@ public class DeviceIdleControllerTest {
enterLightState(LIGHT_STATE_ACTIVE);
setScreenOn(false);
setChargingOn(false);
setEmergencyCallActive(false);
int count = 0;
mDeviceIdleController.becomeInactiveIfAppropriateLocked();
while (mDeviceIdleController.getLightState() != lightState) {
@@ -2177,6 +2307,7 @@ public class DeviceIdleControllerTest {
case LIGHT_STATE_OVERRIDE:
setScreenOn(false);
setChargingOn(false);
setEmergencyCallActive(false);
mDeviceIdleController.setLightStateForTest(lightState);
break;
default:
@@ -2188,6 +2319,14 @@ public class DeviceIdleControllerTest {
mDeviceIdleController.updateChargingLocked(on);
}
private void setEmergencyCallActive(boolean active) {
if (active) {
mEmergencyCallListener.onOutgoingEmergencyCall(mock(EmergencyNumber.class), 0);
} else {
mCallStateListener.onCallStateChanged(TelephonyManager.CALL_STATE_IDLE);
}
}
private void setScreenLocked(boolean locked) {
mDeviceIdleController.keyguardShowingLocked(locked);
}
@@ -2235,6 +2374,7 @@ public class DeviceIdleControllerTest {
assertFalse(mDeviceIdleController.isCharging());
assertFalse(mDeviceIdleController.isScreenOn()
&& !mDeviceIdleController.isKeyguardShowing());
assertFalse(mDeviceIdleController.isEmergencyCallActive());
break;
case STATE_IDLE_PENDING:
assertEquals(
@@ -2244,6 +2384,7 @@ public class DeviceIdleControllerTest {
assertFalse(mDeviceIdleController.isCharging());
assertFalse(mDeviceIdleController.isScreenOn()
&& !mDeviceIdleController.isKeyguardShowing());
assertFalse(mDeviceIdleController.isEmergencyCallActive());
break;
case STATE_SENSING:
assertEquals(
@@ -2255,6 +2396,7 @@ public class DeviceIdleControllerTest {
assertFalse(mDeviceIdleController.isCharging());
assertFalse(mDeviceIdleController.isScreenOn()
&& !mDeviceIdleController.isKeyguardShowing());
assertFalse(mDeviceIdleController.isEmergencyCallActive());
break;
case STATE_LOCATING:
assertEquals(
@@ -2263,6 +2405,7 @@ public class DeviceIdleControllerTest {
assertFalse(mDeviceIdleController.isCharging());
assertFalse(mDeviceIdleController.isScreenOn()
&& !mDeviceIdleController.isKeyguardShowing());
assertFalse(mDeviceIdleController.isEmergencyCallActive());
break;
case STATE_IDLE:
if (mDeviceIdleController.hasMotionSensor()) {
@@ -2276,6 +2419,7 @@ public class DeviceIdleControllerTest {
&& !mDeviceIdleController.isKeyguardShowing());
// Light state should be OVERRIDE at this point.
verifyLightStateConditions(LIGHT_STATE_OVERRIDE);
assertFalse(mDeviceIdleController.isEmergencyCallActive());
break;
case STATE_IDLE_MAINTENANCE:
if (mDeviceIdleController.hasMotionSensor()) {
@@ -2287,6 +2431,7 @@ public class DeviceIdleControllerTest {
assertFalse(mDeviceIdleController.isCharging());
assertFalse(mDeviceIdleController.isScreenOn()
&& !mDeviceIdleController.isKeyguardShowing());
assertFalse(mDeviceIdleController.isEmergencyCallActive());
break;
case STATE_QUICK_DOZE_DELAY:
// If quick doze is enabled, the motion listener should NOT be active.
@@ -2295,6 +2440,7 @@ public class DeviceIdleControllerTest {
assertFalse(mDeviceIdleController.isCharging());
assertFalse(mDeviceIdleController.isScreenOn()
&& !mDeviceIdleController.isKeyguardShowing());
assertFalse(mDeviceIdleController.isEmergencyCallActive());
break;
default:
fail("Conditions for " + stateToString(expectedState) + " unknown.");
@@ -2312,6 +2458,7 @@ public class DeviceIdleControllerTest {
case LIGHT_STATE_ACTIVE:
assertTrue(
mDeviceIdleController.isCharging() || mDeviceIdleController.isScreenOn()
|| mDeviceIdleController.isEmergencyCallActive()
// Or there's an alarm coming up soon.
|| SystemClock.elapsedRealtime() + mConstants.MIN_TIME_TO_ALARM
> mAlarmManager.getNextWakeFromIdleTime());
@@ -2324,6 +2471,7 @@ public class DeviceIdleControllerTest {
assertFalse(mDeviceIdleController.isCharging());
assertFalse(mDeviceIdleController.isScreenOn()
&& !mDeviceIdleController.isKeyguardShowing());
assertFalse(mDeviceIdleController.isEmergencyCallActive());
break;
default:
fail("Conditions for " + lightStateToString(expectedLightState) + " unknown.");