Cache calls to getNotificationChannel*. (69da62bd) · Commits · e / os / android_frameworks_base

core/java/android/app/NotificationManager.java

+151 −19

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,7 @@
	package android.app;		package android.app;

	import static android.Manifest.permission.POST_NOTIFICATIONS;		import static android.Manifest.permission.POST_NOTIFICATIONS;
			import static android.app.NotificationChannel.DEFAULT_CHANNEL_ID;
	import static android.content.pm.PackageManager.PERMISSION_GRANTED;		import static android.content.pm.PackageManager.PERMISSION_GRANTED;
	import static android.service.notification.Flags.notificationClassification;		import static android.service.notification.Flags.notificationClassification;

	@@ -50,6 +51,7 @@ import android.os.Binder;
	import android.os.Build;		import android.os.Build;
	import android.os.Bundle;		import android.os.Bundle;
	import android.os.IBinder;		import android.os.IBinder;
			import android.os.IpcDataCache;
	import android.os.Parcel;		import android.os.Parcel;
	import android.os.Parcelable;		import android.os.Parcelable;
	import android.os.RemoteException;		import android.os.RemoteException;
	@@ -71,6 +73,8 @@ import android.util.LruCache;
	import android.util.Slog;		import android.util.Slog;
	import android.util.proto.ProtoOutputStream;		import android.util.proto.ProtoOutputStream;

			import com.android.internal.annotations.VisibleForTesting;

	import java.lang.annotation.Retention;		import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;		import java.lang.annotation.RetentionPolicy;
	import java.time.InstantSource;		import java.time.InstantSource;
	@@ -1202,6 +1206,13 @@ public class NotificationManager {
	* package (see {@link Context#createPackageContext(String, int)}).</p>		* package (see {@link Context#createPackageContext(String, int)}).</p>
	*/		*/
	public NotificationChannel getNotificationChannel(String channelId) {		public NotificationChannel getNotificationChannel(String channelId) {
			if (Flags.nmBinderPerfCacheChannels()) {
			return getChannelFromList(channelId,
			mNotificationChannelListCache.query(new NotificationChannelQuery(
			mContext.getOpPackageName(),
			mContext.getPackageName(),
			mContext.getUserId())));
			} else {
	INotificationManager service = service();		INotificationManager service = service();
	try {		try {
	return service.getNotificationChannel(mContext.getOpPackageName(),		return service.getNotificationChannel(mContext.getOpPackageName(),
	@@ -1210,6 +1221,7 @@ public class NotificationManager {
	throw e.rethrowFromSystemServer();		throw e.rethrowFromSystemServer();
	}		}
	}		}
			}

	/**		/**
	* Returns the notification channel settings for a given channel and		* Returns the notification channel settings for a given channel and
	@@ -1222,6 +1234,13 @@ public class NotificationManager {
	*/		*/
	public @Nullable NotificationChannel getNotificationChannel(@NonNull String channelId,		public @Nullable NotificationChannel getNotificationChannel(@NonNull String channelId,
	@NonNull String conversationId) {		@NonNull String conversationId) {
			if (Flags.nmBinderPerfCacheChannels()) {
			return getConversationChannelFromList(channelId, conversationId,
			mNotificationChannelListCache.query(new NotificationChannelQuery(
			mContext.getOpPackageName(),
			mContext.getPackageName(),
			mContext.getUserId())));
			} else {
	INotificationManager service = service();		INotificationManager service = service();
	try {		try {
	return service.getConversationNotificationChannel(mContext.getOpPackageName(),		return service.getConversationNotificationChannel(mContext.getOpPackageName(),
	@@ -1231,6 +1250,7 @@ public class NotificationManager {
	throw e.rethrowFromSystemServer();		throw e.rethrowFromSystemServer();
	}		}
	}		}
			}

	/**		/**
	* Returns all notification channels belonging to the calling package.		* Returns all notification channels belonging to the calling package.
	@@ -1241,6 +1261,12 @@ public class NotificationManager {
	* {@link Context#createPackageContext(String, int)}).</p>		* {@link Context#createPackageContext(String, int)}).</p>
	*/		*/
	public List<NotificationChannel> getNotificationChannels() {		public List<NotificationChannel> getNotificationChannels() {
			if (Flags.nmBinderPerfCacheChannels()) {
			return mNotificationChannelListCache.query(new NotificationChannelQuery(
			mContext.getOpPackageName(),
			mContext.getPackageName(),
			mContext.getUserId()));
			} else {
	INotificationManager service = service();		INotificationManager service = service();
	try {		try {
	return service.getNotificationChannels(mContext.getOpPackageName(),		return service.getNotificationChannels(mContext.getOpPackageName(),
	@@ -1249,6 +1275,47 @@ public class NotificationManager {
	throw e.rethrowFromSystemServer();		throw e.rethrowFromSystemServer();
	}		}
	}		}
			}

			// channel list assumed to be associated with the appropriate package & user id already.
			private static NotificationChannel getChannelFromList(String channelId,
			List<NotificationChannel> channels) {
			if (channels == null) {
			return null;
			}
			if (channelId == null) {
			channelId = DEFAULT_CHANNEL_ID;
			}
			for (NotificationChannel channel : channels) {
			if (channelId.equals(channel.getId())) {
			return channel;
			}
			}
			return null;
			}

			private static NotificationChannel getConversationChannelFromList(String channelId,
			String conversationId, List<NotificationChannel> channels) {
			if (channels == null) {
			return null;
			}
			if (channelId == null) {
			channelId = DEFAULT_CHANNEL_ID;
			}
			if (conversationId == null) {
			return getChannelFromList(channelId, channels);
			}
			NotificationChannel parent = null;
			for (NotificationChannel channel : channels) {
			if (conversationId.equals(channel.getConversationId())
			&& channelId.equals(channel.getParentChannelId())) {
			return channel;
			} else if (channelId.equals(channel.getId())) {
			parent = channel;
			}
			}
			return parent;
			}

	/**		/**
	* Deletes the given notification channel.		* Deletes the given notification channel.
	@@ -1328,6 +1395,71 @@ public class NotificationManager {
	}		}
	}		}

			private static final String NOTIFICATION_CHANNEL_CACHE_API = "getNotificationChannel";
			private static final String NOTIFICATION_CHANNEL_LIST_CACHE_NAME = "getNotificationChannels";
			private static final int NOTIFICATION_CHANNEL_CACHE_SIZE = 10;

			private final IpcDataCache.QueryHandler<NotificationChannelQuery, List<NotificationChannel>>
			mNotificationChannelListQueryHandler = new IpcDataCache.QueryHandler<>() {
			@Override
			public List<NotificationChannel> apply(NotificationChannelQuery query) {
			INotificationManager service = service();
			try {
			return service.getNotificationChannels(query.callingPkg,
			query.targetPkg, query.userId).getList();
			} catch (RemoteException e) {
			throw e.rethrowFromSystemServer();
			}
			}

			@Override
			public boolean shouldBypassCache(@NonNull NotificationChannelQuery query) {
			// Other locations should also not be querying the cache in the first place if
			// the flag is not enabled, but this is an extra precaution.
			if (!Flags.nmBinderPerfCacheChannels()) {
			Log.wtf(TAG,
			"shouldBypassCache called when nm_binder_perf_cache_channels off");
			return true;
			}
			return false;
			}
			};

			private final IpcDataCache<NotificationChannelQuery, List<NotificationChannel>>
			mNotificationChannelListCache =
			new IpcDataCache<>(NOTIFICATION_CHANNEL_CACHE_SIZE, IpcDataCache.MODULE_SYSTEM,
			NOTIFICATION_CHANNEL_CACHE_API, NOTIFICATION_CHANNEL_LIST_CACHE_NAME,
			mNotificationChannelListQueryHandler);

			private record NotificationChannelQuery(
			String callingPkg,
			String targetPkg,
			int userId) {}

			/**
			* @hide
			*/
			public static void invalidateNotificationChannelCache() {
			if (Flags.nmBinderPerfCacheChannels()) {
			IpcDataCache.invalidateCache(IpcDataCache.MODULE_SYSTEM,
			NOTIFICATION_CHANNEL_CACHE_API);
			} else {
			// if we are here, we have failed to flag something
			Log.wtf(TAG, "invalidateNotificationChannelCache called without flag");
			}
			}

			/**
			* For testing only: running tests with a cache requires marking the cache's property for
			* testing, as test APIs otherwise cannot invalidate the cache. This must be called after
			* calling PropertyInvalidatedCache.setTestMode(true).
			* @hide
			*/
			@VisibleForTesting
			public void setChannelCacheToTestMode() {
			mNotificationChannelListCache.testPropertyName();
			}

	/**		/**
	* @hide		* @hide
	*/		*/

core/tests/coretests/src/android/app/NotificationManagerTest.java

+212 −2

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

	package android.app;		package android.app;

			import static com.google.common.truth.Truth.assertThat;

	import static org.mockito.ArgumentMatchers.any;		import static org.mockito.ArgumentMatchers.any;
	import static org.mockito.ArgumentMatchers.anyInt;		import static org.mockito.ArgumentMatchers.anyInt;
	import static org.mockito.ArgumentMatchers.eq;		import static org.mockito.ArgumentMatchers.eq;
	@@ -25,16 +27,21 @@ import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.reset;		import static org.mockito.Mockito.reset;
	import static org.mockito.Mockito.times;		import static org.mockito.Mockito.times;
	import static org.mockito.Mockito.verify;		import static org.mockito.Mockito.verify;
			import static org.mockito.Mockito.when;

	import android.content.Context;		import android.content.Context;
			import android.content.pm.ParceledListSlice;
			import android.os.UserHandle;
	import android.platform.test.annotations.EnableFlags;		import android.platform.test.annotations.EnableFlags;
	import android.platform.test.annotations.Presubmit;		import android.platform.test.annotations.Presubmit;
	import android.platform.test.flag.junit.SetFlagsRule;		import android.platform.test.flag.junit.SetFlagsRule;
			import android.testing.TestableContext;

	import androidx.test.core.app.ApplicationProvider;		import androidx.test.core.app.ApplicationProvider;
	import androidx.test.ext.junit.runners.AndroidJUnit4;		import androidx.test.ext.junit.runners.AndroidJUnit4;
	import androidx.test.filters.SmallTest;		import androidx.test.filters.SmallTest;

			import org.junit.After;
	import org.junit.Before;		import org.junit.Before;
	import org.junit.Rule;		import org.junit.Rule;
	import org.junit.Test;		import org.junit.Test;
	@@ -42,6 +49,7 @@ import org.junit.runner.RunWith;

	import java.time.Instant;		import java.time.Instant;
	import java.time.InstantSource;		import java.time.InstantSource;
			import java.util.List;

	@RunWith(AndroidJUnit4.class)		@RunWith(AndroidJUnit4.class)
	@SmallTest		@SmallTest
	@@ -50,14 +58,25 @@ public class NotificationManagerTest {
	@Rule		@Rule
	public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();		public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();

	private Context mContext;
	private NotificationManagerWithMockService mNotificationManager;		private NotificationManagerWithMockService mNotificationManager;
	private final FakeClock mClock = new FakeClock();		private final FakeClock mClock = new FakeClock();

			@Rule
			public final PackageTestableContext mContext = new PackageTestableContext(
			ApplicationProvider.getApplicationContext());

	@Before		@Before
	public void setUp() {		public void setUp() {
	mContext = ApplicationProvider.getApplicationContext();
	mNotificationManager = new NotificationManagerWithMockService(mContext, mClock);		mNotificationManager = new NotificationManagerWithMockService(mContext, mClock);

			// Caches must be in test mode in order to be used in tests.
			PropertyInvalidatedCache.setTestMode(true);
			mNotificationManager.setChannelCacheToTestMode();
			}

			@After
			public void tearDown() {
			PropertyInvalidatedCache.setTestMode(false);
	}		}

	@Test		@Test
	@@ -243,12 +262,161 @@ public class NotificationManagerTest {
	anyInt(), any(), anyInt());		anyInt(), any(), anyInt());
	}		}

			@Test
			@EnableFlags(Flags.FLAG_NM_BINDER_PERF_CACHE_CHANNELS)
			public void getNotificationChannel_cachedUntilInvalidated() throws Exception {
			// Invalidate the cache first because the cache won't do anything until then
			NotificationManager.invalidateNotificationChannelCache();

			// It doesn't matter what the returned contents are, as long as we return a channel.
			// This setup must set up getNotificationChannels(), as that's the method called.
			when(mNotificationManager.mBackendService.getNotificationChannels(any(), any(),
			anyInt())).thenReturn(new ParceledListSlice<>(List.of(exampleChannel())));

			// ask for the same channel 100 times without invalidating the cache
			for (int i = 0; i < 100; i++) {
			NotificationChannel unused = mNotificationManager.getNotificationChannel("id");
			}

			// invalidate the cache; then ask again
			NotificationManager.invalidateNotificationChannelCache();
			NotificationChannel unused = mNotificationManager.getNotificationChannel("id");

			verify(mNotificationManager.mBackendService, times(2))
			.getNotificationChannels(any(), any(), anyInt());
			}

			@Test
			@EnableFlags(Flags.FLAG_NM_BINDER_PERF_CACHE_CHANNELS)
			public void getNotificationChannel_sameApp_oneCall() throws Exception {
			NotificationManager.invalidateNotificationChannelCache();

			NotificationChannel c1 = new NotificationChannel("id1", "name1",
			NotificationManager.IMPORTANCE_DEFAULT);
			NotificationChannel c2 = new NotificationChannel("id2", "name2",
			NotificationManager.IMPORTANCE_NONE);

			when(mNotificationManager.mBackendService.getNotificationChannels(any(), any(),
			anyInt())).thenReturn(new ParceledListSlice<>(List.of(c1, c2)));

			assertThat(mNotificationManager.getNotificationChannel("id1")).isEqualTo(c1);
			assertThat(mNotificationManager.getNotificationChannel("id2")).isEqualTo(c2);
			assertThat(mNotificationManager.getNotificationChannel("id3")).isNull();

			verify(mNotificationManager.mBackendService, times(1))
			.getNotificationChannels(any(), any(), anyInt());
			}

			@Test
			@EnableFlags(Flags.FLAG_NM_BINDER_PERF_CACHE_CHANNELS)
			public void getNotificationChannels_cachedUntilInvalidated() throws Exception {
			NotificationManager.invalidateNotificationChannelCache();
			when(mNotificationManager.mBackendService.getNotificationChannels(any(), any(),
			anyInt())).thenReturn(new ParceledListSlice<>(List.of(exampleChannel())));

			// ask for channels 100 times without invalidating the cache
			for (int i = 0; i < 100; i++) {
			List<NotificationChannel> unused = mNotificationManager.getNotificationChannels();
			}

			// invalidate the cache; then ask again
			NotificationManager.invalidateNotificationChannelCache();
			List<NotificationChannel> res = mNotificationManager.getNotificationChannels();

			verify(mNotificationManager.mBackendService, times(2))
			.getNotificationChannels(any(), any(), anyInt());
			assertThat(res).containsExactlyElementsIn(List.of(exampleChannel()));
			}

			@Test
			@EnableFlags(Flags.FLAG_NM_BINDER_PERF_CACHE_CHANNELS)
			public void getNotificationChannel_channelAndConversationLookup() throws Exception {
			NotificationManager.invalidateNotificationChannelCache();

			// Full list of channels: c1; conv1 = child of c1; c2 is unrelated
			NotificationChannel c1 = new NotificationChannel("id", "name",
			NotificationManager.IMPORTANCE_DEFAULT);
			NotificationChannel conv1 = new NotificationChannel("", "name_conversation",
			NotificationManager.IMPORTANCE_DEFAULT);
			conv1.setConversationId("id", "id_conversation");
			NotificationChannel c2 = new NotificationChannel("other", "name2",
			NotificationManager.IMPORTANCE_DEFAULT);

			when(mNotificationManager.mBackendService.getNotificationChannels(any(), any(), anyInt()))
			.thenReturn(new ParceledListSlice<>(List.of(c1, conv1, c2)));

			// Lookup for channel c1 and c2: returned as expected
			assertThat(mNotificationManager.getNotificationChannel("id")).isEqualTo(c1);
			assertThat(mNotificationManager.getNotificationChannel("other")).isEqualTo(c2);

			// Lookup for conv1 should return conv1
			assertThat(mNotificationManager.getNotificationChannel("id", "id_conversation")).isEqualTo(
			conv1);

			// Lookup for a different conversation channel that doesn't exist, whose parent channel id
			// is "id", should return c1
			assertThat(mNotificationManager.getNotificationChannel("id", "nonexistent")).isEqualTo(c1);

			// Lookup of a nonexistent channel is null
			assertThat(mNotificationManager.getNotificationChannel("id3")).isNull();

			// All of that should have been one call to getNotificationChannels()
			verify(mNotificationManager.mBackendService, times(1))
			.getNotificationChannels(any(), any(), anyInt());
			}

			@Test
			@EnableFlags(Flags.FLAG_NM_BINDER_PERF_CACHE_CHANNELS)
			public void getNotificationChannel_differentPackages() throws Exception {
			NotificationManager.invalidateNotificationChannelCache();
			final String pkg1 = "one";
			final String pkg2 = "two";
			final int userId = 0;
			final int userId1 = 1;

			// multiple channels with the same ID, but belonging to different packages/users
			NotificationChannel channel1 = new NotificationChannel("id", "name1",
			NotificationManager.IMPORTANCE_DEFAULT);
			NotificationChannel channel2 = channel1.copy();
			channel2.setName("name2");
			NotificationChannel channel3 = channel1.copy();
			channel3.setName("name3");

			when(mNotificationManager.mBackendService.getNotificationChannels(any(), eq(pkg1),
			eq(userId))).thenReturn(new ParceledListSlice<>(List.of(channel1)));
			when(mNotificationManager.mBackendService.getNotificationChannels(any(), eq(pkg2),
			eq(userId))).thenReturn(new ParceledListSlice<>(List.of(channel2)));
			when(mNotificationManager.mBackendService.getNotificationChannels(any(), eq(pkg1),
			eq(userId1))).thenReturn(new ParceledListSlice<>(List.of(channel3)));

			// set our context to pretend to be from package 1 and userId 0
			mContext.setParameters(pkg1, pkg1, userId);
			assertThat(mNotificationManager.getNotificationChannel("id")).isEqualTo(channel1);

			// now package 2
			mContext.setParameters(pkg2, pkg2, userId);
			assertThat(mNotificationManager.getNotificationChannel("id")).isEqualTo(channel2);

			// now pkg1 for a different user
			mContext.setParameters(pkg1, pkg1, userId1);
			assertThat(mNotificationManager.getNotificationChannel("id")).isEqualTo(channel3);

			// Those should have been three different calls
			verify(mNotificationManager.mBackendService, times(3))
			.getNotificationChannels(any(), any(), anyInt());
			}

	private Notification exampleNotification() {		private Notification exampleNotification() {
	return new Notification.Builder(mContext, "channel")		return new Notification.Builder(mContext, "channel")
	.setSmallIcon(android.R.drawable.star_big_on)		.setSmallIcon(android.R.drawable.star_big_on)
	.build();		.build();
	}		}

			private NotificationChannel exampleChannel() {
			return new NotificationChannel("id", "channel_name",
			NotificationManager.IMPORTANCE_DEFAULT);
			}

	private static class NotificationManagerWithMockService extends NotificationManager {		private static class NotificationManagerWithMockService extends NotificationManager {

	private final INotificationManager mBackendService;		private final INotificationManager mBackendService;
	@@ -264,6 +432,48 @@ public class NotificationManagerTest {
	}		}
	}		}

			// Helper TestableContext class where we can control just the return values of getPackageName,
			// getOpPackageName, and getUserId (used in getNotificationChannels).
			private static class PackageTestableContext extends TestableContext {
			private String mPackage;
			private String mOpPackage;
			private Integer mUserId;

			PackageTestableContext(Context base) {
			super(base);
			}

			void setParameters(String packageName, String opPackageName, int userId) {
			mPackage = packageName;
			mOpPackage = opPackageName;
			mUserId = userId;
			}

			@Override
			public String getPackageName() {
			if (mPackage != null) return mPackage;
			return super.getPackageName();
			}

			@Override
			public String getOpPackageName() {
			if (mOpPackage != null) return mOpPackage;
			return super.getOpPackageName();
			}

			@Override
			public int getUserId() {
			if (mUserId != null) return mUserId;
			return super.getUserId();
			}

			@Override
			public UserHandle getUser() {
			if (mUserId != null) return UserHandle.of(mUserId);
			return super.getUser();
			}
			}

	private static class FakeClock implements InstantSource {		private static class FakeClock implements InstantSource {

	private long mNowMillis = 441644400000L;		private long mNowMillis = 441644400000L;

services/core/java/com/android/server/notification/NotificationManagerService.java

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -3136,6 +3136,7 @@ public class NotificationManagerService extends SystemService {
	mAssistants.onBootPhaseAppsCanStart();		mAssistants.onBootPhaseAppsCanStart();
	mConditionProviders.onBootPhaseAppsCanStart();		mConditionProviders.onBootPhaseAppsCanStart();
	mHistoryManager.onBootPhaseAppsCanStart();		mHistoryManager.onBootPhaseAppsCanStart();
			mPreferencesHelper.onBootPhaseAppsCanStart();
	migrateDefaultNAS();		migrateDefaultNAS();
	maybeShowInitialReviewPermissionsNotification();		maybeShowInitialReviewPermissionsNotification();

services/core/java/com/android/server/notification/PreferencesHelper.java

+89 −4

File changed.

Preview size limit exceeded, changes collapsed.

services/tests/uiservicestests/src/com/android/server/notification/PreferencesHelperTest.java

+237 −16

File changed.

Preview size limit exceeded, changes collapsed.