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

Commit e1055125 authored by Tony Mantler's avatar Tony Mantler Committed by Android (Google) Code Review
Browse files

Merge changes from topics "tv-settings-manage-power", "applicationsstate-lifecycle" 

* changes:
  Move PowerWhitelistBackend to SettingsLib
  Move ApplicationsState to support lib Lifecycle
parents 53b2d749 70676c1c

packages/SettingsLib/src/com/android/settingslib/applications/ApplicationsState.java

+7 −6
Original line number Diff line number Diff line
@@ -21,6 +21,9 @@ import android.app.AppGlobals; 
import android.app.Application;

import android.app.usage.StorageStats;

import android.app.usage.StorageStatsManager;

import android.arch.lifecycle.Lifecycle;

import android.arch.lifecycle.LifecycleObserver;

import android.arch.lifecycle.OnLifecycleEvent;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;
@@ -52,11 +55,6 @@ import android.util.SparseArray; 


import com.android.internal.R;

import com.android.internal.util.ArrayUtils;

import com.android.settingslib.core.lifecycle.Lifecycle;

import com.android.settingslib.core.lifecycle.LifecycleObserver;

import com.android.settingslib.core.lifecycle.events.OnDestroy;

import com.android.settingslib.core.lifecycle.events.OnPause;

import com.android.settingslib.core.lifecycle.events.OnResume;



import java.io.File;

import java.io.IOException;
@@ -595,7 +593,7 @@ public class ApplicationsState { 
                .replaceAll("").toLowerCase();

    }



    public class Session implements LifecycleObserver, OnPause, OnResume, OnDestroy {

    public class Session implements LifecycleObserver {

        final Callbacks mCallbacks;

        boolean mResumed;
@@ -621,6 +619,7 @@ public class ApplicationsState { 
            }

        }



        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)

        public void onResume() {

            if (DEBUG_LOCKING) Log.v(TAG, "resume about to acquire lock...");

            synchronized (mEntriesMap) {
@@ -633,6 +632,7 @@ public class ApplicationsState { 
            if (DEBUG_LOCKING) Log.v(TAG, "...resume releasing lock");

        }



        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)

        public void onPause() {

            if (DEBUG_LOCKING) Log.v(TAG, "pause about to acquire lock...");

            synchronized (mEntriesMap) {
@@ -752,6 +752,7 @@ public class ApplicationsState { 
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

        }



        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)

        public void onDestroy() {

            if (!mHasLifecycle) {

                // TODO: Legacy, remove this later once all usages are switched to Lifecycle

packages/SettingsLib/src/com/android/settingslib/fuelgauge/PowerWhitelistBackend.java

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

 * Copyright (C) 2017 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.settingslib.fuelgauge;



import android.os.IDeviceIdleController;

import android.os.RemoteException;

import android.os.ServiceManager;

import android.support.annotation.VisibleForTesting;

import android.util.ArraySet;

import android.util.Log;



/**

 * Handles getting/changing the whitelist for the exceptions to battery saving features.

 */

public class PowerWhitelistBackend {



    private static final String TAG = "PowerWhitelistBackend";



    private static final String DEVICE_IDLE_SERVICE = "deviceidle";



    private static PowerWhitelistBackend sInstance;



    private final IDeviceIdleController mDeviceIdleService;

    private final ArraySet<String> mWhitelistedApps = new ArraySet<>();

    private final ArraySet<String> mSysWhitelistedApps = new ArraySet<>();



    public PowerWhitelistBackend() {

        mDeviceIdleService = IDeviceIdleController.Stub.asInterface(

                ServiceManager.getService(DEVICE_IDLE_SERVICE));

        refreshList();

    }



    @VisibleForTesting

    PowerWhitelistBackend(IDeviceIdleController deviceIdleService) {

        mDeviceIdleService = deviceIdleService;

        refreshList();

    }



    public int getWhitelistSize() {

        return mWhitelistedApps.size();

    }



    public boolean isSysWhitelisted(String pkg) {

        return mSysWhitelistedApps.contains(pkg);

    }



    public boolean isWhitelisted(String pkg) {

        return mWhitelistedApps.contains(pkg);

    }



    public void addApp(String pkg) {

        try {

            mDeviceIdleService.addPowerSaveWhitelistApp(pkg);

            mWhitelistedApps.add(pkg);

        } catch (RemoteException e) {

            Log.w(TAG, "Unable to reach IDeviceIdleController", e);

        }

    }



    public void removeApp(String pkg) {

        try {

            mDeviceIdleService.removePowerSaveWhitelistApp(pkg);

            mWhitelistedApps.remove(pkg);

        } catch (RemoteException e) {

            Log.w(TAG, "Unable to reach IDeviceIdleController", e);

        }

    }



    @VisibleForTesting

    public void refreshList() {

        mSysWhitelistedApps.clear();

        mWhitelistedApps.clear();

        try {

            String[] whitelistedApps = mDeviceIdleService.getFullPowerWhitelist();

            for (String app : whitelistedApps) {

                mWhitelistedApps.add(app);

            }

            String[] sysWhitelistedApps = mDeviceIdleService.getSystemPowerWhitelist();

            for (String app : sysWhitelistedApps) {

                mSysWhitelistedApps.add(app);

            }

        } catch (RemoteException e) {

            Log.w(TAG, "Unable to reach IDeviceIdleController", e);

        }

    }



    public static PowerWhitelistBackend getInstance() {

        if (sInstance == null) {

            sInstance = new PowerWhitelistBackend();

        }

        return sInstance;

    }



}

packages/SettingsLib/tests/robotests/src/com/android/settingslib/fuelgauge/PowerWhitelistBackendTest.java

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

 * Copyright (C) 2017 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.settingslib.fuelgauge;



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



import static org.mockito.ArgumentMatchers.anyString;

import static org.mockito.Mockito.atLeastOnce;

import static org.mockito.Mockito.doNothing;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.verify;



import android.os.IDeviceIdleController;



import com.android.settingslib.SettingsLibRobolectricTestRunner;

import com.android.settingslib.TestConfig;



import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.robolectric.annotation.Config;



@RunWith(SettingsLibRobolectricTestRunner.class)

@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)

public class PowerWhitelistBackendTest {



    private static final String PACKAGE_ONE = "com.example.packageone";

    private static final String PACKAGE_TWO = "com.example.packagetwo";



    private PowerWhitelistBackend mPowerWhitelistBackend;

    @Mock

    private IDeviceIdleController mDeviceIdleService;



    @Before

    public void setUp() throws Exception {

        MockitoAnnotations.initMocks(this);

        doReturn(new String[] {}).when(mDeviceIdleService).getFullPowerWhitelist();

        doReturn(new String[] {}).when(mDeviceIdleService).getSystemPowerWhitelist();

        doNothing().when(mDeviceIdleService).addPowerSaveWhitelistApp(anyString());

        doNothing().when(mDeviceIdleService).removePowerSaveWhitelistApp(anyString());

        mPowerWhitelistBackend = new PowerWhitelistBackend(mDeviceIdleService);

    }



    @Test

    public void testIsWhitelisted() throws Exception {

        doReturn(new String[] {PACKAGE_ONE}).when(mDeviceIdleService).getFullPowerWhitelist();

        mPowerWhitelistBackend.refreshList();



        assertThat(mPowerWhitelistBackend.isWhitelisted(PACKAGE_ONE)).isTrue();

        assertThat(mPowerWhitelistBackend.isWhitelisted(PACKAGE_TWO)).isFalse();



        mPowerWhitelistBackend.addApp(PACKAGE_TWO);



        verify(mDeviceIdleService, atLeastOnce()).addPowerSaveWhitelistApp(PACKAGE_TWO);

        assertThat(mPowerWhitelistBackend.isWhitelisted(PACKAGE_ONE)).isTrue();

        assertThat(mPowerWhitelistBackend.isWhitelisted(PACKAGE_TWO)).isTrue();



        mPowerWhitelistBackend.removeApp(PACKAGE_TWO);



        verify(mDeviceIdleService, atLeastOnce()).removePowerSaveWhitelistApp(PACKAGE_TWO);

        assertThat(mPowerWhitelistBackend.isWhitelisted(PACKAGE_ONE)).isTrue();

        assertThat(mPowerWhitelistBackend.isWhitelisted(PACKAGE_TWO)).isFalse();



        mPowerWhitelistBackend.removeApp(PACKAGE_ONE);



        verify(mDeviceIdleService, atLeastOnce()).removePowerSaveWhitelistApp(PACKAGE_ONE);

        assertThat(mPowerWhitelistBackend.isWhitelisted(PACKAGE_ONE)).isFalse();

        assertThat(mPowerWhitelistBackend.isWhitelisted(PACKAGE_TWO)).isFalse();

    }



    @Test

    public void testIsSystemWhitelisted() throws Exception {

        doReturn(new String[] {PACKAGE_ONE}).when(mDeviceIdleService).getSystemPowerWhitelist();

        mPowerWhitelistBackend.refreshList();



        assertThat(mPowerWhitelistBackend.isSysWhitelisted(PACKAGE_ONE)).isTrue();

        assertThat(mPowerWhitelistBackend.isSysWhitelisted(PACKAGE_TWO)).isFalse();

        assertThat(mPowerWhitelistBackend.isWhitelisted(PACKAGE_ONE)).isFalse();



    }

}