Merge "Remove unused CE storage lock events" into main (fcab278f) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/ICeStorageLockEventListener.java

deleted100644 → 0

+0 −28

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.server;

		/**
		* Callback class for receiving CE storage lock events from StorageManagerService.
		*/
		public interface ICeStorageLockEventListener {

		/**
		* Called when the CE storage corresponding to the userId is locked
		*/
		void onStorageLocked(int userId);
		}

services/core/java/com/android/server/StorageManagerInternal.java

+0 −16

Original line number	Diff line number	Diff line
		@@ -16,12 +16,10 @@

		package com.android.server;

		import android.annotation.FlaggedApi;
		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.annotation.UserIdInt;
		import android.content.pm.UserInfo;
		import android.multiuser.Flags;
		import android.os.IInstalld;
		import android.os.IVold;
		import android.os.ParcelFileDescriptor;
		@@ -201,18 +199,4 @@ public abstract class StorageManagerInternal {
		*/
		public abstract int enableFsverity(IInstalld.IFsveritySetupAuthToken authToken, String filePath,
		String packageName) throws IOException;

		/**
		* Registers a {@link ICeStorageLockEventListener} for receiving CE storage lock events.
		*/
		@FlaggedApi(Flags.FLAG_ENABLE_BIOMETRICS_TO_UNLOCK_PRIVATE_SPACE)
		public abstract void registerStorageLockEventListener(
		@NonNull ICeStorageLockEventListener listener);

		/**
		* Unregisters the {@link ICeStorageLockEventListener} which was registered previously
		*/
		@FlaggedApi(Flags.FLAG_ENABLE_BIOMETRICS_TO_UNLOCK_PRIVATE_SPACE)
		public abstract void unregisterStorageLockEventListener(
		@NonNull ICeStorageLockEventListener listener);
		}

services/core/java/com/android/server/StorageManagerService.java

+0 −40

Original line number	Diff line number	Diff line
		@@ -193,7 +193,6 @@ import java.util.Map.Entry;
		import java.util.Objects;
		import java.util.Set;
		import java.util.UUID;
		import java.util.concurrent.CopyOnWriteArrayList;
		import java.util.concurrent.CopyOnWriteArraySet;
		import java.util.concurrent.CountDownLatch;
		import java.util.concurrent.TimeUnit;
		@@ -621,10 +620,6 @@ class StorageManagerService extends IStorageManager.Stub
		// Not guarded by lock, always used on the ActivityManager thread
		private final SparseArray<PackageMonitor> mPackageMonitorsForUser = new SparseArray<>();

		/** List of listeners registered for ce storage callbacks */
		private final CopyOnWriteArrayList<ICeStorageLockEventListener>
		mCeStorageEventCallbacks = new CopyOnWriteArrayList<>();

		class ObbState implements IBinder.DeathRecipient {
		public ObbState(String rawPath, String canonicalPath, int callingUid,
		IObbActionListener token, int nonce, String volId) {
		@@ -3412,11 +3407,6 @@ class StorageManagerService extends IStorageManager.Stub
		synchronized (mLock) {
		mCeUnlockedUsers.remove(userId);
		}
		if (android.os.Flags.allowPrivateProfile()
		&& android.multiuser.Flags.enablePrivateSpaceFeatures()
		&& android.multiuser.Flags.enableBiometricsToUnlockPrivateSpace()) {
		dispatchCeStorageLockedEvent(userId);
		}
		}

		@Override
		@@ -4689,18 +4679,6 @@ class StorageManagerService extends IStorageManager.Stub
		return StorageManager.MOUNT_MODE_EXTERNAL_NONE;
		}

		@VisibleForTesting
		CopyOnWriteArrayList<ICeStorageLockEventListener> getCeStorageEventCallbacks() {
		return mCeStorageEventCallbacks;
		}

		@VisibleForTesting
		void dispatchCeStorageLockedEvent(int userId) {
		for (ICeStorageLockEventListener listener: mCeStorageEventCallbacks) {
		listener.onStorageLocked(userId);
		}
		}

		private static class Callbacks extends Handler {
		private static final int MSG_STORAGE_STATE_CHANGED = 1;
		private static final int MSG_VOLUME_STATE_CHANGED = 2;
		@@ -5188,23 +5166,5 @@ class StorageManagerService extends IStorageManager.Stub
		throw new IOException(e);
		}
		}

		@Override
		public void registerStorageLockEventListener(
		@NonNull ICeStorageLockEventListener listener) {
		boolean registered = mCeStorageEventCallbacks.add(listener);
		if (!registered) {
		Slog.w(TAG, "Failed to register listener: " + listener);
		}
		}

		@Override
		public void unregisterStorageLockEventListener(
		@NonNull ICeStorageLockEventListener listener) {
		boolean unregistered = mCeStorageEventCallbacks.remove(listener);
		if (!unregistered) {
		Slog.w(TAG, "Unregistering " + listener + " that was not registered");
		}
		}
		}
		}

services/tests/mockingservicestests/src/com/android/server/StorageManagerServiceTest.java

+0 −74

Original line number	Diff line number	Diff line
		@@ -16,28 +16,21 @@

		package com.android.server;


		import static com.android.dx.mockito.inline.extended.ExtendedMockito.doNothing;
		import static com.android.dx.mockito.inline.extended.ExtendedMockito.verify;

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

		import static org.junit.Assert.assertThrows;
		import static org.mockito.ArgumentMatchers.eq;
		import static org.mockito.Mockito.doNothing;
		import static org.mockito.Mockito.doReturn;
		import static org.mockito.Mockito.spy;
		import static org.mockito.Mockito.verify;
		import static org.mockito.Mockito.when;

		import android.app.PropertyInvalidatedCache;
		import android.content.Context;
		import android.multiuser.Flags;
		import android.os.UserManager;
		import android.os.storage.DiskInfo;
		import android.os.storage.VolumeInfo;
		import android.platform.test.flag.junit.SetFlagsRule;

		import com.android.modules.utils.testing.ExtendedMockitoRule;
		import com.android.server.storage.WatchedVolumeInfo;
		@@ -47,8 +40,6 @@ import org.junit.Before;
		import org.junit.Rule;
		import org.junit.Test;

		import java.util.concurrent.CopyOnWriteArrayList;

		public class StorageManagerServiceTest {

		private final Context mRealContext = androidx.test.platform.app.InstrumentationRegistry
		@@ -64,23 +55,6 @@ public class StorageManagerServiceTest {
		public final ExtendedMockitoRule mExtendedMockitoRule = new ExtendedMockitoRule.Builder(this)
		.spyStatic(UserManager.class)
		.build();
		@Rule
		public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();

		private static class TestStorageEventListener implements ICeStorageLockEventListener {

		private int mExpectedUserId;

		private TestStorageEventListener(int userId) {
		mExpectedUserId = userId;
		}

		@Override
		public void onStorageLocked(int userId) {
		assertThat(userId).isEqualTo(mExpectedUserId);
		}
		}


		@Before
		public void setFixtures() {
		@@ -101,48 +75,6 @@ public class StorageManagerServiceTest {
		LocalServices.removeServiceForTest(StorageManagerInternal.class);
		}

		@Test
		public void testRegisterLockEventListener() {
		mSetFlagsRule.enableFlags(android.os.Flags.FLAG_ALLOW_PRIVATE_PROFILE,
		Flags.FLAG_ENABLE_BIOMETRICS_TO_UNLOCK_PRIVATE_SPACE,
		Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
		mSetFlagsRule.enableFlags(Flags.FLAG_ENABLE_BIOMETRICS_TO_UNLOCK_PRIVATE_SPACE);
		CopyOnWriteArrayList<ICeStorageLockEventListener> storageLockEventListeners =
		mStorageManagerService.getCeStorageEventCallbacks();
		assertThat(storageLockEventListeners).isNotNull();
		int registeredCallbackCount = storageLockEventListeners.size();
		TestStorageEventListener testStorageEventListener =
		new TestStorageEventListener(TEST_USER_ID);
		mStorageManagerInternal.registerStorageLockEventListener(testStorageEventListener);
		assertNumberOfStorageCallbackReceivers(registeredCallbackCount + 1);

		mStorageManagerInternal.unregisterStorageLockEventListener(testStorageEventListener);
		assertNumberOfStorageCallbackReceivers(registeredCallbackCount);
		}

		@Test
		public void testDispatchCeStorageLockEvent() {
		mSetFlagsRule.enableFlags(android.os.Flags.FLAG_ALLOW_PRIVATE_PROFILE,
		Flags.FLAG_ENABLE_BIOMETRICS_TO_UNLOCK_PRIVATE_SPACE,
		Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);

		assertThat(mStorageManagerService.getCeStorageEventCallbacks()).isNotNull();
		int callbackReceiverSize = mStorageManagerService.getCeStorageEventCallbacks().size();
		TestStorageEventListener testStorageEventListener =
		spy(new TestStorageEventListener(TEST_USER_ID));

		// Add testStorageEventListener to the list of storage callback listeners
		mStorageManagerService.getCeStorageEventCallbacks().add(testStorageEventListener);
		assertNumberOfStorageCallbackReceivers(callbackReceiverSize + 1);

		mStorageManagerService.dispatchCeStorageLockedEvent(TEST_USER_ID);
		verify(testStorageEventListener).onStorageLocked(eq(TEST_USER_ID));

		// Remove testStorageEventListener from the list of storage callback listeners
		mStorageManagerService.getCeStorageEventCallbacks().remove(testStorageEventListener);
		assertNumberOfStorageCallbackReceivers(callbackReceiverSize);
		}

		@Test
		public void testMountWithRestrictionFailure() {
		DiskInfo diskInfo = new DiskInfo("diskInfoId", DiskInfo.FLAG_USB);
		@@ -182,10 +114,4 @@ public class StorageManagerServiceTest {

		mStorageManagerService.mount(watchedVolumeInfo.getId());
		}

		private void assertNumberOfStorageCallbackReceivers(int callbackReceiverSize) {
		assertThat(mStorageManagerService.getCeStorageEventCallbacks()).isNotNull();
		assertThat(mStorageManagerService.getCeStorageEventCallbacks().size())
		.isEqualTo(callbackReceiverSize);
		}
		}