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

Commit 78fd9db1 authored by Kevin Han's avatar Kevin Han
Browse files

Add basic hibernation state management 

Add per-user hibernation state management to AppHibernationService. This
implements the basic set/get logic for AppHibernationService and ensures
user packages are kept up to date.

Bug: 175829330
Test: atest AppHibernationServiceTest
Change-Id: Ief6690bb468cdf87bc1a700f9b8eef5c76f26d70
parent 63576ff7

services/core/java/com/android/server/apphibernation/AppHibernationService.java

+230 −4
Original line number Diff line number Diff line
@@ -16,23 +16,60 @@ 


package com.android.server.apphibernation;



import static android.content.Intent.ACTION_PACKAGE_ADDED;

import static android.content.Intent.ACTION_PACKAGE_REMOVED;

import static android.content.Intent.ACTION_USER_ADDED;

import static android.content.Intent.ACTION_USER_REMOVED;

import static android.content.Intent.EXTRA_REPLACING;

import static android.content.pm.PackageManager.MATCH_ALL;

import static android.provider.DeviceConfig.NAMESPACE_APP_HIBERNATION;



import android.annotation.NonNull;

import android.app.ActivityManager;

import android.app.IActivityManager;

import android.apphibernation.IAppHibernationService;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.content.pm.IPackageManager;

import android.content.pm.PackageInfo;

import android.content.pm.UserInfo;

import android.os.Binder;

import android.os.RemoteException;

import android.os.ServiceManager;

import android.os.Trace;

import android.os.UserHandle;

import android.os.UserManager;

import android.provider.DeviceConfig;

import android.util.ArrayMap;

import android.util.SparseArray;



import com.android.internal.annotations.GuardedBy;

import com.android.internal.annotations.VisibleForTesting;

import com.android.server.SystemService;



import java.util.List;

import java.util.Map;



/**

 * System service that manages app hibernation state, a state apps can enter that means they are

 * not being actively used and can be optimized for storage. The actual policy for determining

 * if an app should hibernate is managed by PermissionController code.

 */

public final class AppHibernationService extends SystemService {

    private static final String TAG = "AppHibernationService";



    /**

     * Lock for accessing any in-memory hibernation state

     */

    private final Object mLock = new Object();

    private final Context mContext;

    private final IPackageManager mIPackageManager;

    private final IActivityManager mIActivityManager;

    private final UserManager mUserManager;

    @GuardedBy("mLock")

    private final SparseArray<Map<String, UserPackageState>> mUserStates = new SparseArray<>();



    /**

     * Initializes the system service.
@@ -44,8 +81,32 @@ public final class AppHibernationService extends SystemService { 
     * @param context The system server context.

     */

    public AppHibernationService(@NonNull Context context) {

        this(context, IPackageManager.Stub.asInterface(ServiceManager.getService("package")),

                ActivityManager.getService(),

                context.getSystemService(UserManager.class));

    }



    @VisibleForTesting

    AppHibernationService(@NonNull Context context, IPackageManager packageManager,

            IActivityManager activityManager, UserManager userManager) {

        super(context);

        mContext = context;

        mIPackageManager = packageManager;

        mIActivityManager = activityManager;

        mUserManager = userManager;



        final Context userAllContext = mContext.createContextAsUser(UserHandle.ALL, 0 /* flags */);



        IntentFilter intentFilter = new IntentFilter();

        intentFilter.addAction(ACTION_USER_ADDED);

        intentFilter.addAction(ACTION_USER_REMOVED);

        userAllContext.registerReceiver(mBroadcastReceiver, intentFilter);



        intentFilter = new IntentFilter();

        intentFilter.addAction(ACTION_PACKAGE_ADDED);

        intentFilter.addAction(ACTION_PACKAGE_REMOVED);

        intentFilter.addDataScheme("package");

        userAllContext.registerReceiver(mBroadcastReceiver, intentFilter);

    }



    @Override
@@ -53,6 +114,19 @@ public final class AppHibernationService extends SystemService { 
        publishBinderService(Context.APP_HIBERNATION_SERVICE, mServiceStub);

    }



    @Override

    public void onBootPhase(int phase) {

        if (phase == PHASE_BOOT_COMPLETED) {

            synchronized (mLock) {

                final List<UserInfo> users = mUserManager.getUsers();

                // TODO: Pull from persistent disk storage. For now, just make from scratch.

                for (UserInfo user : users) {

                    addUserPackageStatesL(user.id);

                }

            }

        }

    }



    /**

     * Whether a package is hibernating for a given user.

     *
@@ -61,8 +135,20 @@ public final class AppHibernationService extends SystemService { 
     * @return true if package is hibernating for the user

     */

    public boolean isHibernating(String packageName, int userId) {

        // Stub

        throw new UnsupportedOperationException("Hibernation state management not implemented yet");

        userId = handleIncomingUser(userId, "isHibernating");

        synchronized (mLock) {

            final Map<String, UserPackageState> packageStates = mUserStates.get(userId);

            if (packageStates == null) {

                throw new IllegalArgumentException("No user associated with user id " + userId);

            }

            final UserPackageState pkgState = packageStates.get(packageName);

            if (pkgState == null) {

                throw new IllegalArgumentException(

                        String.format("Package %s is not installed for user %s",

                                packageName, userId));

            }

            return pkgState != null ? pkgState.hibernated : null;

        }

    }



    /**
@@ -73,8 +159,108 @@ public final class AppHibernationService extends SystemService { 
     * @param isHibernating new hibernation state

     */

    public void setHibernating(String packageName, int userId, boolean isHibernating) {

        // Stub

        throw new UnsupportedOperationException("Hibernation state management not implemented yet");

        userId = handleIncomingUser(userId, "setHibernating");

        synchronized (mLock) {

            if (!mUserStates.contains(userId)) {

                throw new IllegalArgumentException("No user associated with user id " + userId);

            }

            Map<String, UserPackageState> packageStates = mUserStates.get(userId);

            UserPackageState pkgState = packageStates.get(packageName);

            if (pkgState == null) {

                throw new IllegalArgumentException(

                        String.format("Package %s is not installed for user %s",

                                packageName, userId));

            }



            if (pkgState.hibernated == isHibernating) {

                return;

            }





            final long caller = Binder.clearCallingIdentity();

            try {

                if (isHibernating) {

                    Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "hibernatePackage");

                    mIActivityManager.forceStopPackage(packageName, userId);

                    mIPackageManager.deleteApplicationCacheFilesAsUser(packageName, userId,

                            null /* observer */);

                } else {

                    Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "unhibernatePackage");

                    mIPackageManager.setPackageStoppedState(packageName, false, userId);

                }

                pkgState.hibernated = isHibernating;

            } catch (RemoteException e) {

                throw new IllegalStateException(

                        "Failed to hibernate due to manager not being available", e);

            } finally {

                Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

                Binder.restoreCallingIdentity(caller);

            }



            // TODO: Support package level hibernation when package is hibernating for all users

        }

    }



    /**

     * Populates {@link #mUserStates} with the users installed packages. The caller should hold

     * {@link #mLock}.

     *

     * @param userId user id to add installed packages for

     */

    private void addUserPackageStatesL(int userId) {

        Map<String, UserPackageState> packages = new ArrayMap<>();

        List<PackageInfo> packageList;

        try {

            packageList = mIPackageManager.getInstalledPackages(MATCH_ALL, userId).getList();

        } catch (RemoteException e) {

            throw new IllegalStateException("Package manager not available.", e);

        }



        for (PackageInfo pkg : packageList) {

            packages.put(pkg.packageName, new UserPackageState());

        }

        mUserStates.put(userId, packages);

    }



    private void onUserAdded(int userId) {

        synchronized (mLock) {

            addUserPackageStatesL(userId);

        }

    }



    private void onUserRemoved(int userId) {

        synchronized (mLock) {

            mUserStates.remove(userId);

        }

    }



    private void onPackageAdded(@NonNull String packageName, int userId) {

        synchronized (mLock) {

            mUserStates.get(userId).put(packageName, new UserPackageState());

        }

    }



    private void onPackageRemoved(@NonNull String packageName, int userId) {

        synchronized (mLock) {

            mUserStates.get(userId).remove(packageName);

        }

    }



    /**

     * Private helper method to get the real user id and enforce permission checks.

     *

     * @param userId user id to handle

     * @param name name to use for exceptions

     * @return real user id

     */

    private int handleIncomingUser(int userId, @NonNull String name) {

        int callingUid = Binder.getCallingUid();

        try {

            return mIActivityManager.handleIncomingUser(Binder.getCallingPid(), callingUid, userId,

                    false /* allowAll */, true /* requireFull */, name, null);

        } catch (RemoteException re) {

            throw re.rethrowFromSystemServer();

        }

    }



    private final AppHibernationServiceStub mServiceStub = new AppHibernationServiceStub(this);
@@ -97,6 +283,38 @@ public final class AppHibernationService extends SystemService { 
        }

    }



    // Broadcast receiver for user and package add/removal events

    private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {

        @Override

        public void onReceive(Context context, Intent intent) {

            final int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);

            if (userId == UserHandle.USER_NULL) {

                return;

            }



            final String action = intent.getAction();

            if (ACTION_USER_ADDED.equals(action)) {

                onUserAdded(userId);

            }

            if (ACTION_USER_REMOVED.equals(action)) {

                onUserRemoved(userId);

            }

            if (ACTION_PACKAGE_ADDED.equals(action) || ACTION_PACKAGE_REMOVED.equals(action)) {

                final String packageName = intent.getData().getSchemeSpecificPart();

                if (intent.getBooleanExtra(EXTRA_REPLACING, false)) {

                    // Package removal/add is part of an update, so no need to modify package state.

                    return;

                }



                if (ACTION_PACKAGE_ADDED.equals(action)) {

                    onPackageAdded(packageName, userId);

                } else if (ACTION_PACKAGE_REMOVED.equals(action)) {

                    onPackageRemoved(packageName, userId);

                }

            }

        }

    };



    /**

     * Whether app hibernation is enabled on this device.

     *
@@ -108,4 +326,12 @@ public final class AppHibernationService extends SystemService { 
                AppHibernationConstants.KEY_APP_HIBERNATION_ENABLED,

                false /* defaultValue */);

    }



    /**

     * Data class that contains hibernation state info of a package for a user.

     */

    private static final class UserPackageState {

        public boolean hibernated;

        // TODO: Track whether hibernation is exempted by the user

    }

}

services/tests/servicestests/src/com/android/server/apphibernation/AppHibernationServiceTest.java

0 → 100644
+168 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 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.apphibernation;



import static org.junit.Assert.assertTrue;

import static org.mockito.AdditionalAnswers.returnsArgAt;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.anyBoolean;

import static org.mockito.ArgumentMatchers.anyInt;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.verify;

import static org.mockito.internal.verification.VerificationModeFactory.times;



import android.app.IActivityManager;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.pm.IPackageManager;

import android.content.pm.PackageInfo;

import android.content.pm.ParceledListSlice;

import android.content.pm.UserInfo;

import android.net.Uri;

import android.os.RemoteException;

import android.os.UserManager;



import androidx.test.filters.SmallTest;



import com.android.server.SystemService;



import org.junit.Before;

import org.junit.Test;

import org.mockito.ArgumentCaptor;

import org.mockito.Captor;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;



import java.util.ArrayList;

import java.util.List;



/**

 * Tests for {@link com.android.server.apphibernation.AppHibernationService}

 */

@SmallTest

public final class AppHibernationServiceTest {

    private static final String PACKAGE_SCHEME = "package";

    private static final String PACKAGE_NAME_1 = "package1";

    private static final String PACKAGE_NAME_2 = "package2";

    private static final int USER_ID_1 = 1;

    private static final int USER_ID_2 = 2;



    private AppHibernationService mAppHibernationService;

    private BroadcastReceiver mBroadcastReceiver;

    @Mock

    private Context mContext;

    @Mock

    private IPackageManager mIPackageManager;

    @Mock

    private IActivityManager mIActivityManager;

    @Mock

    private UserManager mUserManager;

    @Captor

    private ArgumentCaptor<BroadcastReceiver> mReceiverCaptor;



    @Before

    public void setUp() throws RemoteException {

        MockitoAnnotations.initMocks(this);

        doReturn(mContext).when(mContext).createContextAsUser(any(), anyInt());



        mAppHibernationService = new AppHibernationService(mContext, mIPackageManager,

                mIActivityManager, mUserManager);



        verify(mContext, times(2)).registerReceiver(mReceiverCaptor.capture(), any());

        mBroadcastReceiver = mReceiverCaptor.getValue();



        List<UserInfo> userList = new ArrayList<>();

        userList.add(new UserInfo(USER_ID_1, "user 1", 0 /* flags */));

        doReturn(userList).when(mUserManager).getUsers();



        List<PackageInfo> userPackages = new ArrayList<>();

        userPackages.add(makePackageInfo(PACKAGE_NAME_1));



        doReturn(new ParceledListSlice<>(userPackages)).when(mIPackageManager)

                .getInstalledPackages(anyInt(), eq(USER_ID_1));



        doAnswer(returnsArgAt(2)).when(mIActivityManager).handleIncomingUser(anyInt(), anyInt(),

                anyInt(), anyBoolean(), anyBoolean(), any(), any());



        mAppHibernationService.onBootPhase(SystemService.PHASE_BOOT_COMPLETED);

    }



    @Test

    public void testSetHibernating_packageIsHibernating() {

        // WHEN we hibernate a package for a user

        mAppHibernationService.setHibernating(PACKAGE_NAME_1, USER_ID_1, true);



        // THEN the package is marked hibernating for the user

        assertTrue(mAppHibernationService.isHibernating(PACKAGE_NAME_1, USER_ID_1));

    }



    @Test

    public void testSetHibernating_newPackageAdded_packageIsHibernating() {

        // WHEN a new package is added and it is hibernated

        Intent intent = new Intent(Intent.ACTION_PACKAGE_ADDED,

                Uri.fromParts(PACKAGE_SCHEME, PACKAGE_NAME_2, null /* fragment */));

        intent.putExtra(Intent.EXTRA_USER_HANDLE, USER_ID_1);

        mBroadcastReceiver.onReceive(mContext, intent);



        mAppHibernationService.setHibernating(PACKAGE_NAME_2, USER_ID_1, true);



        // THEN the new package is hibernated

        assertTrue(mAppHibernationService.isHibernating(PACKAGE_NAME_2, USER_ID_1));

    }



    @Test

    public void testSetHibernating_newUserAdded_packageIsHibernating() throws RemoteException {

        // WHEN a new user is added and a package from the user is hibernated

        List<PackageInfo> userPackages = new ArrayList<>();

        userPackages.add(makePackageInfo(PACKAGE_NAME_1));

        doReturn(new ParceledListSlice<>(userPackages)).when(mIPackageManager)

                .getInstalledPackages(anyInt(), eq(USER_ID_2));

        Intent intent = new Intent(Intent.ACTION_USER_ADDED);

        intent.putExtra(Intent.EXTRA_USER_HANDLE, USER_ID_2);

        mBroadcastReceiver.onReceive(mContext, intent);



        mAppHibernationService.setHibernating(PACKAGE_NAME_1, USER_ID_2, true);



        // THEN the new user's package is hibernated

        assertTrue(mAppHibernationService.isHibernating(PACKAGE_NAME_1, USER_ID_2));

    }



    @Test

    public void testIsHibernating_packageReplaced_stillReturnsHibernating() {

        // GIVEN a package is currently hibernated

        mAppHibernationService.setHibernating(PACKAGE_NAME_1, USER_ID_1, true);



        // WHEN the package is removed but marked as replacing

        Intent intent = new Intent(Intent.ACTION_PACKAGE_REMOVED,

                Uri.fromParts(PACKAGE_SCHEME, PACKAGE_NAME_2, null /* fragment */));

        intent.putExtra(Intent.EXTRA_USER_HANDLE, USER_ID_1);

        intent.putExtra(Intent.EXTRA_REPLACING, true);

        mBroadcastReceiver.onReceive(mContext, intent);



        // THEN the package is still hibernating

        assertTrue(mAppHibernationService.isHibernating(PACKAGE_NAME_1, USER_ID_1));

    }



    private static PackageInfo makePackageInfo(String packageName) {

        PackageInfo pkg = new PackageInfo();

        pkg.packageName = packageName;

        return pkg;

    }

}