Merge "App Time Limits API in UsageStats" into pi-dev (0071ccea) · Commits · e / os / android_frameworks_base

api/system-current.txt

+5 −0

Original line number	Diff line number	Diff line
		@@ -729,9 +729,14 @@ package android.app.usage {
		public final class UsageStatsManager {
		method public int getAppStandbyBucket(java.lang.String);
		method public java.util.Map<java.lang.String, java.lang.Integer> getAppStandbyBuckets();
		method public void registerAppUsageObserver(int, java.lang.String[], long, java.util.concurrent.TimeUnit, android.app.PendingIntent);
		method public void setAppStandbyBucket(java.lang.String, int);
		method public void setAppStandbyBuckets(java.util.Map<java.lang.String, java.lang.Integer>);
		method public void unregisterAppUsageObserver(int);
		method public void whitelistAppTemporarily(java.lang.String, long, android.os.UserHandle);
		field public static final java.lang.String EXTRA_OBSERVER_ID = "android.app.usage.extra.OBSERVER_ID";
		field public static final java.lang.String EXTRA_TIME_LIMIT = "android.app.usage.extra.TIME_LIMIT";
		field public static final java.lang.String EXTRA_TIME_USED = "android.app.usage.extra.TIME_USED";
		field public static final int STANDBY_BUCKET_EXEMPTED = 5; // 0x5
		field public static final int STANDBY_BUCKET_NEVER = 50; // 0x32
		}

core/java/android/app/usage/IUsageStatsManager.aidl

+4 −0

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

		package android.app.usage;

		import android.app.PendingIntent;
		import android.app.usage.UsageEvents;
		import android.content.pm.ParceledListSlice;

		@@ -43,4 +44,7 @@ interface IUsageStatsManager {
		void setAppStandbyBucket(String packageName, int bucket, int userId);
		ParceledListSlice getAppStandbyBuckets(String callingPackage, int userId);
		void setAppStandbyBuckets(in ParceledListSlice appBuckets, int userId);
		void registerAppUsageObserver(int observerId, in String[] packages, long timeLimitMs,
		in PendingIntent callback, String callingPackage);
		void unregisterAppUsageObserver(int observerId, String callingPackage);
		}

core/java/android/app/usage/UsageStatsManager.java

+74 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@ import android.annotation.IntDef;
		import android.annotation.RequiresPermission;
		import android.annotation.SystemApi;
		import android.annotation.SystemService;
		import android.app.PendingIntent;
		import android.content.Context;
		import android.content.pm.ParceledListSlice;
		import android.os.RemoteException;
		@@ -32,6 +33,7 @@ import java.util.ArrayList;
		import java.util.Collections;
		import java.util.List;
		import java.util.Map;
		import java.util.concurrent.TimeUnit;

		/**
		* Provides access to device usage history and statistics. Usage data is aggregated into
		@@ -179,6 +181,31 @@ public final class UsageStatsManager {
		@Retention(RetentionPolicy.SOURCE)
		public @interface StandbyBuckets {}

		/**
		* Observer id of the registered observer for the group of packages that reached the usage
		* time limit. Included as an extra in the PendingIntent that was registered.
		* @hide
		*/
		@SystemApi
		public static final String EXTRA_OBSERVER_ID = "android.app.usage.extra.OBSERVER_ID";

		/**
		* Original time limit in milliseconds specified by the registered observer for the group of
		* packages that reached the usage time limit. Included as an extra in the PendingIntent that
		* was registered.
		* @hide
		*/
		@SystemApi
		public static final String EXTRA_TIME_LIMIT = "android.app.usage.extra.TIME_LIMIT";

		/**
		* Actual usage time in milliseconds for the group of packages that reached the specified time
		* limit. Included as an extra in the PendingIntent that was registered.
		* @hide
		*/
		@SystemApi
		public static final String EXTRA_TIME_USED = "android.app.usage.extra.TIME_USED";

		private static final UsageEvents sEmptyResults = new UsageEvents();

		private final Context mContext;
		@@ -470,6 +497,53 @@ public final class UsageStatsManager {
		}
		}

		/**
		* @hide
		* Register an app usage limit observer that receives a callback on the provided intent when
		* the sum of usages of apps in the packages array exceeds the timeLimit specified. The
		* observer will automatically be unregistered when the time limit is reached and the intent
		* is delivered.
		* @param observerId A unique id associated with the group of apps to be monitored. There can
		* be multiple groups with common packages and different time limits.
		* @param packages The list of packages to observe for foreground activity time. Must include
		* at least one package.
		* @param timeLimit The total time the set of apps can be in the foreground before the
		* callbackIntent is delivered. Must be greater than 0.
		* @param timeUnit The unit for time specified in timeLimit.
		* @param callbackIntent The PendingIntent that will be dispatched when the time limit is
		* exceeded by the group of apps. The delivered Intent will also contain
		* the extras {@link #EXTRA_OBSERVER_ID}, {@link #EXTRA_TIME_LIMIT} and
		* {@link #EXTRA_TIME_USED}.
		* @throws SecurityException if the caller doesn't have the PACKAGE_USAGE_STATS permission.
		*/
		@SystemApi
		@RequiresPermission(android.Manifest.permission.PACKAGE_USAGE_STATS)
		public void registerAppUsageObserver(int observerId, String[] packages, long timeLimit,
		TimeUnit timeUnit, PendingIntent callbackIntent) {
		try {
		mService.registerAppUsageObserver(observerId, packages, timeUnit.toMillis(timeLimit),
		callbackIntent, mContext.getOpPackageName());
		} catch (RemoteException e) {
		}
		}

		/**
		* @hide
		* Unregister the app usage observer specified by the observerId. This will only apply to any
		* observer registered by this application. Unregistering an observer that was already
		* unregistered or never registered will have no effect.
		* @param observerId The id of the observer that was previously registered.
		* @throws SecurityException if the caller doesn't have the PACKAGE_USAGE_STATS permission.
		*/
		@SystemApi
		@RequiresPermission(android.Manifest.permission.PACKAGE_USAGE_STATS)
		public void unregisterAppUsageObserver(int observerId) {
		try {
		mService.unregisterAppUsageObserver(observerId, mContext.getOpPackageName());
		} catch (RemoteException e) {
		}
		}

		/** @hide */
		public static String reasonToString(int standbyReason) {
		StringBuilder sb = new StringBuilder();

services/tests/servicestests/src/com/android/server/usage/AppTimeLimitControllerTests.java

0 → 100644

+256 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.usage;

		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertFalse;
		import static org.junit.Assert.assertTrue;

		import android.app.PendingIntent;
		import android.os.HandlerThread;
		import android.os.Looper;
		import android.support.test.filters.MediumTest;
		import android.support.test.runner.AndroidJUnit4;

		import org.junit.After;
		import org.junit.Before;
		import org.junit.Test;
		import org.junit.runner.RunWith;

		import java.util.concurrent.CountDownLatch;
		import java.util.concurrent.TimeUnit;

		@RunWith(AndroidJUnit4.class)
		@MediumTest
		public class AppTimeLimitControllerTests {

		private static final String PKG_SOC1 = "package.soc1";
		private static final String PKG_SOC2 = "package.soc2";
		private static final String PKG_GAME1 = "package.game1";
		private static final String PKG_GAME2 = "package.game2";
		private static final String PKG_PROD = "package.prod";

		private static final int UID = 10100;
		private static final int USER_ID = 10;
		private static final int OBS_ID1 = 1;
		private static final int OBS_ID2 = 2;
		private static final int OBS_ID3 = 3;

		private static final long TIME_30_MIN = 30 * 60_1000L;
		private static final long TIME_10_MIN = 10 * 60_1000L;

		private static final String[] GROUP1 = {
		PKG_SOC1, PKG_GAME1, PKG_PROD
		};

		private static final String[] GROUP_SOC = {
		PKG_SOC1, PKG_SOC2
		};

		private static final String[] GROUP_GAME = {
		PKG_GAME1, PKG_GAME2
		};

		private final CountDownLatch mCountDownLatch = new CountDownLatch(1);

		private AppTimeLimitController mController;

		private HandlerThread mThread;

		private long mUptimeMillis;

		AppTimeLimitController.OnLimitReachedListener mListener
		= new AppTimeLimitController.OnLimitReachedListener() {

		@Override
		public void onLimitReached(int observerId, int userId, long timeLimit, long timeElapsed,
		PendingIntent callbackIntent) {
		mCountDownLatch.countDown();
		}
		};

		class MyAppTimeLimitController extends AppTimeLimitController {
		MyAppTimeLimitController(AppTimeLimitController.OnLimitReachedListener listener,
		Looper looper) {
		super(listener, looper);
		}

		@Override
		protected long getUptimeMillis() {
		return mUptimeMillis;
		}
		}

		@Before
		public void setUp() {
		mThread = new HandlerThread("Test");
		mThread.start();
		mController = new MyAppTimeLimitController(mListener, mThread.getLooper());
		}

		@After
		public void tearDown() {
		mThread.quit();
		}

		/** Verify observer is added */
		@Test
		public void testAddObserver() {
		addObserver(OBS_ID1, GROUP1, TIME_30_MIN);
		assertTrue("Observer wasn't added", hasObserver(OBS_ID1));
		addObserver(OBS_ID2, GROUP_GAME, TIME_30_MIN);
		assertTrue("Observer wasn't added", hasObserver(OBS_ID2));
		assertTrue("Observer wasn't added", hasObserver(OBS_ID1));
		}

		/** Verify observer is removed */
		@Test
		public void testRemoveObserver() {
		addObserver(OBS_ID1, GROUP1, TIME_30_MIN);
		assertTrue("Observer wasn't added", hasObserver(OBS_ID1));
		mController.removeObserver(UID, OBS_ID1, USER_ID);
		assertFalse("Observer wasn't removed", hasObserver(OBS_ID1));
		}

		/** Re-adding an observer should result in only one copy */
		@Test
		public void testObserverReAdd() {
		addObserver(OBS_ID1, GROUP1, TIME_30_MIN);
		assertTrue("Observer wasn't added", hasObserver(OBS_ID1));
		addObserver(OBS_ID1, GROUP1, TIME_10_MIN);
		assertTrue("Observer wasn't added",
		mController.getObserverGroup(OBS_ID1, USER_ID).timeLimit == TIME_10_MIN);
		mController.removeObserver(UID, OBS_ID1, USER_ID);
		assertFalse("Observer wasn't removed", hasObserver(OBS_ID1));
		}

		/** Verify that usage across different apps within a group are added up */
		@Test
		public void testAccumulation() throws Exception {
		setTime(0L);
		addObserver(OBS_ID1, GROUP1, TIME_30_MIN);
		moveToForeground(PKG_SOC1);
		// Add 10 mins
		setTime(TIME_10_MIN);
		moveToBackground(PKG_SOC1);

		long timeRemaining = mController.getObserverGroup(OBS_ID1, USER_ID).timeRemaining;
		assertEquals(TIME_10_MIN * 2, timeRemaining);

		moveToForeground(PKG_SOC1);
		setTime(TIME_10_MIN * 2);
		moveToBackground(PKG_SOC1);

		timeRemaining = mController.getObserverGroup(OBS_ID1, USER_ID).timeRemaining;
		assertEquals(TIME_10_MIN, timeRemaining);

		setTime(TIME_30_MIN);

		assertFalse(mCountDownLatch.await(100L, TimeUnit.MILLISECONDS));

		// Add a different package in the group
		moveToForeground(PKG_GAME1);
		setTime(TIME_30_MIN + TIME_10_MIN);
		moveToBackground(PKG_GAME1);

		assertEquals(0, mController.getObserverGroup(OBS_ID1, USER_ID).timeRemaining);
		assertTrue(mCountDownLatch.await(100L, TimeUnit.MILLISECONDS));
		}

		/** Verify that time limit does not get triggered due to a different app */
		@Test
		public void testTimeoutOtherApp() throws Exception {
		setTime(0L);
		addObserver(OBS_ID1, GROUP1, 4_000L);
		moveToForeground(PKG_SOC2);
		assertFalse(mCountDownLatch.await(6_000L, TimeUnit.MILLISECONDS));
		setTime(6_000L);
		moveToBackground(PKG_SOC2);
		assertFalse(mCountDownLatch.await(100L, TimeUnit.MILLISECONDS));
		}

		/** Verify the timeout message is delivered at the right time */
		@Test
		public void testTimeout() throws Exception {
		setTime(0L);
		addObserver(OBS_ID1, GROUP1, 4_000L);
		moveToForeground(PKG_SOC1);
		setTime(6_000L);
		assertTrue(mCountDownLatch.await(6_000L, TimeUnit.MILLISECONDS));
		moveToBackground(PKG_SOC1);
		// Verify that the observer was removed
		assertFalse(hasObserver(OBS_ID1));
		}

		/** If an app was already running, make sure it is partially counted towards the time limit */
		@Test
		public void testAlreadyRunning() throws Exception {
		setTime(TIME_10_MIN);
		moveToForeground(PKG_GAME1);
		setTime(TIME_30_MIN);
		addObserver(OBS_ID2, GROUP_GAME, TIME_30_MIN);
		setTime(TIME_30_MIN + TIME_10_MIN);
		moveToBackground(PKG_GAME1);
		assertFalse(mCountDownLatch.await(1000L, TimeUnit.MILLISECONDS));

		moveToForeground(PKG_GAME2);
		setTime(TIME_30_MIN + TIME_30_MIN);
		moveToBackground(PKG_GAME2);
		assertTrue(mCountDownLatch.await(1000L, TimeUnit.MILLISECONDS));
		// Verify that the observer was removed
		assertFalse(hasObserver(OBS_ID2));
		}

		/** If watched app is already running, verify the timeout callback happens at the right time */
		@Test
		public void testAlreadyRunningTimeout() throws Exception {
		setTime(0);
		moveToForeground(PKG_SOC1);
		setTime(TIME_10_MIN);
		// 10 second time limit
		addObserver(OBS_ID1, GROUP_SOC, 10_000L);
		setTime(TIME_10_MIN + 5_000L);
		// Shouldn't call back in 6 seconds
		assertFalse(mCountDownLatch.await(6_000L, TimeUnit.MILLISECONDS));
		setTime(TIME_10_MIN + 10_000L);
		// Should call back by 11 seconds (6 earlier + 5 now)
		assertTrue(mCountDownLatch.await(5_000L, TimeUnit.MILLISECONDS));
		// Verify that the observer was removed
		assertFalse(hasObserver(OBS_ID1));
		}

		private void moveToForeground(String packageName) {
		mController.moveToForeground(packageName, "class", USER_ID);
		}

		private void moveToBackground(String packageName) {
		mController.moveToBackground(packageName, "class", USER_ID);
		}

		private void addObserver(int observerId, String[] packages, long timeLimit) {
		mController.addObserver(UID, observerId, packages, timeLimit, null, USER_ID);
		}

		/** Is there still an observer by that id */
		private boolean hasObserver(int observerId) {
		return mController.getObserverGroup(observerId, USER_ID) != null;
		}

		private void setTime(long time) {
		mUptimeMillis = time;
		}
		}

services/usage/java/com/android/server/usage/AppTimeLimitController.java

0 → 100644

+464 −0

File added.

Preview size limit exceeded, changes collapsed.