Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Adding idle maintenance service."

Browse Source
This commit is contained in:
Svetoslav
2013-02-20 19:11:06 +00:00
committed by Android (Google) Code Review
parent 8a47d8eaec b3038ec7cf
commit aa7cc1e2ab
5 changed files with 270 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
api/current.txt
View File

@@ -5848,6 +5848,8 @@ package android.content {
field public static final java.lang.String ACTION_GTALK_SERVICE_CONNECTED = "android.intent.action.GTALK_CONNECTED";
field public static final java.lang.String ACTION_GTALK_SERVICE_DISCONNECTED = "android.intent.action.GTALK_DISCONNECTED";
field public static final java.lang.String ACTION_HEADSET_PLUG = "android.intent.action.HEADSET_PLUG";
field public static final java.lang.String ACTION_IDLE_MAINTENANCE_END = "android.intent.action.ACTION_IDLE_MAINTENANCE_END";
field public static final java.lang.String ACTION_IDLE_MAINTENANCE_START = "android.intent.action.ACTION_IDLE_MAINTENANCE_START";
field public static final java.lang.String ACTION_INPUT_METHOD_CHANGED = "android.intent.action.INPUT_METHOD_CHANGED";
field public static final java.lang.String ACTION_INSERT = "android.intent.action.INSERT";
field public static final java.lang.String ACTION_INSERT_OR_EDIT = "android.intent.action.INSERT_OR_EDIT";

55
core/java/android/content/Intent.java
View File

@@ -2318,6 +2318,61 @@ public class Intent implements Parcelable, Cloneable {
public static final String ACTION_DOCK_EVENT =
"android.intent.action.DOCK_EVENT";
/**
* Broadcast Action: A broadcast when idle maintenance can be started.
* This means that the user is not interacting with the device and is
* not expected to do so soon. Typical use of the idle maintenance is
* to perform somehow expensive tasks that can be postponed at a moment
* when they will not degrade user experience.
* <p>
* <p class="note">In order to keep the device responsive in case of an
* unexpected user interaction, implementations of a maintenance task
* should be interruptible. In such a scenario a broadcast with action
* {@link #ACTION_IDLE_MAINTENANCE_END} will be sent. In other words, you
* should not do the maintenance work in
* {@link BroadcastReceiver#onReceive(Context, Intent)}, rather start a
* maintenance service by {@link Context#startService(Intent)}. Also
* you should hold a wake lock while your maintenance service is running
* to prevent the device going to sleep.
* </p>
* <p>
* <p class="note">This is a protected intent that can only be sent by
* the system.
* </p>
*
* @see #ACTION_IDLE_MAINTENANCE_END
*/
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String ACTION_IDLE_MAINTENANCE_START =
"android.intent.action.ACTION_IDLE_MAINTENANCE_START";
/**
* Broadcast Action: A broadcast when idle maintenance should be stopped.
* This means that the user was not interacting with the device as a result
* of which a broadcast with action {@link #ACTION_IDLE_MAINTENANCE_START}
* was sent and now the user started interacting with the device. Typical
* use of the idle maintenance is to perform somehow expensive tasks that
* can be postponed at a moment when they will not degrade user experience.
* <p>
* <p class="note">In order to keep the device responsive in case of an
* unexpected user interaction, implementations of a maintenance task
* should be interruptible. Hence, on receiving a broadcast with this
* action, the maintenance task should be interrupted as soon as possible.
* In other words, you should not do the maintenance work in
* {@link BroadcastReceiver#onReceive(Context, Intent)}, rather stop the
* maintenance service that was started on receiving of
* {@link #ACTION_IDLE_MAINTENANCE_START}.Also you should release the wake
* lock you acquired when your maintenance service started.
* </p>
* <p class="note">This is a protected intent that can only be sent
* by the system.
*
* @see #ACTION_IDLE_MAINTENANCE_START
*/
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String ACTION_IDLE_MAINTENANCE_END =
"android.intent.action.ACTION_IDLE_MAINTENANCE_END";
/**
* Broadcast Action: a remote intent is to be broadcasted.
*

3
core/res/AndroidManifest.xml
View File

@@ -170,6 +170,9 @@
<protected-broadcast android:name="android.intent.action.AIRPLANE_MODE" />
<protected-broadcast android:name="android.intent.action.ADVANCED_SETTINGS" />
<protected-broadcast android:name="android.intent.action.ACTION_IDLE_MAINTENANCE_START" />
<protected-broadcast android:name="android.intent.action.ACTION_IDLE_MAINTENANCE_END" />
<!-- ====================================== -->
<!-- Permissions for things that cost money -->
<!-- ====================================== -->

202
services/java/com/android/server/IdleMaintenanceService.java Normal file
View File

@@ -0,0 +1,202 @@
/*
* Copyright (C) 2013 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;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.BatteryManager;
import android.os.Handler;
import android.os.Looper;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.os.SystemClock;
import android.os.UserHandle;
import android.util.Log;
import java.util.Calendar;
import java.util.TimeZone;
/**
* This service observes the device state and when applicable sends
* broadcasts at the beginning and at the end of a period during which
* observers can perform idle maintenance tasks. Typical use of the
* idle maintenance is to perform somehow expensive tasks that can be
* postponed to a moment when they will not degrade user experience.
*
* The current implementation is very simple. The start of a maintenance
* window is announced if: the screen is off or showing a dream AND the
* battery level is more than twenty percent AND at least one hour passed
* since the screen went off or a dream started (i.e. since the last user
* activity).
*
* The end of a maintenance window is announced only if: a start was
* announced AND the screen turned on or a dream was stopped.
*/
public class IdleMaintenanceService extends BroadcastReceiver {
private final boolean DEBUG = false;
private static final String LOG_TAG = IdleMaintenanceService.class.getSimpleName();
private static final int LAST_USER_ACTIVITY_TIME_INVALID = -1;
private static final int MIN_IDLE_MAINTENANCE_START_BATTERY_LEVEL = 20; // percent
private static final long MIN_IDLE_MAINTENANCE_START_USER_INACTIVITY = 60 * 60 * 1000; // 1 hour
private final Intent mIdleMaintenanceStartIntent =
new Intent(Intent.ACTION_IDLE_MAINTENANCE_START);
private final Intent mIdleMaintenanceEndIntent =
new Intent(Intent.ACTION_IDLE_MAINTENANCE_END);
private final Context mContext;
private final WakeLock mWakeLock;
private final Handler mHandler;
private final Calendar mTempCalendar = Calendar.getInstance();
private final Calendar mLastIdleMaintenanceStartTime = Calendar.getInstance();
private long mLastUserActivityElapsedTimeMillis = LAST_USER_ACTIVITY_TIME_INVALID;
private int mBatteryLevel;
private boolean mIdleMaintenanceStarted;
public IdleMaintenanceService(Context context) {
mContext = context;
PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, LOG_TAG);
mHandler = new Handler(mContext.getMainLooper());
// Move one day back so we can run maintenance the first day after starting.
final int prevDayOfYear = mLastIdleMaintenanceStartTime.get(Calendar.DAY_OF_YEAR) - 1;
mLastIdleMaintenanceStartTime.set(Calendar.DAY_OF_YEAR, prevDayOfYear);
register(mContext.getMainLooper());
}
public void register(Looper looper) {
IntentFilter intentFilter = new IntentFilter();
// Battery actions.
intentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);
// Screen actions.
intentFilter.addAction(Intent.ACTION_SCREEN_ON);
intentFilter.addAction(Intent.ACTION_SCREEN_OFF);
// Dream actions.
intentFilter.addAction(Intent.ACTION_DREAMING_STARTED);
intentFilter.addAction(Intent.ACTION_DREAMING_STOPPED);
mContext.registerReceiverAsUser(this, UserHandle.ALL,
intentFilter, null, new Handler(looper));
}
private void updateIdleMaintenanceState() {
if (mIdleMaintenanceStarted) {
// Idle maintenance can be interrupted only by
// a change of the device state.
if (!deviceStatePermitsIdleMaintenance()) {
mIdleMaintenanceStarted = false;
sendIdleMaintenanceEndIntent();
}
} else if (deviceStatePermitsIdleMaintenance()
&& lastUserActivityPermitsIdleMaintenanceStart()
&& lastRunPermitsIdleMaintenanceStart()) {
mIdleMaintenanceStarted = true;
mLastIdleMaintenanceStartTime.setTimeInMillis(System.currentTimeMillis());
sendIdleMaintenanceStartIntent();
}
}
private void sendIdleMaintenanceStartIntent() {
if (DEBUG) {
Log.i(LOG_TAG, "Broadcasting " + Intent.ACTION_IDLE_MAINTENANCE_START);
}
mWakeLock.acquire();
mContext.sendOrderedBroadcastAsUser(mIdleMaintenanceStartIntent, UserHandle.ALL,
null, this, mHandler, Activity.RESULT_OK, null, null);
}
private void sendIdleMaintenanceEndIntent() {
if (DEBUG) {
Log.i(LOG_TAG, "Broadcasting " + Intent.ACTION_IDLE_MAINTENANCE_END);
}
mWakeLock.acquire();
mContext.sendOrderedBroadcastAsUser(mIdleMaintenanceEndIntent, UserHandle.ALL,
null, this, mHandler, Activity.RESULT_OK, null, null);
}
private boolean deviceStatePermitsIdleMaintenance() {
return (mLastUserActivityElapsedTimeMillis != LAST_USER_ACTIVITY_TIME_INVALID
&& mBatteryLevel > MIN_IDLE_MAINTENANCE_START_BATTERY_LEVEL);
}
private boolean lastUserActivityPermitsIdleMaintenanceStart() {
return (SystemClock.elapsedRealtime() - mLastUserActivityElapsedTimeMillis
> MIN_IDLE_MAINTENANCE_START_USER_INACTIVITY);
}
private boolean lastRunPermitsIdleMaintenanceStart() {
Calendar now = mTempCalendar;
// Not setting the Locale since we do not care of locale
// specific properties such as the first day of the week.
now.setTimeZone(TimeZone.getDefault());
now.setTimeInMillis(System.currentTimeMillis());
Calendar lastRun = mLastIdleMaintenanceStartTime;
// Not setting the Locale since we do not care of locale
// specific properties such as the first day of the week.
lastRun.setTimeZone(TimeZone.getDefault());
return now.get(Calendar.DAY_OF_YEAR) != lastRun.get(Calendar.DAY_OF_YEAR);
}
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) {
Log.i(LOG_TAG, intent.getAction());
}
String action = intent.getAction();
if (Intent.ACTION_BATTERY_CHANGED.equals(action)) {
final int maxBatteryLevel = intent.getExtras().getInt(BatteryManager.EXTRA_SCALE);
final int currBatteryLevel = intent.getExtras().getInt(BatteryManager.EXTRA_LEVEL);
mBatteryLevel = (int) (((float) maxBatteryLevel / 100) * currBatteryLevel);
} else if (Intent.ACTION_SCREEN_ON.equals(action)
|| Intent.ACTION_DREAMING_STOPPED.equals(action)) {
mLastUserActivityElapsedTimeMillis = LAST_USER_ACTIVITY_TIME_INVALID;
} else if (Intent.ACTION_SCREEN_OFF.equals(action)
|| Intent.ACTION_DREAMING_STARTED.equals(action)) {
mLastUserActivityElapsedTimeMillis = SystemClock.elapsedRealtime();
} else if (Intent.ACTION_IDLE_MAINTENANCE_START.equals(action)
|| Intent.ACTION_IDLE_MAINTENANCE_END.equals(action)) {
mWakeLock.release();
return;
}
updateIdleMaintenanceState();
}
}

9
services/java/com/android/server/SystemServer.java
View File

@@ -255,7 +255,7 @@ class ServerThread extends Thread {
}
ActivityManagerService.setSystemProcess();
Slog.i(TAG, "User Service");
ServiceManager.addService(Context.USER_SERVICE,
UserManagerService.getInstance());
@@ -736,6 +736,13 @@ class ServerThread extends Thread {
reportWtf("starting DreamManagerService", e);
}
}
try {
Slog.i(TAG, "IdleMaintenanceService");
new IdleMaintenanceService(context);
} catch (Throwable e) {
reportWtf("starting IdleMaintenanceService", e);
}
}
// Before things start rolling, be sure we have decided whether