Merge "A space-efficient 2D matrix" into sc-dev am: 1b1bbfc9f7 (56720be8) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/pm/AppsFilter.java

+42 −46

Original line number	Original line	Diff line number	Diff line
	@@ -58,10 +58,12 @@ import com.android.server.compat.CompatChange;
	import com.android.server.om.OverlayReferenceMapper;		import com.android.server.om.OverlayReferenceMapper;
	import com.android.server.pm.parsing.pkg.AndroidPackage;		import com.android.server.pm.parsing.pkg.AndroidPackage;
	import com.android.server.utils.Snappable;		import com.android.server.utils.Snappable;
			import com.android.server.utils.SnapshotCache;
	import com.android.server.utils.Snapshots;		import com.android.server.utils.Snapshots;
	import com.android.server.utils.Watchable;		import com.android.server.utils.Watchable;
	import com.android.server.utils.WatchableImpl;		import com.android.server.utils.WatchableImpl;
	import com.android.server.utils.WatchedArrayMap;		import com.android.server.utils.WatchedArrayMap;
			import com.android.server.utils.WatchedSparseBooleanMatrix;
	import com.android.server.utils.Watcher;		import com.android.server.utils.Watcher;

	import java.io.PrintWriter;		import java.io.PrintWriter;
	@@ -158,12 +160,21 @@ public class AppsFilter implements Watchable, Snappable {
	* initial scam and is null until {@link #onSystemReady()} is called.		* initial scam and is null until {@link #onSystemReady()} is called.
	*/		*/
	@GuardedBy("mCacheLock")		@GuardedBy("mCacheLock")
	private volatile SparseArray<SparseBooleanArray> mShouldFilterCache;		private volatile WatchedSparseBooleanMatrix mShouldFilterCache;

	/**		/**
	* A cached snapshot.		* A cached snapshot.
	*/		*/
	private volatile AppsFilter mSnapshot = null;		private final SnapshotCache<AppsFilter> mSnapshot;

			private SnapshotCache<AppsFilter> makeCache() {
			return new SnapshotCache<AppsFilter>(this, this) {
			@Override
			public AppsFilter createSnapshot() {
			AppsFilter s = new AppsFilter(mSource);
			return s;
			}};
			}

	/**		/**
	* Watchable machinery		* Watchable machinery
	@@ -211,7 +222,6 @@ public class AppsFilter implements Watchable, Snappable {
	*/		*/
	@Override		@Override
	public void dispatchChange(@Nullable Watchable what) {		public void dispatchChange(@Nullable Watchable what) {
	mSnapshot = null;
	mWatchable.dispatchChange(what);		mWatchable.dispatchChange(what);
	}		}

	@@ -236,6 +246,7 @@ public class AppsFilter implements Watchable, Snappable {
	overlayProvider);		overlayProvider);
	mStateProvider = stateProvider;		mStateProvider = stateProvider;
	mBackgroundExecutor = backgroundExecutor;		mBackgroundExecutor = backgroundExecutor;
			mSnapshot = makeCache();
	}		}

	/**		/**
	@@ -258,8 +269,14 @@ public class AppsFilter implements Watchable, Snappable {
	mSystemSigningDetails = orig.mSystemSigningDetails;		mSystemSigningDetails = orig.mSystemSigningDetails;
	mProtectedBroadcasts = orig.mProtectedBroadcasts;		mProtectedBroadcasts = orig.mProtectedBroadcasts;
	mShouldFilterCache = orig.mShouldFilterCache;		mShouldFilterCache = orig.mShouldFilterCache;
			if (mShouldFilterCache != null) {
			synchronized (orig.mCacheLock) {
			mShouldFilterCache = mShouldFilterCache.snapshot();
			}
			}

	mBackgroundExecutor = null;		mBackgroundExecutor = null;
			mSnapshot = new SnapshotCache.Sealed<>();
	}		}

	/**		/**
	@@ -268,13 +285,7 @@ public class AppsFilter implements Watchable, Snappable {
	* condition causes the cached snapshot to be cleared asynchronously to this method.		* condition causes the cached snapshot to be cleared asynchronously to this method.
	*/		*/
	public AppsFilter snapshot() {		public AppsFilter snapshot() {
	AppsFilter s = mSnapshot;		return mSnapshot.snapshot();
	if (s == null) {
	s = new AppsFilter(this);
	s.mWatchable.seal();
	mSnapshot = s;
	}
	return s;
	}		}

	/**		/**
	@@ -636,12 +647,7 @@ public class AppsFilter implements Watchable, Snappable {
	if (mShouldFilterCache != null) {		if (mShouldFilterCache != null) {
	// update the cache in a one-off manner since we've got all the information we		// update the cache in a one-off manner since we've got all the information we
	// need.		// need.
	SparseBooleanArray visibleUids = mShouldFilterCache.get(recipientUid);		mShouldFilterCache.put(recipientUid, visibleUid, false);
	if (visibleUids == null) {
	visibleUids = new SparseBooleanArray();
	mShouldFilterCache.put(recipientUid, visibleUids);
	}
	visibleUids.put(visibleUid, false);
	}		}
	}		}
	if (changed) {		if (changed) {
	@@ -813,23 +819,21 @@ public class AppsFilter implements Watchable, Snappable {
	if (mShouldFilterCache == null) {		if (mShouldFilterCache == null) {
	return;		return;
	}		}
	for (int i = mShouldFilterCache.size() - 1; i >= 0; i--) {		for (int i = 0; i < mShouldFilterCache.size(); i++) {
	if (UserHandle.getAppId(mShouldFilterCache.keyAt(i)) == appId) {		if (UserHandle.getAppId(mShouldFilterCache.keyAt(i)) == appId) {
	mShouldFilterCache.removeAt(i);		mShouldFilterCache.removeAt(i);
	continue;		// The key was deleted so the list of keys has shifted left. That means i
	}		// is now pointing at the next key to be examined. The decrement here and
	SparseBooleanArray targetSparseArray = mShouldFilterCache.valueAt(i);		// the loop increment together mean that i will be unchanged in the need
	for (int j = targetSparseArray.size() - 1; j >= 0; j--) {		// iteration and will correctly point to the next key to be examined.
	if (UserHandle.getAppId(targetSparseArray.keyAt(j)) == appId) {		i--;
	targetSparseArray.removeAt(j);
	}
	}		}
	}		}
	}		}

	private void updateEntireShouldFilterCache() {		private void updateEntireShouldFilterCache() {
	mStateProvider.runWithState((settings, users) -> {		mStateProvider.runWithState((settings, users) -> {
	SparseArray<SparseBooleanArray> cache =		WatchedSparseBooleanMatrix cache =
	updateEntireShouldFilterCacheInner(settings, users);		updateEntireShouldFilterCacheInner(settings, users);
	synchronized (mCacheLock) {		synchronized (mCacheLock) {
	mShouldFilterCache = cache;		mShouldFilterCache = cache;
	@@ -837,10 +841,10 @@ public class AppsFilter implements Watchable, Snappable {
	});		});
	}		}

	private SparseArray<SparseBooleanArray> updateEntireShouldFilterCacheInner(		private WatchedSparseBooleanMatrix updateEntireShouldFilterCacheInner(
	ArrayMap<String, PackageSetting> settings, UserInfo[] users) {		ArrayMap<String, PackageSetting> settings, UserInfo[] users) {
	SparseArray<SparseBooleanArray> cache =		WatchedSparseBooleanMatrix cache =
	new SparseArray<>(users.length * settings.size());		new WatchedSparseBooleanMatrix(users.length * settings.size());
	for (int i = settings.size() - 1; i >= 0; i--) {		for (int i = settings.size() - 1; i >= 0; i--) {
	updateShouldFilterCacheForPackage(cache,		updateShouldFilterCacheForPackage(cache,
	null /skipPackage/, settings.valueAt(i), settings, users, i);		null /skipPackage/, settings.valueAt(i), settings, users, i);
	@@ -864,7 +868,7 @@ public class AppsFilter implements Watchable, Snappable {
	packagesCache.put(settings.keyAt(i), pkg);		packagesCache.put(settings.keyAt(i), pkg);
	}		}
	});		});
	SparseArray<SparseBooleanArray> cache =		WatchedSparseBooleanMatrix cache =
	updateEntireShouldFilterCacheInner(settingsCopy, usersRef[0]);		updateEntireShouldFilterCacheInner(settingsCopy, usersRef[0]);
	boolean[] changed = new boolean[1];		boolean[] changed = new boolean[1];
	// We have a cache, let's make sure the world hasn't changed out from under us.		// We have a cache, let's make sure the world hasn't changed out from under us.
	@@ -916,7 +920,7 @@ public class AppsFilter implements Watchable, Snappable {
	}		}
	}		}

	private void updateShouldFilterCacheForPackage(SparseArray<SparseBooleanArray> cache,		private void updateShouldFilterCacheForPackage(WatchedSparseBooleanMatrix cache,
	@Nullable String skipPackageName, PackageSetting subjectSetting, ArrayMap<String,		@Nullable String skipPackageName, PackageSetting subjectSetting, ArrayMap<String,
	PackageSetting> allSettings, UserInfo[] allUsers, int maxIndex) {		PackageSetting> allSettings, UserInfo[] allUsers, int maxIndex) {
	for (int i = Math.min(maxIndex, allSettings.size() - 1); i >= 0; i--) {		for (int i = Math.min(maxIndex, allSettings.size() - 1); i >= 0; i--) {
	@@ -935,17 +939,11 @@ public class AppsFilter implements Watchable, Snappable {
	for (int ou = 0; ou < userCount; ou++) {		for (int ou = 0; ou < userCount; ou++) {
	int otherUser = allUsers[ou].id;		int otherUser = allUsers[ou].id;
	int subjectUid = UserHandle.getUid(subjectUser, subjectSetting.appId);		int subjectUid = UserHandle.getUid(subjectUser, subjectSetting.appId);
	if (!cache.contains(subjectUid)) {
	cache.put(subjectUid, new SparseBooleanArray(appxUidCount));
	}
	int otherUid = UserHandle.getUid(otherUser, otherSetting.appId);		int otherUid = UserHandle.getUid(otherUser, otherSetting.appId);
	if (!cache.contains(otherUid)) {		cache.put(subjectUid, otherUid,
	cache.put(otherUid, new SparseBooleanArray(appxUidCount));
	}
	cache.get(subjectUid).put(otherUid,
	shouldFilterApplicationInternal(		shouldFilterApplicationInternal(
	subjectUid, subjectSetting, otherSetting, otherUser));		subjectUid, subjectSetting, otherSetting, otherUser));
	cache.get(otherUid).put(subjectUid,		cache.put(otherUid, subjectUid,
	shouldFilterApplicationInternal(		shouldFilterApplicationInternal(
	otherUid, otherSetting, subjectSetting, subjectUser));		otherUid, otherSetting, subjectSetting, subjectUser));
	}		}
	@@ -1198,22 +1196,20 @@ public class AppsFilter implements Watchable, Snappable {
	}		}
	synchronized (mCacheLock) {		synchronized (mCacheLock) {
	if (mShouldFilterCache != null) { // use cache		if (mShouldFilterCache != null) { // use cache
	SparseBooleanArray shouldFilterTargets = mShouldFilterCache.get(callingUid);		final int callingIndex = mShouldFilterCache.indexOfKey(callingUid);
	final int targetUid = UserHandle.getUid(userId, targetPkgSetting.appId);		if (callingIndex < 0) {
	if (shouldFilterTargets == null) {
	Slog.wtf(TAG, "Encountered calling uid with no cached rules: "		Slog.wtf(TAG, "Encountered calling uid with no cached rules: "
	+ callingUid);		+ callingUid);
	return true;		return true;
	}		}
	int indexOfTargetUid = shouldFilterTargets.indexOfKey(targetUid);		final int targetUid = UserHandle.getUid(userId, targetPkgSetting.appId);
	if (indexOfTargetUid < 0) {		final int targetIndex = mShouldFilterCache.indexOfKey(targetUid);
			if (targetIndex < 0) {
	Slog.w(TAG, "Encountered calling -> target with no cached rules: "		Slog.w(TAG, "Encountered calling -> target with no cached rules: "
	+ callingUid + " -> " + targetUid);		+ callingUid + " -> " + targetUid);
	return true;		return true;
	}		}
	if (!shouldFilterTargets.valueAt(indexOfTargetUid)) {		return mShouldFilterCache.valueAt(callingIndex, targetIndex);
	return false;
	}
	} else {		} else {
	if (!shouldFilterApplicationInternal(		if (!shouldFilterApplicationInternal(
	callingUid, callingSetting, targetPkgSetting, userId)) {		callingUid, callingSetting, targetPkgSetting, userId)) {

services/core/java/com/android/server/utils/WatchedSparseBooleanMatrix.java

0 → 100644

+562 −0

File added.

Preview size limit exceeded, changes collapsed.

services/tests/servicestests/src/com/android/server/utils/WatcherTest.java

+92 −1

Original line number	Original line	Diff line number	Diff line
	@@ -22,6 +22,7 @@ import static org.junit.Assert.fail;

	import android.util.ArrayMap;		import android.util.ArrayMap;
	import android.util.ArraySet;		import android.util.ArraySet;
			import android.util.Log;
	import android.util.LongSparseArray;		import android.util.LongSparseArray;
	import android.util.SparseArray;		import android.util.SparseArray;
	import android.util.SparseBooleanArray;		import android.util.SparseBooleanArray;
	@@ -34,9 +35,12 @@ import org.junit.Before;
	import org.junit.Test;		import org.junit.Test;

	import java.util.ArrayList;		import java.util.ArrayList;
			import java.util.Arrays;
			import java.util.Random;

	/**		/**
	* Test class for {@link Watcher}, {@link Watchable}, {@link WatchableImpl},		* Test class for various utility classes that support the Watchable or Snappable
			* features. This covers {@link Watcher}, {@link Watchable}, {@link WatchableImpl},
	* {@link WatchedArrayMap}, {@link WatchedSparseArray}, and		* {@link WatchedArrayMap}, {@link WatchedSparseArray}, and
	* {@link WatchedSparseBooleanArray}.		* {@link WatchedSparseBooleanArray}.
	*		*
	@@ -858,6 +862,93 @@ public class WatcherTest {
	}		}
	}		}

			private static class IndexGenerator {
			private final int mSeed;
			private final Random mRandom;
			public IndexGenerator(int seed) {
			mSeed = seed;
			mRandom = new Random(mSeed);
			}
			public int index() {
			return mRandom.nextInt(50000);
			}
			public void reset() {
			mRandom.setSeed(mSeed);
			}
			}

			// Return a value based on the row and column. The algorithm tries to avoid simple
			// patterns like checkerboard.
			private final boolean cellValue(int row, int col) {
			return (((row * 4 + col) % 3)& 1) == 1;
			}

			// This is an inefficient way to know if a value appears in an array.
			private final boolean contains(int[] s, int length, int k) {
			for (int i = 0; i < length; i++) {
			if (s[i] == k) {
			return true;
			}
			}
			return false;
			}

			private void matrixTest(WatchedSparseBooleanMatrix matrix, int size, IndexGenerator indexer) {
			indexer.reset();
			int[] indexes = new int[size];
			for (int i = 0; i < size; i++) {
			int key = indexer.index();
			// Ensure the list of indices are unique.
			while (contains(indexes, i, key)) {
			key = indexer.index();
			}
			indexes[i] = key;
			}
			// Set values in the matrix.
			for (int i = 0; i < size; i++) {
			int row = indexes[i];
			for (int j = 0; j < size; j++) {
			int col = indexes[j];
			boolean want = cellValue(i, j);
			matrix.put(row, col, want);
			}
			}

			assertEquals(matrix.size(), size);

			// Read back and verify
			for (int i = 0; i < matrix.size(); i++) {
			int row = indexes[i];
			for (int j = 0; j < matrix.size(); j++) {
			int col = indexes[j];
			boolean want = cellValue(i, j);
			boolean actual = matrix.get(row, col);
			String msg = String.format("matrix(%d:%d, %d:%d) == %s, expected %s",
			i, row, j, col, actual, want);
			assertEquals(msg, actual, want);
			}
			}

			// Test the keyAt/indexOfKey methods
			for (int i = 0; i < matrix.size(); i++) {
			int key = indexes[i];
			assertEquals(matrix.keyAt(matrix.indexOfKey(key)), key);
			}
			}

			@Test
			public void testWatchedSparseBooleanMatrix() {
			final String name = "WatchedSparseBooleanMatrix";

			// The first part of this method tests the core matrix functionality. The second
			// part tests the watchable behavior. The third part tests the snappable
			// behavior.
			IndexGenerator indexer = new IndexGenerator(3);
			matrixTest(new WatchedSparseBooleanMatrix(), 10, indexer);
			matrixTest(new WatchedSparseBooleanMatrix(1000), 500, indexer);
			matrixTest(new WatchedSparseBooleanMatrix(1000), 2000, indexer);
			}

	@Test		@Test
	public void testNestedArrays() {		public void testNestedArrays() {
	final String name = "NestedArrays";		final String name = "NestedArrays";