PageRenderTime 65ms CodeModel.GetById 28ms RepoModel.GetById 0ms app.codeStats 1ms

/services/java/com/android/server/AlarmManagerService.java

https://github.com/aizuzi/platform_frameworks_base
Java | 1506 lines | 1267 code | 149 blank | 90 comment | 246 complexity | c5c0b9c78b9aa393110d4af774731447 MD5 | raw file
  1. /*
  2. * Copyright (C) 2006 The Android Open Source Project
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. * http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */
  16. package com.android.server;
  17. import android.app.Activity;
  18. import android.app.ActivityManagerNative;
  19. import android.app.AlarmManager;
  20. import android.app.IAlarmManager;
  21. import android.app.PendingIntent;
  22. import android.content.BroadcastReceiver;
  23. import android.content.ComponentName;
  24. import android.content.Context;
  25. import android.content.Intent;
  26. import android.content.IntentFilter;
  27. import android.content.pm.PackageManager;
  28. import android.net.Uri;
  29. import android.os.Binder;
  30. import android.os.Bundle;
  31. import android.os.Handler;
  32. import android.os.Message;
  33. import android.os.PowerManager;
  34. import android.os.SystemClock;
  35. import android.os.SystemProperties;
  36. import android.os.UserHandle;
  37. import android.os.WorkSource;
  38. import android.text.TextUtils;
  39. import android.util.Pair;
  40. import android.util.Slog;
  41. import android.util.TimeUtils;
  42. import java.io.ByteArrayOutputStream;
  43. import java.io.FileDescriptor;
  44. import java.io.PrintWriter;
  45. import java.text.SimpleDateFormat;
  46. import java.util.ArrayList;
  47. import java.util.Arrays;
  48. import java.util.Calendar;
  49. import java.util.Collections;
  50. import java.util.Comparator;
  51. import java.util.Date;
  52. import java.util.HashMap;
  53. import java.util.LinkedList;
  54. import java.util.Map;
  55. import java.util.TimeZone;
  56. import static android.app.AlarmManager.RTC_WAKEUP;
  57. import static android.app.AlarmManager.RTC;
  58. import static android.app.AlarmManager.ELAPSED_REALTIME_WAKEUP;
  59. import static android.app.AlarmManager.ELAPSED_REALTIME;
  60. import com.android.internal.util.LocalLog;
  61. class AlarmManagerService extends IAlarmManager.Stub {
  62. // The threshold for how long an alarm can be late before we print a
  63. // warning message. The time duration is in milliseconds.
  64. private static final long LATE_ALARM_THRESHOLD = 10 * 1000;
  65. private static final int RTC_WAKEUP_MASK = 1 << RTC_WAKEUP;
  66. private static final int RTC_MASK = 1 << RTC;
  67. private static final int ELAPSED_REALTIME_WAKEUP_MASK = 1 << ELAPSED_REALTIME_WAKEUP;
  68. private static final int ELAPSED_REALTIME_MASK = 1 << ELAPSED_REALTIME;
  69. private static final int TIME_CHANGED_MASK = 1 << 16;
  70. private static final int IS_WAKEUP_MASK = RTC_WAKEUP_MASK|ELAPSED_REALTIME_WAKEUP_MASK;
  71. // Mask for testing whether a given alarm type is wakeup vs non-wakeup
  72. private static final int TYPE_NONWAKEUP_MASK = 0x1; // low bit => non-wakeup
  73. private static final String TAG = "AlarmManager";
  74. private static final String ClockReceiver_TAG = "ClockReceiver";
  75. private static final boolean localLOGV = false;
  76. private static final boolean DEBUG_BATCH = localLOGV || false;
  77. private static final boolean DEBUG_VALIDATE = localLOGV || false;
  78. private static final int ALARM_EVENT = 1;
  79. private static final String TIMEZONE_PROPERTY = "persist.sys.timezone";
  80. private static final Intent mBackgroundIntent
  81. = new Intent().addFlags(Intent.FLAG_FROM_BACKGROUND);
  82. private static final IncreasingTimeOrder sIncreasingTimeOrder = new IncreasingTimeOrder();
  83. private static final boolean WAKEUP_STATS = false;
  84. private final Context mContext;
  85. private final LocalLog mLog = new LocalLog(TAG);
  86. private Object mLock = new Object();
  87. private long mNativeData;
  88. private long mNextWakeup;
  89. private long mNextNonWakeup;
  90. private int mBroadcastRefCount = 0;
  91. private PowerManager.WakeLock mWakeLock;
  92. private ArrayList<InFlight> mInFlight = new ArrayList<InFlight>();
  93. private final AlarmThread mWaitThread = new AlarmThread();
  94. private final AlarmHandler mHandler = new AlarmHandler();
  95. private ClockReceiver mClockReceiver;
  96. private UninstallReceiver mUninstallReceiver;
  97. private final ResultReceiver mResultReceiver = new ResultReceiver();
  98. private final PendingIntent mTimeTickSender;
  99. private final PendingIntent mDateChangeSender;
  100. class WakeupEvent {
  101. public long when;
  102. public int uid;
  103. public String action;
  104. public WakeupEvent(long theTime, int theUid, String theAction) {
  105. when = theTime;
  106. uid = theUid;
  107. action = theAction;
  108. }
  109. }
  110. private final LinkedList<WakeupEvent> mRecentWakeups = new LinkedList<WakeupEvent>();
  111. private final long RECENT_WAKEUP_PERIOD = 1000L * 60 * 60 * 24; // one day
  112. static final class Batch {
  113. long start; // These endpoints are always in ELAPSED
  114. long end;
  115. boolean standalone; // certain "batches" don't participate in coalescing
  116. final ArrayList<Alarm> alarms = new ArrayList<Alarm>();
  117. Batch() {
  118. start = 0;
  119. end = Long.MAX_VALUE;
  120. }
  121. Batch(Alarm seed) {
  122. start = seed.whenElapsed;
  123. end = seed.maxWhen;
  124. alarms.add(seed);
  125. }
  126. int size() {
  127. return alarms.size();
  128. }
  129. Alarm get(int index) {
  130. return alarms.get(index);
  131. }
  132. boolean canHold(long whenElapsed, long maxWhen) {
  133. return (end >= whenElapsed) && (start <= maxWhen);
  134. }
  135. boolean add(Alarm alarm) {
  136. boolean newStart = false;
  137. // narrows the batch if necessary; presumes that canHold(alarm) is true
  138. int index = Collections.binarySearch(alarms, alarm, sIncreasingTimeOrder);
  139. if (index < 0) {
  140. index = 0 - index - 1;
  141. }
  142. alarms.add(index, alarm);
  143. if (DEBUG_BATCH) {
  144. Slog.v(TAG, "Adding " + alarm + " to " + this);
  145. }
  146. if (alarm.whenElapsed > start) {
  147. start = alarm.whenElapsed;
  148. newStart = true;
  149. }
  150. if (alarm.maxWhen < end) {
  151. end = alarm.maxWhen;
  152. }
  153. if (DEBUG_BATCH) {
  154. Slog.v(TAG, " => now " + this);
  155. }
  156. return newStart;
  157. }
  158. boolean remove(final PendingIntent operation) {
  159. boolean didRemove = false;
  160. long newStart = 0; // recalculate endpoints as we go
  161. long newEnd = Long.MAX_VALUE;
  162. for (int i = 0; i < alarms.size(); ) {
  163. Alarm alarm = alarms.get(i);
  164. if (alarm.operation.equals(operation)) {
  165. alarms.remove(i);
  166. didRemove = true;
  167. } else {
  168. if (alarm.whenElapsed > newStart) {
  169. newStart = alarm.whenElapsed;
  170. }
  171. if (alarm.maxWhen < newEnd) {
  172. newEnd = alarm.maxWhen;
  173. }
  174. i++;
  175. }
  176. }
  177. if (didRemove) {
  178. // commit the new batch bounds
  179. start = newStart;
  180. end = newEnd;
  181. }
  182. return didRemove;
  183. }
  184. boolean remove(final String packageName) {
  185. boolean didRemove = false;
  186. long newStart = 0; // recalculate endpoints as we go
  187. long newEnd = Long.MAX_VALUE;
  188. for (int i = 0; i < alarms.size(); ) {
  189. Alarm alarm = alarms.get(i);
  190. if (alarm.operation.getTargetPackage().equals(packageName)) {
  191. alarms.remove(i);
  192. didRemove = true;
  193. } else {
  194. if (alarm.whenElapsed > newStart) {
  195. newStart = alarm.whenElapsed;
  196. }
  197. if (alarm.maxWhen < newEnd) {
  198. newEnd = alarm.maxWhen;
  199. }
  200. i++;
  201. }
  202. }
  203. if (didRemove) {
  204. // commit the new batch bounds
  205. start = newStart;
  206. end = newEnd;
  207. }
  208. return didRemove;
  209. }
  210. boolean remove(final int userHandle) {
  211. boolean didRemove = false;
  212. long newStart = 0; // recalculate endpoints as we go
  213. long newEnd = Long.MAX_VALUE;
  214. for (int i = 0; i < alarms.size(); ) {
  215. Alarm alarm = alarms.get(i);
  216. if (UserHandle.getUserId(alarm.operation.getCreatorUid()) == userHandle) {
  217. alarms.remove(i);
  218. didRemove = true;
  219. } else {
  220. if (alarm.whenElapsed > newStart) {
  221. newStart = alarm.whenElapsed;
  222. }
  223. if (alarm.maxWhen < newEnd) {
  224. newEnd = alarm.maxWhen;
  225. }
  226. i++;
  227. }
  228. }
  229. if (didRemove) {
  230. // commit the new batch bounds
  231. start = newStart;
  232. end = newEnd;
  233. }
  234. return didRemove;
  235. }
  236. boolean hasPackage(final String packageName) {
  237. final int N = alarms.size();
  238. for (int i = 0; i < N; i++) {
  239. Alarm a = alarms.get(i);
  240. if (a.operation.getTargetPackage().equals(packageName)) {
  241. return true;
  242. }
  243. }
  244. return false;
  245. }
  246. boolean hasWakeups() {
  247. final int N = alarms.size();
  248. for (int i = 0; i < N; i++) {
  249. Alarm a = alarms.get(i);
  250. // non-wakeup alarms are types 1 and 3, i.e. have the low bit set
  251. if ((a.type & TYPE_NONWAKEUP_MASK) == 0) {
  252. return true;
  253. }
  254. }
  255. return false;
  256. }
  257. @Override
  258. public String toString() {
  259. StringBuilder b = new StringBuilder(40);
  260. b.append("Batch{"); b.append(Integer.toHexString(this.hashCode()));
  261. b.append(" num="); b.append(size());
  262. b.append(" start="); b.append(start);
  263. b.append(" end="); b.append(end);
  264. if (standalone) {
  265. b.append(" STANDALONE");
  266. }
  267. b.append('}');
  268. return b.toString();
  269. }
  270. }
  271. static class BatchTimeOrder implements Comparator<Batch> {
  272. public int compare(Batch b1, Batch b2) {
  273. long when1 = b1.start;
  274. long when2 = b2.start;
  275. if (when1 - when2 > 0) {
  276. return 1;
  277. }
  278. if (when1 - when2 < 0) {
  279. return -1;
  280. }
  281. return 0;
  282. }
  283. }
  284. // minimum recurrence period or alarm futurity for us to be able to fuzz it
  285. private static final long MIN_FUZZABLE_INTERVAL = 10000;
  286. private static final BatchTimeOrder sBatchOrder = new BatchTimeOrder();
  287. private final ArrayList<Batch> mAlarmBatches = new ArrayList<Batch>();
  288. static long convertToElapsed(long when, int type) {
  289. final boolean isRtc = (type == RTC || type == RTC_WAKEUP);
  290. if (isRtc) {
  291. when -= System.currentTimeMillis() - SystemClock.elapsedRealtime();
  292. }
  293. return when;
  294. }
  295. // Apply a heuristic to { recurrence interval, futurity of the trigger time } to
  296. // calculate the end of our nominal delivery window for the alarm.
  297. static long maxTriggerTime(long now, long triggerAtTime, long interval) {
  298. // Current heuristic: batchable window is 75% of either the recurrence interval
  299. // [for a periodic alarm] or of the time from now to the desired delivery time,
  300. // with a minimum delay/interval of 10 seconds, under which we will simply not
  301. // defer the alarm.
  302. long futurity = (interval == 0)
  303. ? (triggerAtTime - now)
  304. : interval;
  305. if (futurity < MIN_FUZZABLE_INTERVAL) {
  306. futurity = 0;
  307. }
  308. return triggerAtTime + (long)(.75 * futurity);
  309. }
  310. // returns true if the batch was added at the head
  311. static boolean addBatchLocked(ArrayList<Batch> list, Batch newBatch) {
  312. int index = Collections.binarySearch(list, newBatch, sBatchOrder);
  313. if (index < 0) {
  314. index = 0 - index - 1;
  315. }
  316. list.add(index, newBatch);
  317. return (index == 0);
  318. }
  319. // Return the index of the matching batch, or -1 if none found.
  320. int attemptCoalesceLocked(long whenElapsed, long maxWhen) {
  321. final int N = mAlarmBatches.size();
  322. for (int i = 0; i < N; i++) {
  323. Batch b = mAlarmBatches.get(i);
  324. if (!b.standalone && b.canHold(whenElapsed, maxWhen)) {
  325. return i;
  326. }
  327. }
  328. return -1;
  329. }
  330. // The RTC clock has moved arbitrarily, so we need to recalculate all the batching
  331. void rebatchAllAlarms() {
  332. synchronized (mLock) {
  333. rebatchAllAlarmsLocked(true);
  334. }
  335. }
  336. void rebatchAllAlarmsLocked(boolean doValidate) {
  337. ArrayList<Batch> oldSet = (ArrayList<Batch>) mAlarmBatches.clone();
  338. mAlarmBatches.clear();
  339. final long nowElapsed = SystemClock.elapsedRealtime();
  340. final int oldBatches = oldSet.size();
  341. for (int batchNum = 0; batchNum < oldBatches; batchNum++) {
  342. Batch batch = oldSet.get(batchNum);
  343. final int N = batch.size();
  344. for (int i = 0; i < N; i++) {
  345. Alarm a = batch.get(i);
  346. long whenElapsed = convertToElapsed(a.when, a.type);
  347. final long maxElapsed;
  348. if (a.whenElapsed == a.maxWhen) {
  349. // Exact
  350. maxElapsed = whenElapsed;
  351. } else {
  352. // Not exact. Preserve any explicit window, otherwise recalculate
  353. // the window based on the alarm's new futurity. Note that this
  354. // reflects a policy of preferring timely to deferred delivery.
  355. maxElapsed = (a.windowLength > 0)
  356. ? (whenElapsed + a.windowLength)
  357. : maxTriggerTime(nowElapsed, whenElapsed, a.repeatInterval);
  358. }
  359. setImplLocked(a.type, a.when, whenElapsed, a.windowLength, maxElapsed,
  360. a.repeatInterval, a.operation, batch.standalone, doValidate, a.workSource);
  361. }
  362. }
  363. }
  364. private static final class InFlight extends Intent {
  365. final PendingIntent mPendingIntent;
  366. final WorkSource mWorkSource;
  367. final Pair<String, ComponentName> mTarget;
  368. final BroadcastStats mBroadcastStats;
  369. final FilterStats mFilterStats;
  370. InFlight(AlarmManagerService service, PendingIntent pendingIntent, WorkSource workSource) {
  371. mPendingIntent = pendingIntent;
  372. mWorkSource = workSource;
  373. Intent intent = pendingIntent.getIntent();
  374. mTarget = intent != null
  375. ? new Pair<String, ComponentName>(intent.getAction(), intent.getComponent())
  376. : null;
  377. mBroadcastStats = service.getStatsLocked(pendingIntent);
  378. FilterStats fs = mBroadcastStats.filterStats.get(mTarget);
  379. if (fs == null) {
  380. fs = new FilterStats(mBroadcastStats, mTarget);
  381. mBroadcastStats.filterStats.put(mTarget, fs);
  382. }
  383. mFilterStats = fs;
  384. }
  385. }
  386. private static final class FilterStats {
  387. final BroadcastStats mBroadcastStats;
  388. final Pair<String, ComponentName> mTarget;
  389. long aggregateTime;
  390. int count;
  391. int numWakeup;
  392. long startTime;
  393. int nesting;
  394. FilterStats(BroadcastStats broadcastStats, Pair<String, ComponentName> target) {
  395. mBroadcastStats = broadcastStats;
  396. mTarget = target;
  397. }
  398. }
  399. private static final class BroadcastStats {
  400. final String mPackageName;
  401. long aggregateTime;
  402. int count;
  403. int numWakeup;
  404. long startTime;
  405. int nesting;
  406. final HashMap<Pair<String, ComponentName>, FilterStats> filterStats
  407. = new HashMap<Pair<String, ComponentName>, FilterStats>();
  408. BroadcastStats(String packageName) {
  409. mPackageName = packageName;
  410. }
  411. }
  412. private final HashMap<String, BroadcastStats> mBroadcastStats
  413. = new HashMap<String, BroadcastStats>();
  414. public AlarmManagerService(Context context) {
  415. mContext = context;
  416. mNativeData = init();
  417. mNextWakeup = mNextNonWakeup = 0;
  418. // We have to set current TimeZone info to kernel
  419. // because kernel doesn't keep this after reboot
  420. String tz = SystemProperties.get(TIMEZONE_PROPERTY);
  421. if (tz != null) {
  422. setTimeZone(tz);
  423. }
  424. PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
  425. mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
  426. mTimeTickSender = PendingIntent.getBroadcastAsUser(context, 0,
  427. new Intent(Intent.ACTION_TIME_TICK).addFlags(
  428. Intent.FLAG_RECEIVER_REGISTERED_ONLY
  429. | Intent.FLAG_RECEIVER_FOREGROUND), 0,
  430. UserHandle.ALL);
  431. Intent intent = new Intent(Intent.ACTION_DATE_CHANGED);
  432. intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
  433. mDateChangeSender = PendingIntent.getBroadcastAsUser(context, 0, intent,
  434. Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT, UserHandle.ALL);
  435. // now that we have initied the driver schedule the alarm
  436. mClockReceiver= new ClockReceiver();
  437. mClockReceiver.scheduleTimeTickEvent();
  438. mClockReceiver.scheduleDateChangedEvent();
  439. mUninstallReceiver = new UninstallReceiver();
  440. if (mNativeData != 0) {
  441. mWaitThread.start();
  442. } else {
  443. Slog.w(TAG, "Failed to open alarm driver. Falling back to a handler.");
  444. }
  445. }
  446. protected void finalize() throws Throwable {
  447. try {
  448. close(mNativeData);
  449. } finally {
  450. super.finalize();
  451. }
  452. }
  453. @Override
  454. public void set(int type, long triggerAtTime, long windowLength, long interval,
  455. PendingIntent operation, WorkSource workSource) {
  456. if (workSource != null) {
  457. mContext.enforceCallingPermission(
  458. android.Manifest.permission.UPDATE_DEVICE_STATS,
  459. "AlarmManager.set");
  460. }
  461. set(type, triggerAtTime, windowLength, interval, operation, false, workSource);
  462. }
  463. public void set(int type, long triggerAtTime, long windowLength, long interval,
  464. PendingIntent operation, boolean isStandalone, WorkSource workSource) {
  465. if (operation == null) {
  466. Slog.w(TAG, "set/setRepeating ignored because there is no intent");
  467. return;
  468. }
  469. // Sanity check the window length. This will catch people mistakenly
  470. // trying to pass an end-of-window timestamp rather than a duration.
  471. if (windowLength > AlarmManager.INTERVAL_HALF_DAY) {
  472. Slog.w(TAG, "Window length " + windowLength
  473. + "ms suspiciously long; limiting to 1 hour");
  474. windowLength = AlarmManager.INTERVAL_HOUR;
  475. }
  476. if (type < RTC_WAKEUP || type > ELAPSED_REALTIME) {
  477. throw new IllegalArgumentException("Invalid alarm type " + type);
  478. }
  479. if (triggerAtTime < 0) {
  480. final long who = Binder.getCallingUid();
  481. final long what = Binder.getCallingPid();
  482. Slog.w(TAG, "Invalid alarm trigger time! " + triggerAtTime + " from uid=" + who
  483. + " pid=" + what);
  484. triggerAtTime = 0;
  485. }
  486. final long nowElapsed = SystemClock.elapsedRealtime();
  487. final long triggerElapsed = convertToElapsed(triggerAtTime, type);
  488. final long maxElapsed;
  489. if (windowLength == AlarmManager.WINDOW_EXACT) {
  490. maxElapsed = triggerElapsed;
  491. } else if (windowLength < 0) {
  492. maxElapsed = maxTriggerTime(nowElapsed, triggerElapsed, interval);
  493. } else {
  494. maxElapsed = triggerElapsed + windowLength;
  495. }
  496. synchronized (mLock) {
  497. if (DEBUG_BATCH) {
  498. Slog.v(TAG, "set(" + operation + ") : type=" + type
  499. + " triggerAtTime=" + triggerAtTime + " win=" + windowLength
  500. + " tElapsed=" + triggerElapsed + " maxElapsed=" + maxElapsed
  501. + " interval=" + interval + " standalone=" + isStandalone);
  502. }
  503. setImplLocked(type, triggerAtTime, triggerElapsed, windowLength, maxElapsed,
  504. interval, operation, isStandalone, true, workSource);
  505. }
  506. }
  507. private void setImplLocked(int type, long when, long whenElapsed, long windowLength,
  508. long maxWhen, long interval, PendingIntent operation, boolean isStandalone,
  509. boolean doValidate, WorkSource workSource) {
  510. Alarm a = new Alarm(type, when, whenElapsed, windowLength, maxWhen, interval,
  511. operation, workSource);
  512. removeLocked(operation);
  513. int whichBatch = (isStandalone) ? -1 : attemptCoalesceLocked(whenElapsed, maxWhen);
  514. if (whichBatch < 0) {
  515. Batch batch = new Batch(a);
  516. batch.standalone = isStandalone;
  517. addBatchLocked(mAlarmBatches, batch);
  518. } else {
  519. Batch batch = mAlarmBatches.get(whichBatch);
  520. if (batch.add(a)) {
  521. // The start time of this batch advanced, so batch ordering may
  522. // have just been broken. Move it to where it now belongs.
  523. mAlarmBatches.remove(whichBatch);
  524. addBatchLocked(mAlarmBatches, batch);
  525. }
  526. }
  527. if (DEBUG_VALIDATE) {
  528. if (doValidate && !validateConsistencyLocked()) {
  529. Slog.v(TAG, "Tipping-point operation: type=" + type + " when=" + when
  530. + " when(hex)=" + Long.toHexString(when)
  531. + " whenElapsed=" + whenElapsed + " maxWhen=" + maxWhen
  532. + " interval=" + interval + " op=" + operation
  533. + " standalone=" + isStandalone);
  534. rebatchAllAlarmsLocked(false);
  535. }
  536. }
  537. rescheduleKernelAlarmsLocked();
  538. }
  539. private void logBatchesLocked() {
  540. ByteArrayOutputStream bs = new ByteArrayOutputStream(2048);
  541. PrintWriter pw = new PrintWriter(bs);
  542. final long nowRTC = System.currentTimeMillis();
  543. final long nowELAPSED = SystemClock.elapsedRealtime();
  544. final int NZ = mAlarmBatches.size();
  545. for (int iz = 0; iz < NZ; iz++) {
  546. Batch bz = mAlarmBatches.get(iz);
  547. pw.append("Batch "); pw.print(iz); pw.append(": "); pw.println(bz);
  548. dumpAlarmList(pw, bz.alarms, " ", nowELAPSED, nowRTC);
  549. pw.flush();
  550. Slog.v(TAG, bs.toString());
  551. bs.reset();
  552. }
  553. }
  554. private boolean validateConsistencyLocked() {
  555. if (DEBUG_VALIDATE) {
  556. long lastTime = Long.MIN_VALUE;
  557. final int N = mAlarmBatches.size();
  558. for (int i = 0; i < N; i++) {
  559. Batch b = mAlarmBatches.get(i);
  560. if (b.start >= lastTime) {
  561. // duplicate start times are okay because of standalone batches
  562. lastTime = b.start;
  563. } else {
  564. Slog.e(TAG, "CONSISTENCY FAILURE: Batch " + i + " is out of order");
  565. logBatchesLocked();
  566. return false;
  567. }
  568. }
  569. }
  570. return true;
  571. }
  572. private Batch findFirstWakeupBatchLocked() {
  573. final int N = mAlarmBatches.size();
  574. for (int i = 0; i < N; i++) {
  575. Batch b = mAlarmBatches.get(i);
  576. if (b.hasWakeups()) {
  577. return b;
  578. }
  579. }
  580. return null;
  581. }
  582. private void rescheduleKernelAlarmsLocked() {
  583. // Schedule the next upcoming wakeup alarm. If there is a deliverable batch
  584. // prior to that which contains no wakeups, we schedule that as well.
  585. if (mAlarmBatches.size() > 0) {
  586. final Batch firstWakeup = findFirstWakeupBatchLocked();
  587. final Batch firstBatch = mAlarmBatches.get(0);
  588. if (firstWakeup != null && mNextWakeup != firstWakeup.start) {
  589. mNextWakeup = firstWakeup.start;
  590. setLocked(ELAPSED_REALTIME_WAKEUP, firstWakeup.start);
  591. }
  592. if (firstBatch != firstWakeup && mNextNonWakeup != firstBatch.start) {
  593. mNextNonWakeup = firstBatch.start;
  594. setLocked(ELAPSED_REALTIME, firstBatch.start);
  595. }
  596. }
  597. }
  598. public boolean setTime(long millis) {
  599. mContext.enforceCallingOrSelfPermission(
  600. "android.permission.SET_TIME",
  601. "setTime");
  602. if (mNativeData == 0) {
  603. Slog.w(TAG, "Not setting time since no alarm driver is available.");
  604. return false;
  605. }
  606. synchronized (mLock) {
  607. return setKernelTime(mNativeData, millis) == 0;
  608. }
  609. }
  610. public void setTimeZone(String tz) {
  611. mContext.enforceCallingOrSelfPermission(
  612. "android.permission.SET_TIME_ZONE",
  613. "setTimeZone");
  614. long oldId = Binder.clearCallingIdentity();
  615. try {
  616. if (TextUtils.isEmpty(tz)) return;
  617. TimeZone zone = TimeZone.getTimeZone(tz);
  618. // Prevent reentrant calls from stepping on each other when writing
  619. // the time zone property
  620. boolean timeZoneWasChanged = false;
  621. synchronized (this) {
  622. String current = SystemProperties.get(TIMEZONE_PROPERTY);
  623. if (current == null || !current.equals(zone.getID())) {
  624. if (localLOGV) {
  625. Slog.v(TAG, "timezone changed: " + current + ", new=" + zone.getID());
  626. }
  627. timeZoneWasChanged = true;
  628. SystemProperties.set(TIMEZONE_PROPERTY, zone.getID());
  629. }
  630. // Update the kernel timezone information
  631. // Kernel tracks time offsets as 'minutes west of GMT'
  632. int gmtOffset = zone.getOffset(System.currentTimeMillis());
  633. setKernelTimezone(mNativeData, -(gmtOffset / 60000));
  634. }
  635. TimeZone.setDefault(null);
  636. if (timeZoneWasChanged) {
  637. Intent intent = new Intent(Intent.ACTION_TIMEZONE_CHANGED);
  638. intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
  639. intent.putExtra("time-zone", zone.getID());
  640. mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
  641. }
  642. } finally {
  643. Binder.restoreCallingIdentity(oldId);
  644. }
  645. }
  646. public void remove(PendingIntent operation) {
  647. if (operation == null) {
  648. return;
  649. }
  650. synchronized (mLock) {
  651. removeLocked(operation);
  652. }
  653. }
  654. public void removeLocked(PendingIntent operation) {
  655. boolean didRemove = false;
  656. for (int i = mAlarmBatches.size() - 1; i >= 0; i--) {
  657. Batch b = mAlarmBatches.get(i);
  658. didRemove |= b.remove(operation);
  659. if (b.size() == 0) {
  660. mAlarmBatches.remove(i);
  661. }
  662. }
  663. if (didRemove) {
  664. if (DEBUG_BATCH) {
  665. Slog.v(TAG, "remove(operation) changed bounds; rebatching");
  666. }
  667. rebatchAllAlarmsLocked(true);
  668. rescheduleKernelAlarmsLocked();
  669. }
  670. }
  671. public void removeLocked(String packageName) {
  672. boolean didRemove = false;
  673. for (int i = mAlarmBatches.size() - 1; i >= 0; i--) {
  674. Batch b = mAlarmBatches.get(i);
  675. didRemove |= b.remove(packageName);
  676. if (b.size() == 0) {
  677. mAlarmBatches.remove(i);
  678. }
  679. }
  680. if (didRemove) {
  681. if (DEBUG_BATCH) {
  682. Slog.v(TAG, "remove(package) changed bounds; rebatching");
  683. }
  684. rebatchAllAlarmsLocked(true);
  685. rescheduleKernelAlarmsLocked();
  686. }
  687. }
  688. public void removeUserLocked(int userHandle) {
  689. boolean didRemove = false;
  690. for (int i = mAlarmBatches.size() - 1; i >= 0; i--) {
  691. Batch b = mAlarmBatches.get(i);
  692. didRemove |= b.remove(userHandle);
  693. if (b.size() == 0) {
  694. mAlarmBatches.remove(i);
  695. }
  696. }
  697. if (didRemove) {
  698. if (DEBUG_BATCH) {
  699. Slog.v(TAG, "remove(user) changed bounds; rebatching");
  700. }
  701. rebatchAllAlarmsLocked(true);
  702. rescheduleKernelAlarmsLocked();
  703. }
  704. }
  705. public boolean lookForPackageLocked(String packageName) {
  706. for (int i = 0; i < mAlarmBatches.size(); i++) {
  707. Batch b = mAlarmBatches.get(i);
  708. if (b.hasPackage(packageName)) {
  709. return true;
  710. }
  711. }
  712. return false;
  713. }
  714. private void setLocked(int type, long when)
  715. {
  716. if (mNativeData != 0)
  717. {
  718. // The kernel never triggers alarms with negative wakeup times
  719. // so we ensure they are positive.
  720. long alarmSeconds, alarmNanoseconds;
  721. if (when < 0) {
  722. alarmSeconds = 0;
  723. alarmNanoseconds = 0;
  724. } else {
  725. alarmSeconds = when / 1000;
  726. alarmNanoseconds = (when % 1000) * 1000 * 1000;
  727. }
  728. set(mNativeData, type, alarmSeconds, alarmNanoseconds);
  729. }
  730. else
  731. {
  732. Message msg = Message.obtain();
  733. msg.what = ALARM_EVENT;
  734. mHandler.removeMessages(ALARM_EVENT);
  735. mHandler.sendMessageAtTime(msg, when);
  736. }
  737. }
  738. @Override
  739. protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
  740. if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
  741. != PackageManager.PERMISSION_GRANTED) {
  742. pw.println("Permission Denial: can't dump AlarmManager from from pid="
  743. + Binder.getCallingPid()
  744. + ", uid=" + Binder.getCallingUid());
  745. return;
  746. }
  747. synchronized (mLock) {
  748. pw.println("Current Alarm Manager state:");
  749. final long nowRTC = System.currentTimeMillis();
  750. final long nowELAPSED = SystemClock.elapsedRealtime();
  751. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  752. pw.print("nowRTC="); pw.print(nowRTC);
  753. pw.print("="); pw.print(sdf.format(new Date(nowRTC)));
  754. pw.print(" nowELAPSED="); pw.println(nowELAPSED);
  755. long nextWakeupRTC = mNextWakeup + (nowRTC - nowELAPSED);
  756. long nextNonWakeupRTC = mNextNonWakeup + (nowRTC - nowELAPSED);
  757. pw.print("Next alarm: "); pw.print(mNextNonWakeup);
  758. pw.print(" = "); pw.println(sdf.format(new Date(nextNonWakeupRTC)));
  759. pw.print("Next wakeup: "); pw.print(mNextWakeup);
  760. pw.print(" = "); pw.println(sdf.format(new Date(nextWakeupRTC)));
  761. if (mAlarmBatches.size() > 0) {
  762. pw.println();
  763. pw.print("Pending alarm batches: ");
  764. pw.println(mAlarmBatches.size());
  765. for (Batch b : mAlarmBatches) {
  766. pw.print(b); pw.println(':');
  767. dumpAlarmList(pw, b.alarms, " ", nowELAPSED, nowRTC);
  768. }
  769. }
  770. pw.println();
  771. pw.print(" Broadcast ref count: "); pw.println(mBroadcastRefCount);
  772. pw.println();
  773. if (mLog.dump(pw, " Recent problems", " ")) {
  774. pw.println();
  775. }
  776. final FilterStats[] topFilters = new FilterStats[10];
  777. final Comparator<FilterStats> comparator = new Comparator<FilterStats>() {
  778. @Override
  779. public int compare(FilterStats lhs, FilterStats rhs) {
  780. if (lhs.aggregateTime < rhs.aggregateTime) {
  781. return 1;
  782. } else if (lhs.aggregateTime > rhs.aggregateTime) {
  783. return -1;
  784. }
  785. return 0;
  786. }
  787. };
  788. int len = 0;
  789. for (Map.Entry<String, BroadcastStats> be : mBroadcastStats.entrySet()) {
  790. BroadcastStats bs = be.getValue();
  791. for (Map.Entry<Pair<String, ComponentName>, FilterStats> fe
  792. : bs.filterStats.entrySet()) {
  793. FilterStats fs = fe.getValue();
  794. int pos = len > 0
  795. ? Arrays.binarySearch(topFilters, 0, len, fs, comparator) : 0;
  796. if (pos < 0) {
  797. pos = -pos - 1;
  798. }
  799. if (pos < topFilters.length) {
  800. int copylen = topFilters.length - pos - 1;
  801. if (copylen > 0) {
  802. System.arraycopy(topFilters, pos, topFilters, pos+1, copylen);
  803. }
  804. topFilters[pos] = fs;
  805. if (len < topFilters.length) {
  806. len++;
  807. }
  808. }
  809. }
  810. }
  811. if (len > 0) {
  812. pw.println(" Top Alarms:");
  813. for (int i=0; i<len; i++) {
  814. FilterStats fs = topFilters[i];
  815. pw.print(" ");
  816. if (fs.nesting > 0) pw.print("*ACTIVE* ");
  817. TimeUtils.formatDuration(fs.aggregateTime, pw);
  818. pw.print(" running, "); pw.print(fs.numWakeup);
  819. pw.print(" wakeups, "); pw.print(fs.count);
  820. pw.print(" alarms: "); pw.print(fs.mBroadcastStats.mPackageName);
  821. pw.println();
  822. pw.print(" ");
  823. if (fs.mTarget.first != null) {
  824. pw.print(" act="); pw.print(fs.mTarget.first);
  825. }
  826. if (fs.mTarget.second != null) {
  827. pw.print(" cmp="); pw.print(fs.mTarget.second.toShortString());
  828. }
  829. pw.println();
  830. }
  831. }
  832. pw.println(" ");
  833. pw.println(" Alarm Stats:");
  834. final ArrayList<FilterStats> tmpFilters = new ArrayList<FilterStats>();
  835. for (Map.Entry<String, BroadcastStats> be : mBroadcastStats.entrySet()) {
  836. BroadcastStats bs = be.getValue();
  837. pw.print(" ");
  838. if (bs.nesting > 0) pw.print("*ACTIVE* ");
  839. pw.print(be.getKey());
  840. pw.print(" "); TimeUtils.formatDuration(bs.aggregateTime, pw);
  841. pw.print(" running, "); pw.print(bs.numWakeup);
  842. pw.println(" wakeups:");
  843. tmpFilters.clear();
  844. for (Map.Entry<Pair<String, ComponentName>, FilterStats> fe
  845. : bs.filterStats.entrySet()) {
  846. tmpFilters.add(fe.getValue());
  847. }
  848. Collections.sort(tmpFilters, comparator);
  849. for (int i=0; i<tmpFilters.size(); i++) {
  850. FilterStats fs = tmpFilters.get(i);
  851. pw.print(" ");
  852. if (fs.nesting > 0) pw.print("*ACTIVE* ");
  853. TimeUtils.formatDuration(fs.aggregateTime, pw);
  854. pw.print(" "); pw.print(fs.numWakeup);
  855. pw.print(" wakes " ); pw.print(fs.count);
  856. pw.print(" alarms:");
  857. if (fs.mTarget.first != null) {
  858. pw.print(" act="); pw.print(fs.mTarget.first);
  859. }
  860. if (fs.mTarget.second != null) {
  861. pw.print(" cmp="); pw.print(fs.mTarget.second.toShortString());
  862. }
  863. pw.println();
  864. }
  865. }
  866. if (WAKEUP_STATS) {
  867. pw.println();
  868. pw.println(" Recent Wakeup History:");
  869. long last = -1;
  870. for (WakeupEvent event : mRecentWakeups) {
  871. pw.print(" "); pw.print(sdf.format(new Date(event.when)));
  872. pw.print('|');
  873. if (last < 0) {
  874. pw.print('0');
  875. } else {
  876. pw.print(event.when - last);
  877. }
  878. last = event.when;
  879. pw.print('|'); pw.print(event.uid);
  880. pw.print('|'); pw.print(event.action);
  881. pw.println();
  882. }
  883. pw.println();
  884. }
  885. }
  886. }
  887. private static final void dumpAlarmList(PrintWriter pw, ArrayList<Alarm> list,
  888. String prefix, String label, long now) {
  889. for (int i=list.size()-1; i>=0; i--) {
  890. Alarm a = list.get(i);
  891. pw.print(prefix); pw.print(label); pw.print(" #"); pw.print(i);
  892. pw.print(": "); pw.println(a);
  893. a.dump(pw, prefix + " ", now);
  894. }
  895. }
  896. private static final String labelForType(int type) {
  897. switch (type) {
  898. case RTC: return "RTC";
  899. case RTC_WAKEUP : return "RTC_WAKEUP";
  900. case ELAPSED_REALTIME : return "ELAPSED";
  901. case ELAPSED_REALTIME_WAKEUP: return "ELAPSED_WAKEUP";
  902. default:
  903. break;
  904. }
  905. return "--unknown--";
  906. }
  907. private static final void dumpAlarmList(PrintWriter pw, ArrayList<Alarm> list,
  908. String prefix, long nowELAPSED, long nowRTC) {
  909. for (int i=list.size()-1; i>=0; i--) {
  910. Alarm a = list.get(i);
  911. final String label = labelForType(a.type);
  912. long now = (a.type <= RTC) ? nowRTC : nowELAPSED;
  913. pw.print(prefix); pw.print(label); pw.print(" #"); pw.print(i);
  914. pw.print(": "); pw.println(a);
  915. a.dump(pw, prefix + " ", now);
  916. }
  917. }
  918. private native long init();
  919. private native void close(long nativeData);
  920. private native void set(long nativeData, int type, long seconds, long nanoseconds);
  921. private native int waitForAlarm(long nativeData);
  922. private native int setKernelTime(long nativeData, long millis);
  923. private native int setKernelTimezone(long nativeData, int minuteswest);
  924. private void triggerAlarmsLocked(ArrayList<Alarm> triggerList, long nowELAPSED, long nowRTC) {
  925. // batches are temporally sorted, so we need only pull from the
  926. // start of the list until we either empty it or hit a batch
  927. // that is not yet deliverable
  928. while (mAlarmBatches.size() > 0) {
  929. Batch batch = mAlarmBatches.get(0);
  930. if (batch.start > nowELAPSED) {
  931. // Everything else is scheduled for the future
  932. break;
  933. }
  934. // We will (re)schedule some alarms now; don't let that interfere
  935. // with delivery of this current batch
  936. mAlarmBatches.remove(0);
  937. final int N = batch.size();
  938. for (int i = 0; i < N; i++) {
  939. Alarm alarm = batch.get(i);
  940. alarm.count = 1;
  941. triggerList.add(alarm);
  942. // Recurring alarms may have passed several alarm intervals while the
  943. // phone was asleep or off, so pass a trigger count when sending them.
  944. if (alarm.repeatInterval > 0) {
  945. // this adjustment will be zero if we're late by
  946. // less than one full repeat interval
  947. alarm.count += (nowELAPSED - alarm.whenElapsed) / alarm.repeatInterval;
  948. // Also schedule its next recurrence
  949. final long delta = alarm.count * alarm.repeatInterval;
  950. final long nextElapsed = alarm.whenElapsed + delta;
  951. setImplLocked(alarm.type, alarm.when + delta, nextElapsed, alarm.windowLength,
  952. maxTriggerTime(nowELAPSED, nextElapsed, alarm.repeatInterval),
  953. alarm.repeatInterval, alarm.operation, batch.standalone, true,
  954. alarm.workSource);
  955. }
  956. }
  957. }
  958. }
  959. /**
  960. * This Comparator sorts Alarms into increasing time order.
  961. */
  962. public static class IncreasingTimeOrder implements Comparator<Alarm> {
  963. public int compare(Alarm a1, Alarm a2) {
  964. long when1 = a1.when;
  965. long when2 = a2.when;
  966. if (when1 - when2 > 0) {
  967. return 1;
  968. }
  969. if (when1 - when2 < 0) {
  970. return -1;
  971. }
  972. return 0;
  973. }
  974. }
  975. private static class Alarm {
  976. public int type;
  977. public int count;
  978. public long when;
  979. public long windowLength;
  980. public long whenElapsed; // 'when' in the elapsed time base
  981. public long maxWhen; // also in the elapsed time base
  982. public long repeatInterval;
  983. public PendingIntent operation;
  984. public WorkSource workSource;
  985. public Alarm(int _type, long _when, long _whenElapsed, long _windowLength, long _maxWhen,
  986. long _interval, PendingIntent _op, WorkSource _ws) {
  987. type = _type;
  988. when = _when;
  989. whenElapsed = _whenElapsed;
  990. windowLength = _windowLength;
  991. maxWhen = _maxWhen;
  992. repeatInterval = _interval;
  993. operation = _op;
  994. workSource = _ws;
  995. }
  996. @Override
  997. public String toString()
  998. {
  999. StringBuilder sb = new StringBuilder(128);
  1000. sb.append("Alarm{");
  1001. sb.append(Integer.toHexString(System.identityHashCode(this)));
  1002. sb.append(" type ");
  1003. sb.append(type);
  1004. sb.append(" ");
  1005. sb.append(operation.getTargetPackage());
  1006. sb.append('}');
  1007. return sb.toString();
  1008. }
  1009. public void dump(PrintWriter pw, String prefix, long now) {
  1010. pw.print(prefix); pw.print("type="); pw.print(type);
  1011. pw.print(" whenElapsed="); pw.print(whenElapsed);
  1012. pw.print(" when="); TimeUtils.formatDuration(when, now, pw);
  1013. pw.print(" window="); pw.print(windowLength);
  1014. pw.print(" repeatInterval="); pw.print(repeatInterval);
  1015. pw.print(" count="); pw.println(count);
  1016. pw.print(prefix); pw.print("operation="); pw.println(operation);
  1017. }
  1018. }
  1019. void recordWakeupAlarms(ArrayList<Batch> batches, long nowELAPSED, long nowRTC) {
  1020. final int numBatches = batches.size();
  1021. for (int nextBatch = 0; nextBatch < numBatches; nextBatch++) {
  1022. Batch b = batches.get(nextBatch);
  1023. if (b.start > nowELAPSED) {
  1024. break;
  1025. }
  1026. final int numAlarms = b.alarms.size();
  1027. for (int nextAlarm = 0; nextAlarm < numAlarms; nextAlarm++) {
  1028. Alarm a = b.alarms.get(nextAlarm);
  1029. WakeupEvent e = new WakeupEvent(nowRTC,
  1030. a.operation.getCreatorUid(),
  1031. a.operation.getIntent().getAction());
  1032. mRecentWakeups.add(e);
  1033. }
  1034. }
  1035. }
  1036. private class AlarmThread extends Thread
  1037. {
  1038. public AlarmThread()
  1039. {
  1040. super("AlarmManager");
  1041. }
  1042. public void run()
  1043. {
  1044. ArrayList<Alarm> triggerList = new ArrayList<Alarm>();
  1045. while (true)
  1046. {
  1047. int result = waitForAlarm(mNativeData);
  1048. triggerList.clear();
  1049. if ((result & TIME_CHANGED_MASK) != 0) {
  1050. if (DEBUG_BATCH) {
  1051. Slog.v(TAG, "Time changed notification from kernel; rebatching");
  1052. }
  1053. remove(mTimeTickSender);
  1054. rebatchAllAlarms();
  1055. mClockReceiver.scheduleTimeTickEvent();
  1056. Intent intent = new Intent(Intent.ACTION_TIME_CHANGED);
  1057. intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING
  1058. | Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
  1059. mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
  1060. }
  1061. synchronized (mLock) {
  1062. final long nowRTC = System.currentTimeMillis();
  1063. final long nowELAPSED = SystemClock.elapsedRealtime();
  1064. if (localLOGV) Slog.v(
  1065. TAG, "Checking for alarms... rtc=" + nowRTC
  1066. + ", elapsed=" + nowELAPSED);
  1067. if (WAKEUP_STATS) {
  1068. if ((result & IS_WAKEUP_MASK) != 0) {
  1069. long newEarliest = nowRTC - RECENT_WAKEUP_PERIOD;
  1070. int n = 0;
  1071. for (WakeupEvent event : mRecentWakeups) {
  1072. if (event.when > newEarliest) break;
  1073. n++; // number of now-stale entries at the list head
  1074. }
  1075. for (int i = 0; i < n; i++) {
  1076. mRecentWakeups.remove();
  1077. }
  1078. recordWakeupAlarms(mAlarmBatches, nowELAPSED, nowRTC);
  1079. }
  1080. }
  1081. triggerAlarmsLocked(triggerList, nowELAPSED, nowRTC);
  1082. rescheduleKernelAlarmsLocked();
  1083. // now deliver the alarm intents
  1084. for (int i=0; i<triggerList.size(); i++) {
  1085. Alarm alarm = triggerList.get(i);
  1086. try {
  1087. if (localLOGV) Slog.v(TAG, "sending alarm " + alarm);
  1088. alarm.operation.send(mContext, 0,
  1089. mBackgroundIntent.putExtra(
  1090. Intent.EXTRA_ALARM_COUNT, alarm.count),
  1091. mResultReceiver, mHandler);
  1092. // we have an active broadcast so stay awake.
  1093. if (mBroadcastRefCount == 0) {
  1094. setWakelockWorkSource(alarm.operation, alarm.workSource);
  1095. mWakeLock.acquire();
  1096. }
  1097. final InFlight inflight = new InFlight(AlarmManagerService.this,
  1098. alarm.operation, alarm.workSource);
  1099. mInFlight.add(inflight);
  1100. mBroadcastRefCount++;
  1101. final BroadcastStats bs = inflight.mBroadcastStats;
  1102. bs.count++;
  1103. if (bs.nesting == 0) {
  1104. bs.nesting = 1;
  1105. bs.startTime = nowELAPSED;
  1106. } else {
  1107. bs.nesting++;
  1108. }
  1109. final FilterStats fs = inflight.mFilterStats;
  1110. fs.count++;
  1111. if (fs.nesting == 0) {
  1112. fs.nesting = 1;
  1113. fs.startTime = nowELAPSED;
  1114. } else {
  1115. fs.nesting++;
  1116. }
  1117. if (alarm.type == ELAPSED_REALTIME_WAKEUP
  1118. || alarm.type == RTC_WAKEUP) {
  1119. bs.numWakeup++;
  1120. fs.numWakeup++;
  1121. ActivityManagerNative.noteWakeupAlarm(
  1122. alarm.operation);
  1123. }
  1124. } catch (PendingIntent.CanceledException e) {
  1125. if (alarm.repeatInterval > 0) {
  1126. // This IntentSender is no longer valid, but this
  1127. // is a repeating alarm, so toss the hoser.
  1128. remove(alarm.operation);
  1129. }
  1130. } catch (RuntimeException e) {
  1131. Slog.w(TAG, "Failure sending alarm.", e);
  1132. }
  1133. }
  1134. }
  1135. }
  1136. }
  1137. }
  1138. /**
  1139. * Attribute blame for a WakeLock.
  1140. * @param pi PendingIntent to attribute blame to if ws is null.
  1141. * @param ws WorkSource to attribute blame.
  1142. */
  1143. void setWakelockWorkSource(PendingIntent pi, WorkSource ws) {
  1144. try {
  1145. if (ws != null) {
  1146. mWakeLock.setWorkSource(ws);
  1147. return;
  1148. }
  1149. final int uid = ActivityManagerNative.getDefault()
  1150. .getUidForIntentSender(pi.getTarget());
  1151. if (uid >= 0) {
  1152. mWakeLock.setWorkSource(new WorkSource(uid));
  1153. return;
  1154. }
  1155. } catch (Exception e) {
  1156. }
  1157. // Something went wrong; fall back to attributing the lock to the OS
  1158. mWakeLock.setWorkSource(null);
  1159. }
  1160. private class AlarmHandler extends Handler {
  1161. public static final int ALARM_EVENT = 1;
  1162. public static final int MINUTE_CHANGE_EVENT = 2;
  1163. public static final int DATE_CHANGE_EVENT = 3;
  1164. public AlarmHandler() {
  1165. }
  1166. public void handleMessage(Message msg) {
  1167. if (msg.what == ALARM_EVENT) {
  1168. ArrayList<Alarm> triggerList = new ArrayList<Alarm>();
  1169. synchronized (mLock) {
  1170. final long nowRTC = System.currentTimeMillis();
  1171. final long nowELAPSED = SystemClock.elapsedRealtime();
  1172. triggerAlarmsLocked(triggerList, nowELAPSED, nowRTC);
  1173. }
  1174. // now trigger the alarms without the lock held
  1175. for (int i=0; i<triggerList.size(); i++) {
  1176. Alarm alarm = triggerList.get(i);
  1177. try {
  1178. alarm.operation.send();
  1179. } catch (PendingIntent.CanceledException e) {
  1180. if (alarm.repeatInterval > 0) {
  1181. // This IntentSender is no longer valid, but this
  1182. // is a repeating alarm, so toss the hoser.
  1183. remove(alarm.operation);
  1184. }
  1185. }
  1186. }
  1187. }
  1188. }
  1189. }
  1190. class ClockReceiver extends BroadcastReceiver {
  1191. public ClockReceiver() {
  1192. IntentFilter filter = new IntentFilter();
  1193. filter.addAction(Intent.ACTION_TIME_TICK);
  1194. filter.addAction(Intent.ACTION_DATE_CHANGED);
  1195. mContext.registerReceiver(this, filter);
  1196. }
  1197. @Override
  1198. public void onReceive(Context context, Intent intent) {
  1199. if (intent.getAction().equals(Intent.ACTION_TIME_TICK)) {
  1200. if (DEBUG_BATCH) {
  1201. Slog.v(TAG, "Received TIME_TICK alarm; rescheduling");
  1202. }
  1203. scheduleTimeTickEvent();
  1204. } else if (intent.getAction().equals(Intent.ACTION_DATE_CHANGED)) {
  1205. // Since the kernel does not keep track of DST, we need to
  1206. // reset the TZ information at the beginning of each day
  1207. // based off of the current Zone gmt offset + userspace tracked
  1208. // daylight savings information.
  1209. TimeZone zone = TimeZone.getTimeZone(SystemProperties.get(TIMEZONE_PROPERTY));
  1210. int gmtOffset = zone.getOffset(System.currentTimeMillis());
  1211. setKernelTimezone(mNativeData, -(gmtOffset / 60000));
  1212. scheduleDateChangedEvent();
  1213. }
  1214. }
  1215. public void scheduleTimeTickEvent() {
  1216. final long currentTime = System.currentTimeMillis();
  1217. final long nextTime = 60000 * ((currentTime / 60000) + 1);
  1218. // Schedule this event for the amount of time that it would take to get to
  1219. // the top of the next minute.
  1220. final long tickEventDelay = nextTime - currentTime;
  1221. final WorkSource workSource = null; // Let system take blame for time tick events.
  1222. set(ELAPSED_REALTIME, SystemClock.elapsedRealtime() + tickEventDelay, 0,
  1223. 0, mTimeTickSender, true, workSource);
  1224. }
  1225. public void scheduleDateChangedEvent() {
  1226. Calendar calendar = Calendar.getInstance();
  1227. calendar.setTimeInMillis(System.currentTimeMillis());
  1228. calendar.set(Calendar.HOUR, 0);
  1229. calendar.set(Calendar.MINUTE, 0);
  1230. calendar.set(Calendar.SECOND, 0);
  1231. calendar.set(Calendar.MILLISECOND, 0);
  1232. calendar.add(Calendar.DAY_OF_MONTH, 1);
  1233. final WorkSource workSource = null; // Let system take blame for date change events.
  1234. set(RTC, calendar.getTimeInMillis(), 0, 0, mDateChangeSender, true, workSource);
  1235. }
  1236. }
  1237. class UninstallReceiver extends BroadcastReceiver {
  1238. public UninstallReceiver() {
  1239. IntentFilter filter = new IntentFilter();
  1240. filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
  1241. filter.addAction(Intent.ACTION_PACKAGE_RESTARTED);
  1242. filter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART);
  1243. filter.addDataScheme("package");
  1244. mContext.registerReceiver(this, filter);
  1245. // Register for events related to sdcard installation.
  1246. IntentFilter sdFilter = new IntentFilter();
  1247. sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
  1248. sdFilter.addAction(Intent.ACTION_USER_STOPPED);
  1249. mContext.registerReceiver(this, sdFilter);
  1250. }
  1251. @Override
  1252. public void onReceive(Context context, Intent intent) {
  1253. synchronized (mLock) {
  1254. String action = intent.getAction();
  1255. String pkgList[] = null;
  1256. if (Intent.ACTION_QUERY_PACKAGE_RESTART.equals(action)) {
  1257. pkgList = intent.getStringArrayExtra(Intent.EXTRA_PACKAGES);
  1258. for (String packageName : pkgList) {
  1259. if (lookForPackageLocked(packageName)) {
  1260. setResultCode(Activity.RESULT_OK);
  1261. return;
  1262. }
  1263. }
  1264. return;
  1265. } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(action)) {
  1266. pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
  1267. } else if (Intent.ACTION_USER_STOPPED.equals(action)) {
  1268. int userHandle = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, -1);
  1269. if (userHandle >= 0) {
  1270. removeUserLocked(userHandle);
  1271. }
  1272. } else {
  1273. if (Intent.ACTION_PACKAGE_REMOVED.equals(action)
  1274. && intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) {
  1275. // This package is being updated; don't kill its alarms.
  1276. return;
  1277. }
  1278. Uri data = intent.getData();
  1279. if (data != null) {
  1280. String pkg = data.getSchemeSpecificPart();
  1281. if (pkg != null) {
  1282. pkgList = new String[]{pkg};
  1283. }
  1284. }
  1285. }
  1286. if (pkgList != null && (pkgList.length > 0)) {
  1287. for (String pkg : pkgList) {
  1288. removeLocked(pkg);
  1289. mBroadcastStats.remove(pkg);
  1290. }
  1291. }
  1292. }
  1293. }
  1294. }
  1295. private final BroadcastStats getStatsLocked(PendingIntent pi) {
  1296. String pkg = pi.getTargetPackage();
  1297. BroadcastStats bs = mBroadcastStats.get(pkg);
  1298. if (bs == null) {
  1299. bs = new BroadcastStats(pkg);
  1300. mBroadcastStats.put(pkg, bs);
  1301. }
  1302. return bs;
  1303. }
  1304. class ResultReceiver implements PendingIntent.OnFinished {
  1305. public void onSendFinished(PendingIntent pi, Intent intent, int resultCode,
  1306. String resultData, Bundle resultExtras) {
  1307. synchronized (mLock) {
  1308. InFlight inflight = null;
  1309. for (int i=0; i<mInFlight.size(); i++) {
  1310. if (mInFlight.get(i).mPendingIntent == pi) {
  1311. inflight = mInFlight.remove(i);
  1312. break;
  1313. }
  1314. }
  1315. if (inflight != null) {
  1316. final long nowELAPSED = SystemClock.elapsedRealtime();
  1317. BroadcastStats bs = inflight.mBroadcastStats;
  1318. bs.nesting--;
  1319. if (bs.nesting <= 0) {
  1320. bs.nesting = 0;
  1321. bs.aggregateTime += nowELAPSED - bs.startTime;
  1322. }
  1323. FilterStats fs = inflight.mFilterStats;
  1324. fs.nesting--;
  1325. if (fs.nesting <= 0) {
  1326. fs.nesting = 0;
  1327. fs.aggregateTime += nowELAPSED - fs.startTime;
  1328. }
  1329. } else {
  1330. mLog.w("No in-flight alarm for " + pi + " " + intent);
  1331. }
  1332. mBroadcastRefCount--;
  1333. if (mBroadcastRefCount == 0) {
  1334. mWakeLock.release();
  1335. if (mInFlight.size() > 0) {
  1336. mLog.w("Finished all broadcasts with " + mInFlight.size()
  1337. + " remaining inflights");
  1338. for (int i=0; i<mInFlight.size(); i++) {
  1339. mLog.w(" Remaining #" + i + ": " + mInFlight.get(i));
  1340. }
  1341. mInFlight.clear();
  1342. }
  1343. } else {
  1344. // the next of our alarms is now in flight. reattribute the wakelock.
  1345. if (mInFlight.size() > 0) {
  1346. InFlight inFlight = mInFlight.get(0);
  1347. setWakelockWorkSource(inFlight.mPendingIntent, inFlight.mWorkSource);
  1348. } else {
  1349. // should never happen
  1350. mLog.w("Alarm wakelock still held but sent queue empty");
  1351. mWakeLock.setWorkSource(null);
  1352. }
  1353. }
  1354. }
  1355. }
  1356. }
  1357. }