903 lines
35 KiB
Java
903 lines
35 KiB
Java
/*
|
|
* Copyright (C) 2006 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.app.ActivityManagerNative;
|
|
import android.app.AlarmManager;
|
|
import android.app.IAlarmManager;
|
|
import android.app.PendingIntent;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.content.pm.PackageManager;
|
|
import android.net.Uri;
|
|
import android.os.Binder;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Message;
|
|
import android.os.PowerManager;
|
|
import android.os.SystemClock;
|
|
import android.os.SystemProperties;
|
|
import android.text.TextUtils;
|
|
import android.text.format.Time;
|
|
import android.util.EventLog;
|
|
import android.util.Slog;
|
|
import android.util.TimeUtils;
|
|
|
|
import java.io.FileDescriptor;
|
|
import java.io.PrintWriter;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Calendar;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import java.util.TimeZone;
|
|
|
|
class AlarmManagerService extends IAlarmManager.Stub {
|
|
// The threshold for how long an alarm can be late before we print a
|
|
// warning message. The time duration is in milliseconds.
|
|
private static final long LATE_ALARM_THRESHOLD = 10 * 1000;
|
|
|
|
private static final int RTC_WAKEUP_MASK = 1 << AlarmManager.RTC_WAKEUP;
|
|
private static final int RTC_MASK = 1 << AlarmManager.RTC;
|
|
private static final int ELAPSED_REALTIME_WAKEUP_MASK = 1 << AlarmManager.ELAPSED_REALTIME_WAKEUP;
|
|
private static final int ELAPSED_REALTIME_MASK = 1 << AlarmManager.ELAPSED_REALTIME;
|
|
private static final int TIME_CHANGED_MASK = 1 << 16;
|
|
|
|
private static final String TAG = "AlarmManager";
|
|
private static final String ClockReceiver_TAG = "ClockReceiver";
|
|
private static final boolean localLOGV = false;
|
|
private static final int ALARM_EVENT = 1;
|
|
private static final String TIMEZONE_PROPERTY = "persist.sys.timezone";
|
|
|
|
private static final Intent mBackgroundIntent
|
|
= new Intent().addFlags(Intent.FLAG_FROM_BACKGROUND);
|
|
|
|
private final Context mContext;
|
|
|
|
private Object mLock = new Object();
|
|
|
|
private final ArrayList<Alarm> mRtcWakeupAlarms = new ArrayList<Alarm>();
|
|
private final ArrayList<Alarm> mRtcAlarms = new ArrayList<Alarm>();
|
|
private final ArrayList<Alarm> mElapsedRealtimeWakeupAlarms = new ArrayList<Alarm>();
|
|
private final ArrayList<Alarm> mElapsedRealtimeAlarms = new ArrayList<Alarm>();
|
|
private final IncreasingTimeOrder mIncreasingTimeOrder = new IncreasingTimeOrder();
|
|
|
|
// slots corresponding with the inexact-repeat interval buckets,
|
|
// ordered from shortest to longest
|
|
private static final long sInexactSlotIntervals[] = {
|
|
AlarmManager.INTERVAL_FIFTEEN_MINUTES,
|
|
AlarmManager.INTERVAL_HALF_HOUR,
|
|
AlarmManager.INTERVAL_HOUR,
|
|
AlarmManager.INTERVAL_HALF_DAY,
|
|
AlarmManager.INTERVAL_DAY
|
|
};
|
|
private long mInexactDeliveryTimes[] = { 0, 0, 0, 0, 0};
|
|
|
|
private int mDescriptor;
|
|
private int mBroadcastRefCount = 0;
|
|
private PowerManager.WakeLock mWakeLock;
|
|
private final AlarmThread mWaitThread = new AlarmThread();
|
|
private final AlarmHandler mHandler = new AlarmHandler();
|
|
private ClockReceiver mClockReceiver;
|
|
private UninstallReceiver mUninstallReceiver;
|
|
private final ResultReceiver mResultReceiver = new ResultReceiver();
|
|
private final PendingIntent mTimeTickSender;
|
|
private final PendingIntent mDateChangeSender;
|
|
|
|
private static final class FilterStats {
|
|
int count;
|
|
}
|
|
|
|
private static final class BroadcastStats {
|
|
long aggregateTime;
|
|
int numWakeup;
|
|
long startTime;
|
|
int nesting;
|
|
HashMap<Intent.FilterComparison, FilterStats> filterStats
|
|
= new HashMap<Intent.FilterComparison, FilterStats>();
|
|
}
|
|
|
|
private final HashMap<String, BroadcastStats> mBroadcastStats
|
|
= new HashMap<String, BroadcastStats>();
|
|
|
|
public AlarmManagerService(Context context) {
|
|
mContext = context;
|
|
mDescriptor = init();
|
|
PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
|
|
mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
|
|
|
|
mTimeTickSender = PendingIntent.getBroadcast(context, 0,
|
|
new Intent(Intent.ACTION_TIME_TICK).addFlags(
|
|
Intent.FLAG_RECEIVER_REGISTERED_ONLY), 0);
|
|
Intent intent = new Intent(Intent.ACTION_DATE_CHANGED);
|
|
intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
|
|
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
|
|
mDateChangeSender = PendingIntent.getBroadcast(context, 0, intent, 0);
|
|
|
|
// now that we have initied the driver schedule the alarm
|
|
mClockReceiver= new ClockReceiver();
|
|
mClockReceiver.scheduleTimeTickEvent();
|
|
mClockReceiver.scheduleDateChangedEvent();
|
|
mUninstallReceiver = new UninstallReceiver();
|
|
|
|
if (mDescriptor != -1) {
|
|
mWaitThread.start();
|
|
} else {
|
|
Slog.w(TAG, "Failed to open alarm driver. Falling back to a handler.");
|
|
}
|
|
}
|
|
|
|
protected void finalize() throws Throwable {
|
|
try {
|
|
close(mDescriptor);
|
|
} finally {
|
|
super.finalize();
|
|
}
|
|
}
|
|
|
|
public void set(int type, long triggerAtTime, PendingIntent operation) {
|
|
setRepeating(type, triggerAtTime, 0, operation);
|
|
}
|
|
|
|
public void setRepeating(int type, long triggerAtTime, long interval,
|
|
PendingIntent operation) {
|
|
if (operation == null) {
|
|
Slog.w(TAG, "set/setRepeating ignored because there is no intent");
|
|
return;
|
|
}
|
|
synchronized (mLock) {
|
|
Alarm alarm = new Alarm();
|
|
alarm.type = type;
|
|
alarm.when = triggerAtTime;
|
|
alarm.repeatInterval = interval;
|
|
alarm.operation = operation;
|
|
|
|
// Remove this alarm if already scheduled.
|
|
removeLocked(operation);
|
|
|
|
if (localLOGV) Slog.v(TAG, "set: " + alarm);
|
|
|
|
int index = addAlarmLocked(alarm);
|
|
if (index == 0) {
|
|
setLocked(alarm);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setInexactRepeating(int type, long triggerAtTime, long interval,
|
|
PendingIntent operation) {
|
|
if (operation == null) {
|
|
Slog.w(TAG, "setInexactRepeating ignored because there is no intent");
|
|
return;
|
|
}
|
|
|
|
// find the slot in the delivery-times array that we will use
|
|
int intervalSlot;
|
|
for (intervalSlot = 0; intervalSlot < sInexactSlotIntervals.length; intervalSlot++) {
|
|
if (sInexactSlotIntervals[intervalSlot] == interval) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Non-bucket intervals just fall back to the less-efficient
|
|
// unbucketed recurring alarm implementation
|
|
if (intervalSlot >= sInexactSlotIntervals.length) {
|
|
setRepeating(type, triggerAtTime, interval, operation);
|
|
return;
|
|
}
|
|
|
|
// Align bucketed alarm deliveries by trying to match
|
|
// the shortest-interval bucket already scheduled
|
|
long bucketTime = 0;
|
|
for (int slot = 0; slot < mInexactDeliveryTimes.length; slot++) {
|
|
if (mInexactDeliveryTimes[slot] > 0) {
|
|
bucketTime = mInexactDeliveryTimes[slot];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bucketTime == 0) {
|
|
// If nothing is scheduled yet, just start at the requested time
|
|
bucketTime = triggerAtTime;
|
|
} else {
|
|
// Align the new alarm with the existing bucketed sequence. To achieve
|
|
// alignment, we slide the start time around by min{interval, slot interval}
|
|
long adjustment = (interval <= sInexactSlotIntervals[intervalSlot])
|
|
? interval : sInexactSlotIntervals[intervalSlot];
|
|
|
|
// The bucket may have started in the past; adjust
|
|
while (bucketTime < triggerAtTime) {
|
|
bucketTime += adjustment;
|
|
}
|
|
|
|
// Or the bucket may be set to start more than an interval beyond
|
|
// our requested trigger time; pull it back to meet our needs
|
|
while (bucketTime > triggerAtTime + adjustment) {
|
|
bucketTime -= adjustment;
|
|
}
|
|
}
|
|
|
|
// Remember where this bucket started (reducing the amount of later
|
|
// fixup required) and set the alarm with the new, bucketed start time.
|
|
if (localLOGV) Slog.v(TAG, "setInexactRepeating: interval=" + interval
|
|
+ " bucketTime=" + bucketTime);
|
|
mInexactDeliveryTimes[intervalSlot] = bucketTime;
|
|
setRepeating(type, bucketTime, interval, operation);
|
|
}
|
|
|
|
public void setTime(long millis) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
"android.permission.SET_TIME",
|
|
"setTime");
|
|
|
|
SystemClock.setCurrentTimeMillis(millis);
|
|
}
|
|
|
|
public void setTimeZone(String tz) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
"android.permission.SET_TIME_ZONE",
|
|
"setTimeZone");
|
|
|
|
if (TextUtils.isEmpty(tz)) return;
|
|
TimeZone zone = TimeZone.getTimeZone(tz);
|
|
// Prevent reentrant calls from stepping on each other when writing
|
|
// the time zone property
|
|
boolean timeZoneWasChanged = false;
|
|
synchronized (this) {
|
|
String current = SystemProperties.get(TIMEZONE_PROPERTY);
|
|
if (current == null || !current.equals(zone.getID())) {
|
|
if (localLOGV) Slog.v(TAG, "timezone changed: " + current + ", new=" + zone.getID());
|
|
timeZoneWasChanged = true;
|
|
SystemProperties.set(TIMEZONE_PROPERTY, zone.getID());
|
|
}
|
|
|
|
// Update the kernel timezone information
|
|
// Kernel tracks time offsets as 'minutes west of GMT'
|
|
int gmtOffset = zone.getRawOffset();
|
|
if (zone.inDaylightTime(new Date(System.currentTimeMillis()))) {
|
|
gmtOffset += zone.getDSTSavings();
|
|
}
|
|
setKernelTimezone(mDescriptor, -(gmtOffset / 60000));
|
|
}
|
|
|
|
TimeZone.setDefault(null);
|
|
|
|
if (timeZoneWasChanged) {
|
|
Intent intent = new Intent(Intent.ACTION_TIMEZONE_CHANGED);
|
|
intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
|
|
intent.putExtra("time-zone", zone.getID());
|
|
mContext.sendBroadcast(intent);
|
|
}
|
|
}
|
|
|
|
public void remove(PendingIntent operation) {
|
|
if (operation == null) {
|
|
return;
|
|
}
|
|
synchronized (mLock) {
|
|
removeLocked(operation);
|
|
}
|
|
}
|
|
|
|
public void removeLocked(PendingIntent operation) {
|
|
removeLocked(mRtcWakeupAlarms, operation);
|
|
removeLocked(mRtcAlarms, operation);
|
|
removeLocked(mElapsedRealtimeWakeupAlarms, operation);
|
|
removeLocked(mElapsedRealtimeAlarms, operation);
|
|
}
|
|
|
|
private void removeLocked(ArrayList<Alarm> alarmList,
|
|
PendingIntent operation) {
|
|
if (alarmList.size() <= 0) {
|
|
return;
|
|
}
|
|
|
|
// iterator over the list removing any it where the intent match
|
|
Iterator<Alarm> it = alarmList.iterator();
|
|
|
|
while (it.hasNext()) {
|
|
Alarm alarm = it.next();
|
|
if (alarm.operation.equals(operation)) {
|
|
it.remove();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removeLocked(String packageName) {
|
|
removeLocked(mRtcWakeupAlarms, packageName);
|
|
removeLocked(mRtcAlarms, packageName);
|
|
removeLocked(mElapsedRealtimeWakeupAlarms, packageName);
|
|
removeLocked(mElapsedRealtimeAlarms, packageName);
|
|
}
|
|
|
|
private void removeLocked(ArrayList<Alarm> alarmList,
|
|
String packageName) {
|
|
if (alarmList.size() <= 0) {
|
|
return;
|
|
}
|
|
|
|
// iterator over the list removing any it where the intent match
|
|
Iterator<Alarm> it = alarmList.iterator();
|
|
|
|
while (it.hasNext()) {
|
|
Alarm alarm = it.next();
|
|
if (alarm.operation.getTargetPackage().equals(packageName)) {
|
|
it.remove();
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean lookForPackageLocked(String packageName) {
|
|
return lookForPackageLocked(mRtcWakeupAlarms, packageName)
|
|
|| lookForPackageLocked(mRtcAlarms, packageName)
|
|
|| lookForPackageLocked(mElapsedRealtimeWakeupAlarms, packageName)
|
|
|| lookForPackageLocked(mElapsedRealtimeAlarms, packageName);
|
|
}
|
|
|
|
private boolean lookForPackageLocked(ArrayList<Alarm> alarmList, String packageName) {
|
|
for (int i=alarmList.size()-1; i>=0; i--) {
|
|
if (alarmList.get(i).operation.getTargetPackage().equals(packageName)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private ArrayList<Alarm> getAlarmList(int type) {
|
|
switch (type) {
|
|
case AlarmManager.RTC_WAKEUP: return mRtcWakeupAlarms;
|
|
case AlarmManager.RTC: return mRtcAlarms;
|
|
case AlarmManager.ELAPSED_REALTIME_WAKEUP: return mElapsedRealtimeWakeupAlarms;
|
|
case AlarmManager.ELAPSED_REALTIME: return mElapsedRealtimeAlarms;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private int addAlarmLocked(Alarm alarm) {
|
|
ArrayList<Alarm> alarmList = getAlarmList(alarm.type);
|
|
|
|
int index = Collections.binarySearch(alarmList, alarm, mIncreasingTimeOrder);
|
|
if (index < 0) {
|
|
index = 0 - index - 1;
|
|
}
|
|
if (localLOGV) Slog.v(TAG, "Adding alarm " + alarm + " at " + index);
|
|
alarmList.add(index, alarm);
|
|
|
|
if (localLOGV) {
|
|
// Display the list of alarms for this alarm type
|
|
Slog.v(TAG, "alarms: " + alarmList.size() + " type: " + alarm.type);
|
|
int position = 0;
|
|
for (Alarm a : alarmList) {
|
|
Time time = new Time();
|
|
time.set(a.when);
|
|
String timeStr = time.format("%b %d %I:%M:%S %p");
|
|
Slog.v(TAG, position + ": " + timeStr
|
|
+ " " + a.operation.getTargetPackage());
|
|
position += 1;
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
public long timeToNextAlarm() {
|
|
long nextAlarm = Long.MAX_VALUE;
|
|
synchronized (mLock) {
|
|
for (int i=AlarmManager.RTC_WAKEUP;
|
|
i<=AlarmManager.ELAPSED_REALTIME; i++) {
|
|
ArrayList<Alarm> alarmList = getAlarmList(i);
|
|
if (alarmList.size() > 0) {
|
|
Alarm a = alarmList.get(0);
|
|
if (a.when < nextAlarm) {
|
|
nextAlarm = a.when;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nextAlarm;
|
|
}
|
|
|
|
private void setLocked(Alarm alarm)
|
|
{
|
|
if (mDescriptor != -1)
|
|
{
|
|
// The kernel never triggers alarms with negative wakeup times
|
|
// so we ensure they are positive.
|
|
long alarmSeconds, alarmNanoseconds;
|
|
if (alarm.when < 0) {
|
|
alarmSeconds = 0;
|
|
alarmNanoseconds = 0;
|
|
} else {
|
|
alarmSeconds = alarm.when / 1000;
|
|
alarmNanoseconds = (alarm.when % 1000) * 1000 * 1000;
|
|
}
|
|
|
|
set(mDescriptor, alarm.type, alarmSeconds, alarmNanoseconds);
|
|
}
|
|
else
|
|
{
|
|
Message msg = Message.obtain();
|
|
msg.what = ALARM_EVENT;
|
|
|
|
mHandler.removeMessages(ALARM_EVENT);
|
|
mHandler.sendMessageAtTime(msg, alarm.when);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
|
|
if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
|
|
!= PackageManager.PERMISSION_GRANTED) {
|
|
pw.println("Permission Denial: can't dump AlarmManager from from pid="
|
|
+ Binder.getCallingPid()
|
|
+ ", uid=" + Binder.getCallingUid());
|
|
return;
|
|
}
|
|
|
|
synchronized (mLock) {
|
|
pw.println("Current Alarm Manager state:");
|
|
if (mRtcWakeupAlarms.size() > 0 || mRtcAlarms.size() > 0) {
|
|
final long now = System.currentTimeMillis();
|
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
|
pw.println(" ");
|
|
pw.print(" Realtime wakeup (now=");
|
|
pw.print(sdf.format(new Date(now))); pw.println("):");
|
|
if (mRtcWakeupAlarms.size() > 0) {
|
|
dumpAlarmList(pw, mRtcWakeupAlarms, " ", "RTC_WAKEUP", now);
|
|
}
|
|
if (mRtcAlarms.size() > 0) {
|
|
dumpAlarmList(pw, mRtcAlarms, " ", "RTC", now);
|
|
}
|
|
}
|
|
if (mElapsedRealtimeWakeupAlarms.size() > 0 || mElapsedRealtimeAlarms.size() > 0) {
|
|
final long now = SystemClock.elapsedRealtime();
|
|
pw.println(" ");
|
|
pw.print(" Elapsed realtime wakeup (now=");
|
|
TimeUtils.formatDuration(now, pw); pw.println("):");
|
|
if (mElapsedRealtimeWakeupAlarms.size() > 0) {
|
|
dumpAlarmList(pw, mElapsedRealtimeWakeupAlarms, " ", "ELAPSED_WAKEUP", now);
|
|
}
|
|
if (mElapsedRealtimeAlarms.size() > 0) {
|
|
dumpAlarmList(pw, mElapsedRealtimeAlarms, " ", "ELAPSED", now);
|
|
}
|
|
}
|
|
|
|
pw.println(" ");
|
|
pw.print(" Broadcast ref count: "); pw.println(mBroadcastRefCount);
|
|
|
|
pw.println(" ");
|
|
pw.println(" Alarm Stats:");
|
|
for (Map.Entry<String, BroadcastStats> be : mBroadcastStats.entrySet()) {
|
|
BroadcastStats bs = be.getValue();
|
|
pw.print(" "); pw.println(be.getKey());
|
|
pw.print(" "); pw.print(bs.aggregateTime);
|
|
pw.print("ms running, "); pw.print(bs.numWakeup);
|
|
pw.println(" wakeups");
|
|
for (Map.Entry<Intent.FilterComparison, FilterStats> fe
|
|
: bs.filterStats.entrySet()) {
|
|
pw.print(" "); pw.print(fe.getValue().count);
|
|
pw.print(" alarms: ");
|
|
pw.println(fe.getKey().getIntent().toShortString(true, false));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static final void dumpAlarmList(PrintWriter pw, ArrayList<Alarm> list,
|
|
String prefix, String label, long now) {
|
|
for (int i=list.size()-1; i>=0; i--) {
|
|
Alarm a = list.get(i);
|
|
pw.print(prefix); pw.print(label); pw.print(" #"); pw.print(i);
|
|
pw.print(": "); pw.println(a);
|
|
a.dump(pw, prefix + " ", now);
|
|
}
|
|
}
|
|
|
|
private native int init();
|
|
private native void close(int fd);
|
|
private native void set(int fd, int type, long seconds, long nanoseconds);
|
|
private native int waitForAlarm(int fd);
|
|
private native int setKernelTimezone(int fd, int minuteswest);
|
|
|
|
private void triggerAlarmsLocked(ArrayList<Alarm> alarmList,
|
|
ArrayList<Alarm> triggerList,
|
|
long now)
|
|
{
|
|
Iterator<Alarm> it = alarmList.iterator();
|
|
ArrayList<Alarm> repeats = new ArrayList<Alarm>();
|
|
|
|
while (it.hasNext())
|
|
{
|
|
Alarm alarm = it.next();
|
|
|
|
if (localLOGV) Slog.v(TAG, "Checking active alarm when=" + alarm.when + " " + alarm);
|
|
|
|
if (alarm.when > now) {
|
|
// don't fire alarms in the future
|
|
break;
|
|
}
|
|
|
|
// If the alarm is late, then print a warning message.
|
|
// Note that this can happen if the user creates a new event on
|
|
// the Calendar app with a reminder that is in the past. In that
|
|
// case, the reminder alarm will fire immediately.
|
|
if (localLOGV && now - alarm.when > LATE_ALARM_THRESHOLD) {
|
|
Slog.v(TAG, "alarm is late! alarm time: " + alarm.when
|
|
+ " now: " + now + " delay (in seconds): "
|
|
+ (now - alarm.when) / 1000);
|
|
}
|
|
|
|
// Recurring alarms may have passed several alarm intervals while the
|
|
// phone was asleep or off, so pass a trigger count when sending them.
|
|
if (localLOGV) Slog.v(TAG, "Alarm triggering: " + alarm);
|
|
alarm.count = 1;
|
|
if (alarm.repeatInterval > 0) {
|
|
// this adjustment will be zero if we're late by
|
|
// less than one full repeat interval
|
|
alarm.count += (now - alarm.when) / alarm.repeatInterval;
|
|
}
|
|
triggerList.add(alarm);
|
|
|
|
// remove the alarm from the list
|
|
it.remove();
|
|
|
|
// if it repeats queue it up to be read-added to the list
|
|
if (alarm.repeatInterval > 0) {
|
|
repeats.add(alarm);
|
|
}
|
|
}
|
|
|
|
// reset any repeating alarms.
|
|
it = repeats.iterator();
|
|
while (it.hasNext()) {
|
|
Alarm alarm = it.next();
|
|
alarm.when += alarm.count * alarm.repeatInterval;
|
|
addAlarmLocked(alarm);
|
|
}
|
|
|
|
if (alarmList.size() > 0) {
|
|
setLocked(alarmList.get(0));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This Comparator sorts Alarms into increasing time order.
|
|
*/
|
|
public static class IncreasingTimeOrder implements Comparator<Alarm> {
|
|
public int compare(Alarm a1, Alarm a2) {
|
|
long when1 = a1.when;
|
|
long when2 = a2.when;
|
|
if (when1 - when2 > 0) {
|
|
return 1;
|
|
}
|
|
if (when1 - when2 < 0) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private static class Alarm {
|
|
public int type;
|
|
public int count;
|
|
public long when;
|
|
public long repeatInterval;
|
|
public PendingIntent operation;
|
|
|
|
public Alarm() {
|
|
when = 0;
|
|
repeatInterval = 0;
|
|
operation = null;
|
|
}
|
|
|
|
@Override
|
|
public String toString()
|
|
{
|
|
StringBuilder sb = new StringBuilder(128);
|
|
sb.append("Alarm{");
|
|
sb.append(Integer.toHexString(System.identityHashCode(this)));
|
|
sb.append(" type ");
|
|
sb.append(type);
|
|
sb.append(" ");
|
|
sb.append(operation.getTargetPackage());
|
|
sb.append('}');
|
|
return sb.toString();
|
|
}
|
|
|
|
public void dump(PrintWriter pw, String prefix, long now) {
|
|
pw.print(prefix); pw.print("type="); pw.print(type);
|
|
pw.print(" when="); TimeUtils.formatDuration(when, now, pw);
|
|
pw.print(" repeatInterval="); pw.print(repeatInterval);
|
|
pw.print(" count="); pw.println(count);
|
|
pw.print(prefix); pw.print("operation="); pw.println(operation);
|
|
}
|
|
}
|
|
|
|
private class AlarmThread extends Thread
|
|
{
|
|
public AlarmThread()
|
|
{
|
|
super("AlarmManager");
|
|
}
|
|
|
|
public void run()
|
|
{
|
|
while (true)
|
|
{
|
|
int result = waitForAlarm(mDescriptor);
|
|
|
|
ArrayList<Alarm> triggerList = new ArrayList<Alarm>();
|
|
|
|
if ((result & TIME_CHANGED_MASK) != 0) {
|
|
remove(mTimeTickSender);
|
|
mClockReceiver.scheduleTimeTickEvent();
|
|
Intent intent = new Intent(Intent.ACTION_TIME_CHANGED);
|
|
intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
|
|
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
|
|
mContext.sendBroadcast(intent);
|
|
}
|
|
|
|
synchronized (mLock) {
|
|
final long nowRTC = System.currentTimeMillis();
|
|
final long nowELAPSED = SystemClock.elapsedRealtime();
|
|
if (localLOGV) Slog.v(
|
|
TAG, "Checking for alarms... rtc=" + nowRTC
|
|
+ ", elapsed=" + nowELAPSED);
|
|
|
|
if ((result & RTC_WAKEUP_MASK) != 0)
|
|
triggerAlarmsLocked(mRtcWakeupAlarms, triggerList, nowRTC);
|
|
|
|
if ((result & RTC_MASK) != 0)
|
|
triggerAlarmsLocked(mRtcAlarms, triggerList, nowRTC);
|
|
|
|
if ((result & ELAPSED_REALTIME_WAKEUP_MASK) != 0)
|
|
triggerAlarmsLocked(mElapsedRealtimeWakeupAlarms, triggerList, nowELAPSED);
|
|
|
|
if ((result & ELAPSED_REALTIME_MASK) != 0)
|
|
triggerAlarmsLocked(mElapsedRealtimeAlarms, triggerList, nowELAPSED);
|
|
|
|
// now trigger the alarms
|
|
Iterator<Alarm> it = triggerList.iterator();
|
|
while (it.hasNext()) {
|
|
Alarm alarm = it.next();
|
|
try {
|
|
if (localLOGV) Slog.v(TAG, "sending alarm " + alarm);
|
|
alarm.operation.send(mContext, 0,
|
|
mBackgroundIntent.putExtra(
|
|
Intent.EXTRA_ALARM_COUNT, alarm.count),
|
|
mResultReceiver, mHandler);
|
|
|
|
// we have an active broadcast so stay awake.
|
|
if (mBroadcastRefCount == 0) {
|
|
mWakeLock.acquire();
|
|
}
|
|
mBroadcastRefCount++;
|
|
|
|
BroadcastStats bs = getStatsLocked(alarm.operation);
|
|
if (bs.nesting == 0) {
|
|
bs.startTime = nowELAPSED;
|
|
} else {
|
|
bs.nesting++;
|
|
}
|
|
if (alarm.type == AlarmManager.ELAPSED_REALTIME_WAKEUP
|
|
|| alarm.type == AlarmManager.RTC_WAKEUP) {
|
|
bs.numWakeup++;
|
|
ActivityManagerNative.noteWakeupAlarm(
|
|
alarm.operation);
|
|
}
|
|
} catch (PendingIntent.CanceledException e) {
|
|
if (alarm.repeatInterval > 0) {
|
|
// This IntentSender is no longer valid, but this
|
|
// is a repeating alarm, so toss the hoser.
|
|
remove(alarm.operation);
|
|
}
|
|
} catch (RuntimeException e) {
|
|
Slog.w(TAG, "Failure sending alarm.", e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private class AlarmHandler extends Handler {
|
|
public static final int ALARM_EVENT = 1;
|
|
public static final int MINUTE_CHANGE_EVENT = 2;
|
|
public static final int DATE_CHANGE_EVENT = 3;
|
|
|
|
public AlarmHandler() {
|
|
}
|
|
|
|
public void handleMessage(Message msg) {
|
|
if (msg.what == ALARM_EVENT) {
|
|
ArrayList<Alarm> triggerList = new ArrayList<Alarm>();
|
|
synchronized (mLock) {
|
|
final long nowRTC = System.currentTimeMillis();
|
|
triggerAlarmsLocked(mRtcWakeupAlarms, triggerList, nowRTC);
|
|
triggerAlarmsLocked(mRtcAlarms, triggerList, nowRTC);
|
|
triggerAlarmsLocked(mElapsedRealtimeWakeupAlarms, triggerList, nowRTC);
|
|
triggerAlarmsLocked(mElapsedRealtimeAlarms, triggerList, nowRTC);
|
|
}
|
|
|
|
// now trigger the alarms without the lock held
|
|
Iterator<Alarm> it = triggerList.iterator();
|
|
while (it.hasNext())
|
|
{
|
|
Alarm alarm = it.next();
|
|
try {
|
|
alarm.operation.send();
|
|
} catch (PendingIntent.CanceledException e) {
|
|
if (alarm.repeatInterval > 0) {
|
|
// This IntentSender is no longer valid, but this
|
|
// is a repeating alarm, so toss the hoser.
|
|
remove(alarm.operation);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class ClockReceiver extends BroadcastReceiver {
|
|
public ClockReceiver() {
|
|
IntentFilter filter = new IntentFilter();
|
|
filter.addAction(Intent.ACTION_TIME_TICK);
|
|
filter.addAction(Intent.ACTION_DATE_CHANGED);
|
|
mContext.registerReceiver(this, filter);
|
|
}
|
|
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
if (intent.getAction().equals(Intent.ACTION_TIME_TICK)) {
|
|
scheduleTimeTickEvent();
|
|
} else if (intent.getAction().equals(Intent.ACTION_DATE_CHANGED)) {
|
|
// Since the kernel does not keep track of DST, we need to
|
|
// reset the TZ information at the beginning of each day
|
|
// based off of the current Zone gmt offset + userspace tracked
|
|
// daylight savings information.
|
|
TimeZone zone = TimeZone.getTimeZone(SystemProperties.get(TIMEZONE_PROPERTY));
|
|
int gmtOffset = (zone.getRawOffset() + zone.getDSTSavings()) / 60000;
|
|
|
|
setKernelTimezone(mDescriptor, -(gmtOffset));
|
|
scheduleDateChangedEvent();
|
|
}
|
|
}
|
|
|
|
public void scheduleTimeTickEvent() {
|
|
Calendar calendar = Calendar.getInstance();
|
|
calendar.setTimeInMillis(System.currentTimeMillis());
|
|
calendar.add(Calendar.MINUTE, 1);
|
|
calendar.set(Calendar.SECOND, 0);
|
|
calendar.set(Calendar.MILLISECOND, 0);
|
|
|
|
set(AlarmManager.RTC, calendar.getTimeInMillis(), mTimeTickSender);
|
|
}
|
|
|
|
public void scheduleDateChangedEvent() {
|
|
Calendar calendar = Calendar.getInstance();
|
|
calendar.setTimeInMillis(System.currentTimeMillis());
|
|
calendar.set(Calendar.HOUR, 0);
|
|
calendar.set(Calendar.MINUTE, 0);
|
|
calendar.set(Calendar.SECOND, 0);
|
|
calendar.set(Calendar.MILLISECOND, 0);
|
|
calendar.add(Calendar.DAY_OF_MONTH, 1);
|
|
|
|
set(AlarmManager.RTC, calendar.getTimeInMillis(), mDateChangeSender);
|
|
}
|
|
}
|
|
|
|
class UninstallReceiver extends BroadcastReceiver {
|
|
public UninstallReceiver() {
|
|
IntentFilter filter = new IntentFilter();
|
|
filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
|
|
filter.addAction(Intent.ACTION_PACKAGE_RESTARTED);
|
|
filter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART);
|
|
filter.addDataScheme("package");
|
|
mContext.registerReceiver(this, filter);
|
|
// Register for events related to sdcard installation.
|
|
IntentFilter sdFilter = new IntentFilter();
|
|
sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
|
|
mContext.registerReceiver(this, sdFilter);
|
|
}
|
|
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
synchronized (mLock) {
|
|
String action = intent.getAction();
|
|
String pkgList[] = null;
|
|
if (Intent.ACTION_QUERY_PACKAGE_RESTART.equals(action)) {
|
|
pkgList = intent.getStringArrayExtra(Intent.EXTRA_PACKAGES);
|
|
for (String packageName : pkgList) {
|
|
if (lookForPackageLocked(packageName)) {
|
|
setResultCode(Activity.RESULT_OK);
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
} else if (Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(action)) {
|
|
pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
|
|
} else {
|
|
if (Intent.ACTION_PACKAGE_REMOVED.equals(action)
|
|
&& intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) {
|
|
// This package is being updated; don't kill its alarms.
|
|
return;
|
|
}
|
|
Uri data = intent.getData();
|
|
if (data != null) {
|
|
String pkg = data.getSchemeSpecificPart();
|
|
if (pkg != null) {
|
|
pkgList = new String[]{pkg};
|
|
}
|
|
}
|
|
}
|
|
if (pkgList != null && (pkgList.length > 0)) {
|
|
for (String pkg : pkgList) {
|
|
removeLocked(pkg);
|
|
mBroadcastStats.remove(pkg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private final BroadcastStats getStatsLocked(PendingIntent pi) {
|
|
String pkg = pi.getTargetPackage();
|
|
BroadcastStats bs = mBroadcastStats.get(pkg);
|
|
if (bs == null) {
|
|
bs = new BroadcastStats();
|
|
mBroadcastStats.put(pkg, bs);
|
|
}
|
|
return bs;
|
|
}
|
|
|
|
class ResultReceiver implements PendingIntent.OnFinished {
|
|
public void onSendFinished(PendingIntent pi, Intent intent, int resultCode,
|
|
String resultData, Bundle resultExtras) {
|
|
synchronized (mLock) {
|
|
BroadcastStats bs = getStatsLocked(pi);
|
|
if (bs != null) {
|
|
bs.nesting--;
|
|
if (bs.nesting <= 0) {
|
|
bs.nesting = 0;
|
|
bs.aggregateTime += SystemClock.elapsedRealtime()
|
|
- bs.startTime;
|
|
Intent.FilterComparison fc = new Intent.FilterComparison(intent);
|
|
FilterStats fs = bs.filterStats.get(fc);
|
|
if (fs == null) {
|
|
fs = new FilterStats();
|
|
bs.filterStats.put(fc, fs);
|
|
}
|
|
fs.count++;
|
|
}
|
|
}
|
|
mBroadcastRefCount--;
|
|
if (mBroadcastRefCount == 0) {
|
|
mWakeLock.release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|