Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 930df69d authored by Eric Biggers's avatar Eric Biggers
Browse files

Remove unused CE storage lock events 

Remove ICeStorageLockEventListener and the StorageManagerInternal
methods related to it, since they are no longer used.  Their only user
was LockSettingsService, but now LockSettingsService#lockUser() just
incorporates the code that was previously in the callback.

Bug: 389069078
Flag: EXEMPT removing unused code
Test: atest StorageManagerServiceTest
Change-Id: If84b5928d5dea3c8ed42e82d6451fcaea8394f07
parent 90e7c178

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);

    }

}