Adds requestBaseStateOverride method on DeviceStateManagerService (d5fe5cc1) · Commits · e / os / android_frameworks_base

core/java/android/hardware/devicestate/IDeviceStateManager.aidl

+44 −1

Original line number	Original line	Diff line number	Diff line
	@@ -41,6 +41,10 @@ interface IDeviceStateManager {
	* previously registered with {@link #registerCallback(IDeviceStateManagerCallback)} before a		* previously registered with {@link #registerCallback(IDeviceStateManagerCallback)} before a
	* call to this method.		* call to this method.
	*		*
			* Requesting a state does not cancel a base state override made through
			* {@link #requestBaseStateOverride}, but will still attempt to put the device into the
			* supplied {@code state}.
			*
	* @param token the request token provided		* @param token the request token provided
	* @param state the state of device the request is asking for		* @param state the state of device the request is asking for
	* @param flags any flags that correspond to the request		* @param flags any flags that correspond to the request
	@@ -50,14 +54,53 @@ interface IDeviceStateManager {
	* @throws IllegalStateException if the supplied {@code token} has already been registered.		* @throws IllegalStateException if the supplied {@code token} has already been registered.
	* @throws IllegalArgumentException if the supplied {@code state} is not supported.		* @throws IllegalArgumentException if the supplied {@code state} is not supported.
	*/		*/
			@JavaPassthrough(annotation=
			"@android.annotation.RequiresPermission(value=android.Manifest.permission.CONTROL_DEVICE_STATE, conditional=true)")
	void requestState(IBinder token, int state, int flags);		void requestState(IBinder token, int state, int flags);

	/**		/**
	* Cancels the active request previously submitted with a call to		* Cancels the active request previously submitted with a call to
	* {@link #requestState(IBinder, int, int)}.		* {@link #requestState(IBinder, int, int)}. Will have no effect on any base state override that
			* was previously requested with {@link #requestBaseStateOverride}.
	*		*
	* @throws IllegalStateException if a callback has not yet been registered for the calling		* @throws IllegalStateException if a callback has not yet been registered for the calling
	* process.		* process.
	*/		*/
			@JavaPassthrough(annotation=
			"@android.annotation.RequiresPermission(value=android.Manifest.permission.CONTROL_DEVICE_STATE, conditional=true)")
	void cancelStateRequest();		void cancelStateRequest();

			/**
			* Requests that the device's base state be overridden to the supplied {@code state}. A callback
			* <b>MUST</b> have been previously registered with
			* {@link #registerCallback(IDeviceStateManagerCallback)} before a call to this method.
			*
			* This method should only be used for testing, when you want to simulate the device physically
			* changing states. If you are looking to change device state for a feature, where the system
			* should still be aware that the physical state is different than the emulated state, use
			* {@link #requestState}.
			*
			* @param token the request token provided
			* @param state the state of device the request is asking for
			* @param flags any flags that correspond to the request
			*
			* @throws IllegalStateException if a callback has not yet been registered for the calling
			* process.
			* @throws IllegalStateException if the supplied {@code token} has already been registered.
			* @throws IllegalArgumentException if the supplied {@code state} is not supported.
			*/
			@JavaPassthrough(annotation=
			"@android.annotation.RequiresPermission(android.Manifest.permission.CONTROL_DEVICE_STATE)")
			void requestBaseStateOverride(IBinder token, int state, int flags);

			/**
			* Cancels the active base state request previously submitted with a call to
			* {@link #overrideBaseState(IBinder, int, int)}.
			*
			* @throws IllegalStateException if a callback has not yet been registered for the calling
			* process.
			*/
			@JavaPassthrough(annotation=
			"@android.annotation.RequiresPermission(android.Manifest.permission.CONTROL_DEVICE_STATE)")
			void cancelBaseStateOverride();
	}		}

services/core/java/com/android/server/devicestate/DeviceStateManagerService.java

+149 −11

Original line number	Original line	Diff line number	Diff line
	@@ -21,8 +21,11 @@ import static android.hardware.devicestate.DeviceStateManager.MAXIMUM_DEVICE_STA
	import static android.hardware.devicestate.DeviceStateManager.MINIMUM_DEVICE_STATE;		import static android.hardware.devicestate.DeviceStateManager.MINIMUM_DEVICE_STATE;

	import static com.android.server.devicestate.DeviceState.FLAG_CANCEL_OVERRIDE_REQUESTS;		import static com.android.server.devicestate.DeviceState.FLAG_CANCEL_OVERRIDE_REQUESTS;
			import static com.android.server.devicestate.OverrideRequest.OVERRIDE_REQUEST_TYPE_BASE_STATE;
			import static com.android.server.devicestate.OverrideRequest.OVERRIDE_REQUEST_TYPE_EMULATED_STATE;
	import static com.android.server.devicestate.OverrideRequestController.STATUS_ACTIVE;		import static com.android.server.devicestate.OverrideRequestController.STATUS_ACTIVE;
	import static com.android.server.devicestate.OverrideRequestController.STATUS_CANCELED;		import static com.android.server.devicestate.OverrideRequestController.STATUS_CANCELED;
			import static com.android.server.devicestate.OverrideRequestController.STATUS_UNKNOWN;

	import android.annotation.IntDef;		import android.annotation.IntDef;
	import android.annotation.IntRange;		import android.annotation.IntRange;
	@@ -106,6 +109,8 @@ public final class DeviceStateManagerService extends SystemService {
	private final BinderService mBinderService;		private final BinderService mBinderService;
	@NonNull		@NonNull
	private final OverrideRequestController mOverrideRequestController;		private final OverrideRequestController mOverrideRequestController;
			@NonNull
			private final DeviceStateProviderListener mDeviceStateProviderListener;
	@VisibleForTesting		@VisibleForTesting
	@NonNull		@NonNull
	public ActivityTaskManagerInternal mActivityTaskManagerInternal;		public ActivityTaskManagerInternal mActivityTaskManagerInternal;
	@@ -139,6 +144,12 @@ public final class DeviceStateManagerService extends SystemService {
	@NonNull		@NonNull
	private Optional<OverrideRequest> mActiveOverride = Optional.empty();		private Optional<OverrideRequest> mActiveOverride = Optional.empty();

			// The current active base state override request. When set the device state specified here will
			// replace the value in mBaseState.
			@GuardedBy("mLock")
			@NonNull
			private Optional<OverrideRequest> mActiveBaseStateOverride = Optional.empty();

	// List of processes registered to receive notifications about changes to device state and		// List of processes registered to receive notifications about changes to device state and
	// request status indexed by process id.		// request status indexed by process id.
	@GuardedBy("mLock")		@GuardedBy("mLock")
	@@ -177,7 +188,8 @@ public final class DeviceStateManagerService extends SystemService {
	mOverrideRequestController = new OverrideRequestController(		mOverrideRequestController = new OverrideRequestController(
	this::onOverrideRequestStatusChangedLocked);		this::onOverrideRequestStatusChangedLocked);
	mDeviceStatePolicy = policy;		mDeviceStatePolicy = policy;
	mDeviceStatePolicy.getDeviceStateProvider().setListener(new DeviceStateProviderListener());		mDeviceStateProviderListener = new DeviceStateProviderListener();
			mDeviceStatePolicy.getDeviceStateProvider().setListener(mDeviceStateProviderListener);
	mBinderService = new BinderService();		mBinderService = new BinderService();
	mActivityTaskManagerInternal = LocalServices.getService(ActivityTaskManagerInternal.class);		mActivityTaskManagerInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
	}		}
	@@ -257,6 +269,21 @@ public final class DeviceStateManagerService extends SystemService {
	}		}
	}		}

			/**
			* Returns the current override base state, or {@link Optional#empty()} if no override state is
			* requested. If an override base state is present, the returned state will be the same as
			* the base state returned from {@link #getBaseState()}.
			*/
			@NonNull
			Optional<DeviceState> getOverrideBaseState() {
			synchronized (mLock) {
			if (mActiveBaseStateOverride.isPresent()) {
			return getStateLocked(mActiveBaseStateOverride.get().getRequestedState());
			}
			return Optional.empty();
			}
			}

	/** Returns the list of currently supported device states. */		/** Returns the list of currently supported device states. */
	DeviceState[] getSupportedStates() {		DeviceState[] getSupportedStates() {
	synchronized (mLock) {		synchronized (mLock) {
	@@ -366,6 +393,7 @@ public final class DeviceStateManagerService extends SystemService {
	}		}

	final DeviceState baseState = baseStateOptional.get();		final DeviceState baseState = baseStateOptional.get();

	if (mBaseState.isPresent() && mBaseState.get().equals(baseState)) {		if (mBaseState.isPresent() && mBaseState.get().equals(baseState)) {
	// Base state hasn't changed. Nothing to do.		// Base state hasn't changed. Nothing to do.
	return;		return;
	@@ -375,7 +403,7 @@ public final class DeviceStateManagerService extends SystemService {
	if (baseState.hasFlag(FLAG_CANCEL_OVERRIDE_REQUESTS)) {		if (baseState.hasFlag(FLAG_CANCEL_OVERRIDE_REQUESTS)) {
	mOverrideRequestController.cancelOverrideRequest();		mOverrideRequestController.cancelOverrideRequest();
	}		}
	mOverrideRequestController.handleBaseStateChanged();		mOverrideRequestController.handleBaseStateChanged(identifier);
	updatePendingStateLocked();		updatePendingStateLocked();

	if (!mPendingState.isPresent()) {		if (!mPendingState.isPresent()) {
	@@ -528,17 +556,42 @@ public final class DeviceStateManagerService extends SystemService {
	}		}
	}		}

			@GuardedBy("mLock")
	private void onOverrideRequestStatusChangedLocked(@NonNull OverrideRequest request,		private void onOverrideRequestStatusChangedLocked(@NonNull OverrideRequest request,
	@OverrideRequestController.RequestStatus int status) {		@OverrideRequestController.RequestStatus int status) {
	if (status == STATUS_ACTIVE) {		if (request.getRequestType() == OVERRIDE_REQUEST_TYPE_BASE_STATE) {
			switch (status) {
			case STATUS_ACTIVE:
			enableBaseStateRequestLocked(request);
			return;
			case STATUS_CANCELED:
			if (mActiveBaseStateOverride.isPresent()
			&& mActiveBaseStateOverride.get() == request) {
			mActiveBaseStateOverride = Optional.empty();
			}
			break;
			case STATUS_UNKNOWN: // same as default
			default:
			throw new IllegalArgumentException("Unknown request status: " + status);
			}
			} else if (request.getRequestType() == OVERRIDE_REQUEST_TYPE_EMULATED_STATE) {
			switch (status) {
			case STATUS_ACTIVE:
	mActiveOverride = Optional.of(request);		mActiveOverride = Optional.of(request);
	} else if (status == STATUS_CANCELED) {		break;
			case STATUS_CANCELED:
	if (mActiveOverride.isPresent() && mActiveOverride.get() == request) {		if (mActiveOverride.isPresent() && mActiveOverride.get() == request) {
	mActiveOverride = Optional.empty();		mActiveOverride = Optional.empty();
	}		}
	} else {		break;
			case STATUS_UNKNOWN: // same as default
			default:
	throw new IllegalArgumentException("Unknown request status: " + status);		throw new IllegalArgumentException("Unknown request status: " + status);
	}		}
			} else {
			throw new IllegalArgumentException(
			"Unknown OverrideRest type: " + request.getRequestType());
			}

	boolean updatedPendingState = updatePendingStateLocked();		boolean updatedPendingState = updatePendingStateLocked();

	@@ -564,6 +617,18 @@ public final class DeviceStateManagerService extends SystemService {
	mHandler.post(this::notifyPolicyIfNeeded);		mHandler.post(this::notifyPolicyIfNeeded);
	}		}

			/**
			* Sets the new base state of the device and notifies the process that made the base state
			* override request that the request is now active.
			*/
			@GuardedBy("mLock")
			private void enableBaseStateRequestLocked(OverrideRequest request) {
			setBaseState(request.getRequestedState());
			mActiveBaseStateOverride = Optional.of(request);
			ProcessRecord processRecord = mProcessRecords.get(request.getPid());
			processRecord.notifyRequestActiveAsync(request.getToken());
			}

	private void registerProcess(int pid, IDeviceStateManagerCallback callback) {		private void registerProcess(int pid, IDeviceStateManagerCallback callback) {
	synchronized (mLock) {		synchronized (mLock) {
	if (mProcessRecords.contains(pid)) {		if (mProcessRecords.contains(pid)) {
	@@ -606,7 +671,8 @@ public final class DeviceStateManagerService extends SystemService {
	+ " has no registered callback.");		+ " has no registered callback.");
	}		}

	if (mOverrideRequestController.hasRequest(token)) {		if (mOverrideRequestController.hasRequest(token,
			OVERRIDE_REQUEST_TYPE_EMULATED_STATE)) {
	throw new IllegalStateException("Request has already been made for the supplied"		throw new IllegalStateException("Request has already been made for the supplied"
	+ " token: " + token);		+ " token: " + token);
	}		}
	@@ -618,7 +684,7 @@ public final class DeviceStateManagerService extends SystemService {
	}		}

	OverrideRequest request = new OverrideRequest(token, callingPid, state, flags,		OverrideRequest request = new OverrideRequest(token, callingPid, state, flags,
	OverrideRequest.OVERRIDE_REQUEST_TYPE_EMULATED_STATE);		OVERRIDE_REQUEST_TYPE_EMULATED_STATE);
	mOverrideRequestController.addRequest(request);		mOverrideRequestController.addRequest(request);
	}		}
	}		}
	@@ -634,6 +700,44 @@ public final class DeviceStateManagerService extends SystemService {
	}		}
	}		}

			private void requestBaseStateOverrideInternal(int state, int flags, int callingPid,
			@NonNull IBinder token) {
			synchronized (mLock) {
			final Optional<DeviceState> deviceState = getStateLocked(state);
			if (!deviceState.isPresent()) {
			throw new IllegalArgumentException("Requested state: " + state
			+ " is not supported.");
			}

			final ProcessRecord processRecord = mProcessRecords.get(callingPid);
			if (processRecord == null) {
			throw new IllegalStateException("Process " + callingPid
			+ " has no registered callback.");
			}

			if (mOverrideRequestController.hasRequest(token,
			OVERRIDE_REQUEST_TYPE_BASE_STATE)) {
			throw new IllegalStateException("Request has already been made for the supplied"
			+ " token: " + token);
			}

			OverrideRequest request = new OverrideRequest(token, callingPid, state, flags,
			OVERRIDE_REQUEST_TYPE_BASE_STATE);
			mOverrideRequestController.addBaseStateRequest(request);
			}
			}

			private void cancelBaseStateOverrideInternal(int callingPid) {
			synchronized (mLock) {
			final ProcessRecord processRecord = mProcessRecords.get(callingPid);
			if (processRecord == null) {
			throw new IllegalStateException("Process " + callingPid
			+ " has no registered callback.");
			}
			setBaseState(mDeviceStateProviderListener.mCurrentBaseState);
			}
			}

	private void dumpInternal(PrintWriter pw) {		private void dumpInternal(PrintWriter pw) {
	pw.println("DEVICE STATE MANAGER (dumpsys device_state)");		pw.println("DEVICE STATE MANAGER (dumpsys device_state)");

	@@ -730,6 +834,8 @@ public final class DeviceStateManagerService extends SystemService {
	}		}

	private final class DeviceStateProviderListener implements DeviceStateProvider.Listener {		private final class DeviceStateProviderListener implements DeviceStateProvider.Listener {
			@IntRange(from = MINIMUM_DEVICE_STATE, to = MAXIMUM_DEVICE_STATE) int mCurrentBaseState;

	@Override		@Override
	public void onSupportedDeviceStatesChanged(DeviceState[] newDeviceStates) {		public void onSupportedDeviceStatesChanged(DeviceState[] newDeviceStates) {
	if (newDeviceStates.length == 0) {		if (newDeviceStates.length == 0) {
	@@ -744,7 +850,7 @@ public final class DeviceStateManagerService extends SystemService {
	if (identifier < MINIMUM_DEVICE_STATE \|\| identifier > MAXIMUM_DEVICE_STATE) {		if (identifier < MINIMUM_DEVICE_STATE \|\| identifier > MAXIMUM_DEVICE_STATE) {
	throw new IllegalArgumentException("Invalid identifier: " + identifier);		throw new IllegalArgumentException("Invalid identifier: " + identifier);
	}		}
			mCurrentBaseState = identifier;
	setBaseState(identifier);		setBaseState(identifier);
	}		}
	}		}
	@@ -895,6 +1001,38 @@ public final class DeviceStateManagerService extends SystemService {
	}		}
	}		}

			@Override // Binder call
			public void requestBaseStateOverride(IBinder token, int state, int flags) {
			final int callingPid = Binder.getCallingPid();
			getContext().enforceCallingOrSelfPermission(CONTROL_DEVICE_STATE,
			"Permission required to control base state of device.");

			if (token == null) {
			throw new IllegalArgumentException("Request token must not be null.");
			}

			final long callingIdentity = Binder.clearCallingIdentity();
			try {
			requestBaseStateOverrideInternal(state, flags, callingPid, token);
			} finally {
			Binder.restoreCallingIdentity(callingIdentity);
			}
			}

			@Override // Binder call
			public void cancelBaseStateOverride() {
			final int callingPid = Binder.getCallingPid();
			getContext().enforceCallingOrSelfPermission(CONTROL_DEVICE_STATE,
			"Permission required to control base state of device.");

			final long callingIdentity = Binder.clearCallingIdentity();
			try {
			cancelBaseStateOverrideInternal(callingPid);
			} finally {
			Binder.restoreCallingIdentity(callingIdentity);
			}
			}

	@Override // Binder call		@Override // Binder call
	public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,		public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
	String[] args, ShellCallback callback, ResultReceiver result) {		String[] args, ShellCallback callback, ResultReceiver result) {

services/core/java/com/android/server/devicestate/DeviceStateManagerShellCommand.java

+45 −7

Original line number	Original line	Diff line number	Diff line
	@@ -16,11 +16,8 @@

	package com.android.server.devicestate;		package com.android.server.devicestate;

	import static android.Manifest.permission.CONTROL_DEVICE_STATE;

	import android.annotation.NonNull;		import android.annotation.NonNull;
	import android.annotation.Nullable;		import android.annotation.Nullable;
	import android.content.Context;
	import android.hardware.devicestate.DeviceStateManager;		import android.hardware.devicestate.DeviceStateManager;
	import android.hardware.devicestate.DeviceStateRequest;		import android.hardware.devicestate.DeviceStateRequest;
	import android.os.Binder;		import android.os.Binder;
	@@ -39,6 +36,8 @@ import java.util.stream.Collectors;
	public class DeviceStateManagerShellCommand extends ShellCommand {		public class DeviceStateManagerShellCommand extends ShellCommand {
	@Nullable		@Nullable
	private static DeviceStateRequest sLastRequest;		private static DeviceStateRequest sLastRequest;
			@Nullable
			private static DeviceStateRequest sLastBaseStateRequest;

	private final DeviceStateManagerService mService;		private final DeviceStateManagerService mService;
	private final DeviceStateManager mClient;		private final DeviceStateManager mClient;
	@@ -58,6 +57,8 @@ public class DeviceStateManagerShellCommand extends ShellCommand {
	switch (cmd) {		switch (cmd) {
	case "state":		case "state":
	return runState(pw);		return runState(pw);
			case "base-state":
			return runBaseState(pw);
	case "print-state":		case "print-state":
	return runPrintState(pw);		return runPrintState(pw);
	case "print-states":		case "print-states":
	@@ -89,10 +90,6 @@ public class DeviceStateManagerShellCommand extends ShellCommand {
	return 0;		return 0;
	}		}

	final Context context = mService.getContext();
	context.enforceCallingOrSelfPermission(
	CONTROL_DEVICE_STATE,
	"Permission required to request device state.");
	final long callingIdentity = Binder.clearCallingIdentity();		final long callingIdentity = Binder.clearCallingIdentity();
	try {		try {
	if ("reset".equals(nextArg)) {		if ("reset".equals(nextArg)) {
	@@ -127,6 +124,47 @@ public class DeviceStateManagerShellCommand extends ShellCommand {
	return 0;		return 0;
	}		}

			private int runBaseState(PrintWriter pw) {
			final String nextArg = getNextArg();
			if (nextArg == null) {
			printAllStates(pw);
			return 0;
			}

			final long callingIdentity = Binder.clearCallingIdentity();
			try {
			if ("reset".equals(nextArg)) {
			if (sLastBaseStateRequest != null) {
			mClient.cancelBaseStateOverride();
			sLastBaseStateRequest = null;
			}
			} else {
			int requestedState = Integer.parseInt(nextArg);
			DeviceStateRequest request = DeviceStateRequest.newBuilder(requestedState).build();

			mClient.requestBaseStateOverride(request, null, null);

			sLastBaseStateRequest = request;
			}
			} catch (NumberFormatException e) {
			getErrPrintWriter().println("Error: requested state should be an integer");
			return -1;
			} catch (IllegalArgumentException e) {
			getErrPrintWriter().println("Error: " + e.getMessage());
			getErrPrintWriter().println("-------------------");
			getErrPrintWriter().println("Run:");
			getErrPrintWriter().println("");
			getErrPrintWriter().println(" print-states");
			getErrPrintWriter().println("");
			getErrPrintWriter().println("to get the list of currently supported device states");
			return -1;
			} finally {
			Binder.restoreCallingIdentity(callingIdentity);
			}

			return 0;
			}

	private int runPrintState(PrintWriter pw) {		private int runPrintState(PrintWriter pw) {
	Optional<DeviceState> deviceState = mService.getCommittedState();		Optional<DeviceState> deviceState = mService.getCommittedState();
	if (deviceState.isPresent()) {		if (deviceState.isPresent()) {

services/core/java/com/android/server/devicestate/OverrideRequestController.java

+53 −11

Original line number	Original line	Diff line number	Diff line
	@@ -75,6 +75,8 @@ final class OverrideRequestController {

	// Handle to the current override request, null if none.		// Handle to the current override request, null if none.
	private OverrideRequest mRequest;		private OverrideRequest mRequest;
			// Handle to the current base state override request, null if none.
			private OverrideRequest mBaseStateRequest;

	private boolean mStickyRequestsAllowed;		private boolean mStickyRequestsAllowed;
	// The current request has outlived their process.		// The current request has outlived their process.
	@@ -111,13 +113,23 @@ final class OverrideRequestController {
	}		}
	}		}

			void addBaseStateRequest(@NonNull OverrideRequest request) {
			OverrideRequest previousRequest = mBaseStateRequest;
			mBaseStateRequest = request;
			mListener.onStatusChanged(request, STATUS_ACTIVE);

			if (previousRequest != null) {
			cancelRequestLocked(previousRequest);
			}
			}

	/**		/**
	* Cancels the request with the specified {@code token} and notifies the listener of all changes		* Cancels the request with the specified {@code token} and notifies the listener of all changes
	* to request status as a result of this operation.		* to request status as a result of this operation.
	*/		*/
	void cancelRequest(@NonNull OverrideRequest request) {		void cancelRequest(@NonNull OverrideRequest request) {
	// Either don't have a current request or attempting to cancel an already cancelled request		// Either don't have a current request or attempting to cancel an already cancelled request
	if (!hasRequest(request.getToken())) {		if (!hasRequest(request.getToken(), request.getRequestType())) {
	return;		return;
	}		}
	cancelCurrentRequestLocked();		cancelCurrentRequestLocked();
	@@ -143,13 +155,26 @@ final class OverrideRequestController {
	cancelCurrentRequestLocked();		cancelCurrentRequestLocked();
	}		}

			/**
			* Cancels the current base state override request, this could be due to the physical
			* configuration of the device changing.
			*/
			void cancelBaseStateOverrideRequest() {
			cancelCurrentBaseStateRequestLocked();
			}

	/**		/**
	* Returns {@code true} if this controller is current managing a request with the specified		* Returns {@code true} if this controller is current managing a request with the specified
	* {@code token}, {@code false} otherwise.		* {@code token}, {@code false} otherwise.
	*/		*/
	boolean hasRequest(@NonNull IBinder token) {		boolean hasRequest(@NonNull IBinder token,
			@OverrideRequest.OverrideRequestType int requestType) {
			if (requestType == OverrideRequest.OVERRIDE_REQUEST_TYPE_BASE_STATE) {
			return mBaseStateRequest != null && token == mBaseStateRequest.getToken();
			} else {
	return mRequest != null && token == mRequest.getToken();		return mRequest != null && token == mRequest.getToken();
	}		}
			}

	/**		/**
	* Notifies the controller that the process with the specified {@code pid} has died. The		* Notifies the controller that the process with the specified {@code pid} has died. The
	@@ -157,11 +182,11 @@ final class OverrideRequestController {
	* operation.		* operation.
	*/		*/
	void handleProcessDied(int pid) {		void handleProcessDied(int pid) {
	if (mRequest == null) {		if (mBaseStateRequest != null && mBaseStateRequest.getPid() == pid) {
	return;		cancelCurrentBaseStateRequestLocked();
	}		}

	if (mRequest.getPid() == pid) {		if (mRequest != null && mRequest.getPid() == pid) {
	if (mStickyRequestsAllowed) {		if (mStickyRequestsAllowed) {
	// Do not cancel the requests now because sticky requests are allowed. These		// Do not cancel the requests now because sticky requests are allowed. These
	// requests will be cancelled on a call to cancelStickyRequests().		// requests will be cancelled on a call to cancelStickyRequests().
	@@ -176,7 +201,10 @@ final class OverrideRequestController {
	* Notifies the controller that the base state has changed. The controller will notify the		* Notifies the controller that the base state has changed. The controller will notify the
	* listener of all changes to request status as a result of this change.		* listener of all changes to request status as a result of this change.
	*/		*/
	void handleBaseStateChanged() {		void handleBaseStateChanged(int state) {
			if (mBaseStateRequest != null && state != mBaseStateRequest.getRequestedState()) {
			cancelBaseStateOverrideRequest();
			}
	if (mRequest == null) {		if (mRequest == null) {
	return;		return;
	}		}
	@@ -192,11 +220,12 @@ final class OverrideRequestController {
	* notify the listener of all changes to request status as a result of this change.		* notify the listener of all changes to request status as a result of this change.
	*/		*/
	void handleNewSupportedStates(int[] newSupportedStates) {		void handleNewSupportedStates(int[] newSupportedStates) {
	if (mRequest == null) {		if (mBaseStateRequest != null && !contains(newSupportedStates,
	return;		mBaseStateRequest.getRequestedState())) {
			cancelCurrentBaseStateRequestLocked();
	}		}

	if (!contains(newSupportedStates, mRequest.getRequestedState())) {		if (mRequest != null && !contains(newSupportedStates, mRequest.getRequestedState())) {
	cancelCurrentRequestLocked();		cancelCurrentRequestLocked();
	}		}
	}		}
	@@ -228,10 +257,23 @@ final class OverrideRequestController {
	return;		return;
	}		}
	mStickyRequest = false;		mStickyRequest = false;
	mListener.onStatusChanged(mRequest, STATUS_CANCELED);		cancelRequestLocked(mRequest);
	mRequest = null;		mRequest = null;
	}		}

			/**
			* Handles cancelling {@code mBaseStateRequest}.
			* Notifies the listener of the canceled status as well.
			*/
			private void cancelCurrentBaseStateRequestLocked() {
			if (mBaseStateRequest == null) {
			Slog.w(TAG, "Attempted to cancel a null OverrideRequest");
			return;
			}
			cancelRequestLocked(mBaseStateRequest);
			mBaseStateRequest = null;
			}

	private static boolean contains(int[] array, int value) {		private static boolean contains(int[] array, int value) {
	for (int i = 0; i < array.length; i++) {		for (int i = 0; i < array.length; i++) {
	if (array[i] == value) {		if (array[i] == value) {

services/tests/servicestests/src/com/android/server/devicestate/DeviceStateManagerServiceTest.java

+151 −0

File changed.

Preview size limit exceeded, changes collapsed.