Merge changes If6c9684f,Iefab4b8b (61f31c7b) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/am/ActivityManagerService.java

+91 −90

Original line number	Diff line number	Diff line
		@@ -2627,11 +2627,11 @@ public class ActivityManagerService extends IActivityManager.Stub
		}

		@VisibleForTesting
		public ActivityManagerService() {
		public ActivityManagerService(AppOpsService appOpsService) {
		GL_ES_VERSION = 0;
		mActivityStarter = null;
		mAppErrors = null;
		mAppOpsService = null;
		mAppOpsService = appOpsService;
		mBatteryStatsService = null;
		mCompatModePackages = null;
		mConstants = null;
		@@ -4257,7 +4257,8 @@ public class ActivityManagerService extends IActivityManager.Stub
		mProcessObservers.finishBroadcast();
		}

		private void dispatchUidsChanged() {
		@VisibleForTesting
		void dispatchUidsChanged() {
		int N;
		synchronized (this) {
		N = mPendingUidChanges.size();
		@@ -4280,23 +4281,49 @@ public class ActivityManagerService extends IActivityManager.Stub
		int i = mUidObservers.beginBroadcast();
		while (i > 0) {
		i--;
		final IUidObserver observer = mUidObservers.getBroadcastItem(i);
		final UidObserverRegistration reg = (UidObserverRegistration)
		mUidObservers.getBroadcastCookie(i);
		if (observer != null) {
		try {
		for (int j=0; j<N; j++) {
		UidRecord.ChangeItem item = mActiveUidChanges[j];
		final int change = item.change;
		UidRecord validateUid = null;
		if (VALIDATE_UID_STATES && i == 0) {
		validateUid = mValidateUids.get(item.uid);
		if (validateUid == null && change != UidRecord.CHANGE_GONE
		&& change != UidRecord.CHANGE_GONE_IDLE) {
		dispatchUidsChangedForObserver(mUidObservers.getBroadcastItem(i),
		(UidObserverRegistration) mUidObservers.getBroadcastCookie(i), N);
		}
		mUidObservers.finishBroadcast();

		if (VALIDATE_UID_STATES && mUidObservers.getRegisteredCallbackCount() > 0) {
		for (int j = 0; j < N; ++j) {
		final UidRecord.ChangeItem item = mActiveUidChanges[j];
		if (item.change == UidRecord.CHANGE_GONE
		\|\| item.change == UidRecord.CHANGE_GONE_IDLE) {
		mValidateUids.remove(item.uid);
		} else {
		UidRecord validateUid = mValidateUids.get(item.uid);
		if (validateUid == null) {
		validateUid = new UidRecord(item.uid);
		mValidateUids.put(item.uid, validateUid);
		}
		if (item.change == UidRecord.CHANGE_IDLE) {
		validateUid.idle = true;
		} else if (item.change == UidRecord.CHANGE_ACTIVE) {
		validateUid.idle = false;
		}
		validateUid.curProcState = validateUid.setProcState = item.processState;
		}
		}
		}

		synchronized (this) {
		for (int j = 0; j < N; j++) {
		mAvailUidChanges.add(mActiveUidChanges[j]);
		}
		}
		}

		private void dispatchUidsChangedForObserver(IUidObserver observer,
		UidObserverRegistration reg, int changesSize) {
		if (observer == null) {
		return;
		}
		try {
		for (int j = 0; j < changesSize; j++) {
		UidRecord.ChangeItem item = mActiveUidChanges[j];
		final int change = item.change;
		if (change == UidRecord.CHANGE_IDLE
		\|\| change == UidRecord.CHANGE_GONE_IDLE) {
		if ((reg.which & ActivityManager.UID_OBSERVER_IDLE) != 0) {
		@@ -4304,20 +4331,12 @@ public class ActivityManagerService extends IActivityManager.Stub
		"UID idle uid=" + item.uid);
		observer.onUidIdle(item.uid, item.ephemeral);
		}
		if (VALIDATE_UID_STATES && i == 0) {
		if (validateUid != null) {
		validateUid.idle = true;
		}
		}
		} else if (change == UidRecord.CHANGE_ACTIVE) {
		if ((reg.which & ActivityManager.UID_OBSERVER_ACTIVE) != 0) {
		if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS,
		"UID active uid=" + item.uid);
		observer.onUidActive(item.uid);
		}
		if (VALIDATE_UID_STATES && i == 0) {
		validateUid.idle = false;
		}
		}
		if (change == UidRecord.CHANGE_GONE
		\|\| change == UidRecord.CHANGE_GONE_IDLE) {
		@@ -4329,11 +4348,6 @@ public class ActivityManagerService extends IActivityManager.Stub
		if (reg.lastProcStates != null) {
		reg.lastProcStates.delete(item.uid);
		}
		if (VALIDATE_UID_STATES && i == 0) {
		if (validateUid != null) {
		mValidateUids.remove(item.uid);
		}
		}
		} else {
		if ((reg.which & ActivityManager.UID_OBSERVER_PROCSTATE) != 0) {
		if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS,
		@@ -4359,24 +4373,11 @@ public class ActivityManagerService extends IActivityManager.Stub
		observer.onUidStateChanged(item.uid, item.processState);
		}
		}
		if (VALIDATE_UID_STATES && i == 0) {
		validateUid.curProcState = validateUid.setProcState
		= item.processState;
		}
		}
		}
		} catch (RemoteException e) {
		}
		}
		}
		mUidObservers.finishBroadcast();

		synchronized (this) {
		for (int j=0; j<N; j++) {
		mAvailUidChanges.add(mActiveUidChanges[j]);
		}
		}
		}

		@Override
		public final int startActivity(IApplicationThread caller, String callingPackage,

services/tests/servicestests/src/com/android/server/am/ActivityManagerServiceTest.java

+308 −2

Original line number	Diff line number	Diff line
		@@ -31,15 +31,35 @@ import static android.util.DebugUtils.valueToString;

		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertFalse;
		import static org.junit.Assert.assertNotEquals;
		import static org.junit.Assert.assertNotNull;
		import static org.junit.Assert.assertNull;
		import static org.junit.Assert.assertTrue;
		import static org.mockito.Mockito.verify;
		import static org.mockito.Mockito.verifyNoMoreInteractions;
		import static org.mockito.Mockito.when;

		import android.app.ActivityManager;
		import android.app.AppOpsManager;
		import android.app.IUidObserver;
		import android.os.IBinder;
		import android.os.Process;
		import android.os.RemoteException;
		import android.support.test.filters.SmallTest;
		import android.support.test.runner.AndroidJUnit4;

		import com.android.server.AppOpsService;

		import org.junit.Before;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.Mock;
		import org.mockito.Mockito;
		import org.mockito.MockitoAnnotations;

		import java.util.ArrayList;
		import java.util.HashMap;
		import java.util.Map;
		import java.util.function.Function;

		/**
		@@ -62,9 +82,16 @@ import java.util.function.Function;
		public class ActivityManagerServiceTest {
		private static final int TEST_UID = 111;

		@Mock private AppOpsService mAppOpsService;

		@Before
		public void setUp() {
		MockitoAnnotations.initMocks(this);
		}

		@Test
		public void testIncrementProcStateSeqIfNeeded() {
		final ActivityManagerService ams = new ActivityManagerService();
		final ActivityManagerService ams = new ActivityManagerService(mAppOpsService);
		final UidRecord uidRec = new UidRecord(TEST_UID);

		assertEquals("Initially global seq counter should be 0", 0, ams.mProcStateSeqCounter);
		@@ -104,7 +131,7 @@ public class ActivityManagerServiceTest {

		@Test
		public void testShouldIncrementProcStateSeq() {
		final ActivityManagerService ams = new ActivityManagerService();
		final ActivityManagerService ams = new ActivityManagerService(mAppOpsService);
		final UidRecord uidRec = new UidRecord(TEST_UID);

		final String error1 = "Seq should be incremented: prevState: %s, curState: %s";
		@@ -145,4 +172,283 @@ public class ActivityManagerServiceTest {
		uidRec.curProcState = PROCESS_STATE_LAST_ACTIVITY;
		assertTrue(errorMsg.apply(error1), ams.shouldIncrementProcStateSeq(uidRec));
		}

		/**
		* This test verifies that process state changes are dispatched to observers based on the
		* changes they wanted to listen (this is specified when registering the observer).
		*/
		@Test
		public void testDispatchUids_dispatchNeededChanges() throws RemoteException {
		final ActivityManagerService ams = new ActivityManagerService(mAppOpsService);
		when(mAppOpsService.checkOperation(AppOpsManager.OP_GET_USAGE_STATS, Process.myUid(), null))
		.thenReturn(AppOpsManager.MODE_ALLOWED);

		final int[] changesToObserve = {
		ActivityManager.UID_OBSERVER_PROCSTATE,
		ActivityManager.UID_OBSERVER_GONE,
		ActivityManager.UID_OBSERVER_IDLE,
		ActivityManager.UID_OBSERVER_ACTIVE,
		ActivityManager.UID_OBSERVER_PROCSTATE \| ActivityManager.UID_OBSERVER_GONE
		\| ActivityManager.UID_OBSERVER_ACTIVE \| ActivityManager.UID_OBSERVER_IDLE
		};
		final IUidObserver[] observers = new IUidObserver.Stub[changesToObserve.length];
		for (int i = 0; i < observers.length; ++i) {
		observers[i] = Mockito.mock(IUidObserver.Stub.class);
		when(observers[i].asBinder()).thenReturn((IBinder) observers[i]);
		ams.registerUidObserver(observers[i], changesToObserve[i] /* which */,
		ActivityManager.PROCESS_STATE_UNKNOWN /* cutpoint /, null / caller */);

		// When we invoke AMS.registerUidObserver, there are some interactions with observers[i]
		// mock in RemoteCallbackList class. We don't want to test those interactions and
		// at the same time, we don't want those to interfere with verifyNoMoreInteractions.
		// So, resetting the mock here.
		Mockito.reset(observers[i]);
		}

		// Add pending uid records each corresponding to a different change type UidRecord.CHANGE_*
		final int[] changesForPendingUidRecords = {
		UidRecord.CHANGE_PROCSTATE,
		UidRecord.CHANGE_GONE,
		UidRecord.CHANGE_GONE_IDLE,
		UidRecord.CHANGE_IDLE,
		UidRecord.CHANGE_ACTIVE
		};
		final int[] procStatesForPendingUidRecords = {
		ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE,
		ActivityManager.PROCESS_STATE_NONEXISTENT,
		ActivityManager.PROCESS_STATE_CACHED_EMPTY,
		ActivityManager.PROCESS_STATE_CACHED_ACTIVITY,
		ActivityManager.PROCESS_STATE_TOP
		};
		final Map<Integer, UidRecord.ChangeItem> changeItems = new HashMap<>();
		for (int i = 0; i < changesForPendingUidRecords.length; ++i) {
		final UidRecord.ChangeItem pendingChange = new UidRecord.ChangeItem();
		pendingChange.change = changesForPendingUidRecords[i];
		pendingChange.uid = i;
		pendingChange.processState = procStatesForPendingUidRecords[i];
		changeItems.put(changesForPendingUidRecords[i], pendingChange);
		ams.mPendingUidChanges.add(pendingChange);
		}

		ams.dispatchUidsChanged();
		// Verify the required changes have been dispatched to observers.
		for (int i = 0; i < observers.length; ++i) {
		final int changeToObserve = changesToObserve[i];
		final IUidObserver observerToTest = observers[i];
		if ((changeToObserve & ActivityManager.UID_OBSERVER_IDLE) != 0) {
		// Observer listens to uid idle changes, so change items corresponding to
		// UidRecord.CHANGE_IDLE or UidRecord.CHANGE_IDLE_GONE needs to be
		// delivered to this observer.
		final int[] changesToVerify = {
		UidRecord.CHANGE_IDLE,
		UidRecord.CHANGE_GONE_IDLE
		};
		verifyObserverReceivedChanges(observerToTest, changesToVerify, changeItems,
		(observer, changeItem) -> {
		verify(observer).onUidIdle(changeItem.uid, changeItem.ephemeral);
		});
		}
		if ((changeToObserve & ActivityManager.UID_OBSERVER_ACTIVE) != 0) {
		// Observer listens to uid active changes, so change items corresponding to
		// UidRecord.CHANGE_ACTIVE needs to be delivered to this observer.
		final int[] changesToVerify = { UidRecord.CHANGE_ACTIVE };
		verifyObserverReceivedChanges(observerToTest, changesToVerify, changeItems,
		(observer, changeItem) -> {
		verify(observer).onUidActive(changeItem.uid);
		});
		}
		if ((changeToObserve & ActivityManager.UID_OBSERVER_GONE) != 0) {
		// Observer listens to uid gone changes, so change items corresponding to
		// UidRecord.CHANGE_GONE or UidRecord.CHANGE_IDLE_GONE needs to be
		// delivered to this observer.
		final int[] changesToVerify = {
		UidRecord.CHANGE_GONE,
		UidRecord.CHANGE_GONE_IDLE
		};
		verifyObserverReceivedChanges(observerToTest, changesToVerify, changeItems,
		(observer, changeItem) -> {
		verify(observer).onUidGone(changeItem.uid, changeItem.ephemeral);
		});
		}
		if ((changeToObserve & ActivityManager.UID_OBSERVER_PROCSTATE) != 0) {
		// Observer listens to uid procState changes, so change items corresponding to
		// UidRecord.CHANGE_PROCSTATE or UidRecord.CHANGE_IDLE or UidRecord.CHANGE_ACTIVE
		// needs to be delivered to this observer.
		final int[] changesToVerify = {
		UidRecord.CHANGE_PROCSTATE,
		UidRecord.CHANGE_ACTIVE,
		UidRecord.CHANGE_IDLE
		};
		verifyObserverReceivedChanges(observerToTest, changesToVerify, changeItems,
		(observer, changeItem) -> {
		verify(observer).onUidStateChanged(
		changeItem.uid, changeItem.processState);
		});
		}
		// Verify there are no other callbacks for this observer.
		verifyNoMoreInteractions(observerToTest);
		}
		}

		private interface ObserverChangesVerifier {
		void verify(IUidObserver observer, UidRecord.ChangeItem changeItem) throws RemoteException;
		}

		private void verifyObserverReceivedChanges(IUidObserver observer, int[] changesToVerify,
		Map<Integer, UidRecord.ChangeItem> changeItems, ObserverChangesVerifier verifier)
		throws RemoteException {
		for (int change : changesToVerify) {
		final UidRecord.ChangeItem changeItem = changeItems.get(change);
		verifier.verify(observer, changeItem);
		}
		}

		/**
		* This test verifies that process state changes are dispatched to observers only when they
		* change across the cutpoint (this is specified when registering the observer).
		*/
		@Test
		public void testDispatchUidChanges_procStateCutpoint() throws RemoteException {
		final ActivityManagerService ams = new ActivityManagerService(mAppOpsService);
		final IUidObserver observer = Mockito.mock(IUidObserver.Stub.class);

		when(observer.asBinder()).thenReturn((IBinder) observer);
		ams.registerUidObserver(observer, ActivityManager.UID_OBSERVER_PROCSTATE /* which */,
		ActivityManager.PROCESS_STATE_SERVICE /* cutpoint /, null / callingPackage */);
		// When we invoke AMS.registerUidObserver, there are some interactions with observer
		// mock in RemoteCallbackList class. We don't want to test those interactions and
		// at the same time, we don't want those to interfere with verifyNoMoreInteractions.
		// So, resetting the mock here.
		Mockito.reset(observer);

		final UidRecord.ChangeItem changeItem = new UidRecord.ChangeItem();
		changeItem.uid = TEST_UID;
		changeItem.change = UidRecord.CHANGE_PROCSTATE;
		changeItem.processState = ActivityManager.PROCESS_STATE_LAST_ACTIVITY;
		ams.mPendingUidChanges.add(changeItem);
		ams.dispatchUidsChanged();
		// First process state message is always delivered regardless of whether the process state
		// change is above or below the cutpoint (PROCESS_STATE_SERVICE).
		verify(observer).onUidStateChanged(TEST_UID,
		ActivityManager.PROCESS_STATE_LAST_ACTIVITY);
		verifyNoMoreInteractions(observer);

		changeItem.processState = ActivityManager.PROCESS_STATE_RECEIVER;
		ams.mPendingUidChanges.add(changeItem);
		ams.dispatchUidsChanged();
		// Previous process state change is below cutpoint (PROCESS_STATE_SERVICE) and
		// the current process state change is also below cutpoint, so no callback will be invoked.
		verifyNoMoreInteractions(observer);

		changeItem.processState = ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE;
		ams.mPendingUidChanges.add(changeItem);
		ams.dispatchUidsChanged();
		// Previous process state change is below cutpoint (PROCESS_STATE_SERVICE) and
		// the current process state change is above cutpoint, so callback will be invoked with the
		// current process state change.
		verify(observer).onUidStateChanged(TEST_UID,
		ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE);
		verifyNoMoreInteractions(observer);

		changeItem.processState = ActivityManager.PROCESS_STATE_TOP;
		ams.mPendingUidChanges.add(changeItem);
		ams.dispatchUidsChanged();
		// Previous process state change is above cutpoint (PROCESS_STATE_SERVICE) and
		// the current process state change is also above cutpoint, so no callback will be invoked.
		verifyNoMoreInteractions(observer);

		changeItem.processState = ActivityManager.PROCESS_STATE_CACHED_EMPTY;
		ams.mPendingUidChanges.add(changeItem);
		ams.dispatchUidsChanged();
		// Previous process state change is above cutpoint (PROCESS_STATE_SERVICE) and
		// the current process state change is below cutpoint, so callback will be invoked with the
		// current process state change.
		verify(observer).onUidStateChanged(TEST_UID, ActivityManager.PROCESS_STATE_CACHED_EMPTY);
		verifyNoMoreInteractions(observer);
		}

		/**
		* This test verifies that {@link ActivityManagerService#mValidateUids} which is a
		* part of dumpsys is correctly updated.
		*/
		@Test
		public void testDispatchUidChanges_validateUidsUpdated() {
		final ActivityManagerService ams = new ActivityManagerService(mAppOpsService);

		final int[] changesForPendingItems = {
		UidRecord.CHANGE_PROCSTATE,
		UidRecord.CHANGE_GONE,
		UidRecord.CHANGE_GONE_IDLE,
		UidRecord.CHANGE_IDLE,
		UidRecord.CHANGE_ACTIVE
		};
		final int[] procStatesForPendingItems = {
		ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE,
		ActivityManager.PROCESS_STATE_CACHED_EMPTY,
		ActivityManager.PROCESS_STATE_CACHED_ACTIVITY,
		ActivityManager.PROCESS_STATE_SERVICE,
		ActivityManager.PROCESS_STATE_RECEIVER
		};
		final ArrayList<UidRecord.ChangeItem> pendingItemsForUids
		= new ArrayList<>(changesForPendingItems.length);
		for (int i = 0; i < changesForPendingItems.length; ++i) {
		final UidRecord.ChangeItem item = new UidRecord.ChangeItem();
		item.uid = i;
		item.change = changesForPendingItems[i];
		item.processState = procStatesForPendingItems[i];
		pendingItemsForUids.add(i, item);
		}

		// Verify that when there no observers listening to uid state changes, then there will
		// be no changes to validateUids.
		ams.mPendingUidChanges.addAll(pendingItemsForUids);
		ams.dispatchUidsChanged();
		assertEquals("No observers registered, so validateUids should be empty",
		0, ams.mValidateUids.size());

		final IUidObserver observer = Mockito.mock(IUidObserver.Stub.class);
		when(observer.asBinder()).thenReturn((IBinder) observer);
		ams.registerUidObserver(observer, 0, 0, null);
		// Verify that when observers are registered, then validateUids is correctly updated.
		ams.mPendingUidChanges.addAll(pendingItemsForUids);
		ams.dispatchUidsChanged();
		for (int i = 0; i < pendingItemsForUids.size(); ++i) {
		final UidRecord.ChangeItem item = pendingItemsForUids.get(i);
		final UidRecord validateUidRecord = ams.mValidateUids.get(item.uid);
		if (item.change == UidRecord.CHANGE_GONE \|\| item.change == UidRecord.CHANGE_GONE_IDLE) {
		assertNull("validateUidRecord should be null since the change is either "
		+ "CHANGE_GONE or CHANGE_GONE_IDLE", validateUidRecord);
		} else {
		assertNotNull("validateUidRecord should not be null since the change is neither "
		+ "CHANGE_GONE nor CHANGE_GONE_IDLE", validateUidRecord);
		assertEquals("processState: " + item.processState + " curProcState: "
		+ validateUidRecord.curProcState + " should have been equal",
		item.processState, validateUidRecord.curProcState);
		assertEquals("processState: " + item.processState + " setProcState: "
		+ validateUidRecord.curProcState + " should have been equal",
		item.processState, validateUidRecord.setProcState);
		if (item.change == UidRecord.CHANGE_IDLE) {
		assertTrue("UidRecord.idle should be updated to true for CHANGE_IDLE",
		validateUidRecord.idle);
		} else if (item.change == UidRecord.CHANGE_ACTIVE) {
		assertFalse("UidRecord.idle should be updated to false for CHANGE_ACTIVE",
		validateUidRecord.idle);
		}
		}
		}

		// Verify that when uid state changes to CHANGE_GONE or CHANGE_GONE_IDLE, then it
		// will be removed from validateUids.
		assertNotEquals("validateUids should not be empty", 0, ams.mValidateUids.size());
		for (int i = 0; i < pendingItemsForUids.size(); ++i) {
		final UidRecord.ChangeItem item = pendingItemsForUids.get(i);
		// Assign CHANGE_GONE_IDLE to some items and CHANGE_GONE to the others, using even/odd
		// distribution for this assignment.
		item.change = (i % 2) == 0 ? UidRecord.CHANGE_GONE_IDLE : UidRecord.CHANGE_GONE;
		}
		ams.mPendingUidChanges.addAll(pendingItemsForUids);
		ams.dispatchUidsChanged();
		assertEquals("validateUids should be empty, validateUids: " + ams.mValidateUids,
		0, ams.mValidateUids.size());
		}
		}
		No newline at end of file