Android5.1AlarmManagerService深刻分析（Android4.4补充）

因为在个人博客中Android4.4已经比较详细的分析了AlarmManagerService，所以这里主要分析一下差别，在我看来5.1的在AlarmManagerService的改动仍是比较大的。

 

先看AlarmManager新增了一个接口：

1. public void setAlarmClock(AlarmClockInfo info, PendingIntent operation) {  
2.     setImpl(RTC_WAKEUP, info.getTriggerTime(), WINDOW_EXACT, 0, operation, null, info);  
3. }  

这个接口主要应用本身设置一个新的对象AlarmClockInfo，这个针对多用户的，每一个用户也能够在AlarmManagerService中获得本身的下个AlarmClockInfo，能够获得triggertime，pendingIntent。

1. public AlarmClockInfo getNextAlarmClock() {  
2.     return getNextAlarmClock(UserHandle.myUserId());  
3. }  

这是AlarmManager，接下来分析下AlarmManagerService中在5.1的变化。

先从Alarm的设置那块，也就是AlarmManagerService的主线程分析，主要变化最大的是rescheduleKernelAlarmsLocked函数

1. void rescheduleKernelAlarmsLocked() {  
2.     // Schedule the next upcoming wakeup alarm.  If there is a deliverable batch  
3.     // prior to that which contains no wakeups, we schedule that as well.  
4.     long nextNonWakeup = 0;  
5.     if (mAlarmBatches.size() > 0) {  
6.         final Batch firstWakeup = findFirstWakeupBatchLocked();  
7.         final Batch firstBatch = mAlarmBatches.get(0);  
8.         // always update the kernel alarms, as a backstop against missed wakeups  
9.         if (firstWakeup != null) {  
10.             mNextWakeup = firstWakeup.start;  
11.             setLocked(ELAPSED_REALTIME_WAKEUP, firstWakeup.start);  
12.         }  
13.         if (firstBatch != firstWakeup) {//和唤醒的时间不相同，才赋值  
14.             nextNonWakeup = firstBatch.start;  
15.         }  
16.     }  
17.     if (mPendingNonWakeupAlarms.size() > 0) {//有没有发送的非唤醒类型的alarm  
18.         if (nextNonWakeup == 0 || mNextNonWakeupDeliveryTime < nextNonWakeup) {  
19.             nextNonWakeup = mNextNonWakeupDeliveryTime;  
20.         }  
21.     }  
22.     // always update the kernel alarm, as a backstop against missed wakeups  
23.     if (nextNonWakeup != 0) {  
24.         mNextNonWakeup = nextNonWakeup;  
25.         setLocked(ELAPSED_REALTIME, nextNonWakeup);  
26.     }  
27. }  

接下来主要分析下AlarmThread的run函数，主要用来发送alarm，直接挑选了主要内容：

1. boolean hasWakeup = triggerAlarmsLocked(triggerList, nowELAPSED, nowRTC);  
2. if (!hasWakeup && checkAllowNonWakeupDelayLocked(nowELAPSED)) {//没有wakeup类型的alarm，并且容许延迟（接下来分析)  
3.     // if there are no wakeup alarms and the screen is off, we can  
4.     // delay what we have so far until the future.  
5.     if (mPendingNonWakeupAlarms.size() == 0) {  
6.         mStartCurrentDelayTime = nowELAPSED;  
7.         mNextNonWakeupDeliveryTime = nowELAPSED//定义下个alarm的发送时间  
8.                 + ((currentNonWakeupFuzzLocked(nowELAPSED)*3)/2);  
9.     }  
10.     mPendingNonWakeupAlarms.addAll(triggerList);  
11.     mNumDelayedAlarms += triggerList.size();  
12.     rescheduleKernelAlarmsLocked();  
13.     updateNextAlarmClockLocked();  
14. } else {//当alarm有唤醒的  
15.     // now deliver the alarm intents; if there are pending non-wakeup  
16.     // alarms, we need to merge them in to the list.  note we don't  
17.     // just deliver them first because we generally want non-wakeup  
18.     // alarms delivered after wakeup alarms.  
19.     rescheduleKernelAlarmsLocked();  
20.     updateNextAlarmClockLocked();  
21.     if (mPendingNonWakeupAlarms.size() > 0) {//当有没有发送的非唤醒的alarm，加入发送列表一块儿发送  
22.         calculateDeliveryPriorities(mPendingNonWakeupAlarms);  
23.         triggerList.addAll(mPendingNonWakeupAlarms);  
24.         Collections.sort(triggerList, mAlarmDispatchComparator);  
25.         final long thisDelayTime = nowELAPSED - mStartCurrentDelayTime;  
26.         mTotalDelayTime += thisDelayTime;  
27.         if (mMaxDelayTime < thisDelayTime) {  
28.             mMaxDelayTime = thisDelayTime;  
29.         }  
30.         mPendingNonWakeupAlarms.clear();  
31.     }  
32.     deliverAlarmsLocked(triggerList, nowELAPSED);//发送的部分封装了一个函数，大体和之前同样就不分析了  
33. }  

下面咱们详细分析下checkAllowNonWakeupDelayLocked这个函数：

1. long currentNonWakeupFuzzLocked(long nowELAPSED) {  
2.     long timeSinceOn = nowELAPSED - mNonInteractiveStartTime;  
3.     if (timeSinceOn < 5*60*1000) {  
4.         // If the screen has been off for 5 minutes, only delay by at most two minutes.  
5.         return 2*60*1000;  
6.     } else if (timeSinceOn < 30*60*1000) {  
7.         // If the screen has been off for 30 minutes, only delay by at most 15 minutes.  
8.         return 15*60*1000;  
9.     } else {  
10.         // Otherwise, we will delay by at most an hour.  
11.         return 60*60*1000;  
12.     }  
13. }  
14.   
15. boolean checkAllowNonWakeupDelayLocked(long nowELAPSED) {  
16.     if (mInteractive) {//屏幕亮着  
17.         return false;  
18.     }  
19.     if (mLastAlarmDeliveryTime <= 0) {  
20.         return false;  
21.     }  
22.     if (mPendingNonWakeupAlarms.size() > 0 && mNextNonWakeupDeliveryTime > nowELAPSED) {//有非唤醒类型的alarm未发送，且发送没过时  
23.         // This is just a little paranoia, if somehow we have pending non-wakeup alarms  
24.         // and the next delivery time is in the past, then just deliver them all.  This  
25.         // avoids bugs where we get stuck in a loop trying to poll for alarms.  
26.         return false;  
27.     }  
28.     long timeSinceLast = nowELAPSED - mLastAlarmDeliveryTime;//如今距离上次发送的时间差  
29.     return timeSinceLast <= currentNonWakeupFuzzLocked(nowELAPSED);//时间差小于灭屏到如今的一个时间差。  
30. }  

接下来分析下，系统更新clockInfo那块。

1. * Recomputes the next alarm clock for all users.  
2.  */  
3. private void updateNextAlarmClockLocked() {  
4.     if (!mNextAlarmClockMayChange) {  
5.         return;  
6.     }  
7.     mNextAlarmClockMayChange = false;  
8.   
9.     SparseArray<AlarmManager.AlarmClockInfo> nextForUser = mTmpSparseAlarmClockArray;  
10.     nextForUser.clear();  
11.   
12.     final int N = mAlarmBatches.size();  
13.     for (int i = 0; i < N; i++) {  
14.         ArrayList<Alarm> alarms = mAlarmBatches.get(i).alarms;  
15.         final int M = alarms.size();  
16.   
17.         for (int j = 0; j < M; j++) {  
18.             Alarm a = alarms.get(j);  
19.             if (a.alarmClock != null) {  
20.                 final int userId = a.userId;  
21.   
22.                 // Alarms and batches are sorted by time, no need to compare times here.  
23.                 if (nextForUser.get(userId) == null) {  
24.                     nextForUser.put(userId, a.alarmClock);//uid、alarmClock对应的关系  
25.                 }  
26.             }  
27.         }  
28.     }  
29.   
30.     // Update mNextAlarmForUser with new values.  
31.     final int NN = nextForUser.size();  
32.     for (int i = 0; i < NN; i++) {  
33.         AlarmManager.AlarmClockInfo newAlarm = nextForUser.valueAt(i);  
34.         int userId = nextForUser.keyAt(i);  
35.         AlarmManager.AlarmClockInfo currentAlarm = mNextAlarmClockForUser.get(userId);  
36.         if (!newAlarm.equals(currentAlarm)) {//如今mNextAlarmClockForUser中uid对应的alarmclockinfo不是最新的，须要更新  
37.             updateNextAlarmInfoForUserLocked(userId, newAlarm);  
38.         }  
39.     }  
40.   
41.     // Remove users without any alarm clocks scheduled.  
42.     final int NNN = mNextAlarmClockForUser.size();  
43.     for (int i = NNN - 1; i >= 0; i--) {  
44.         int userId = mNextAlarmClockForUser.keyAt(i);  
45.         if (nextForUser.get(userId) == null) {//若是如今userId，对应的AlarmClockInfo没有，也要更新  
46.             updateNextAlarmInfoForUserLocked(userId, null);  
47.         }  
48.     }  
49. }  
50.   
51. private void updateNextAlarmInfoForUserLocked(int userId,  
52.         AlarmManager.AlarmClockInfo alarmClock) {  
53.     if (alarmClock != null) {  
54.         mNextAlarmClockForUser.put(userId, alarmClock);  
55.     } else {            
56.         mNextAlarmClockForUser.remove(userId);  
57.     }  
58.   
59.     mPendingSendNextAlarmClockChangedForUser.put(userId, true);//将须要更新AlarmClockInfo的userId保存起来  
60.     mHandler.removeMessages(AlarmHandler.SEND_NEXT_ALARM_CLOCK_CHANGED);  
61.     mHandler.sendEmptyMessage(AlarmHandler.SEND_NEXT_ALARM_CLOCK_CHANGED);  
62. }  

发送AlarmHandler.SEND_NEXT_ALARM_CLOCK_CHANGED消息，会调用以下函数：

1. private void sendNextAlarmClockChanged() {  
2.     SparseArray<AlarmManager.AlarmClockInfo> pendingUsers = mHandlerSparseAlarmClockArray;  
3.     pendingUsers.clear();  
4.   
5.     synchronized (mLock) {  
6.         final int N  = mPendingSendNextAlarmClockChangedForUser.size();  
7.         for (int i = 0; i < N; i++) {  
8.             int userId = mPendingSendNextAlarmClockChangedForUser.keyAt(i);  
9.             pendingUsers.append(userId, mNextAlarmClockForUser.get(userId));  
10.         }  
11.         mPendingSendNextAlarmClockChangedForUser.clear();  
12.     }  
13.   
14.     final int N = pendingUsers.size();  
15.     for (int i = 0; i < N; i++) {  
16.         int userId = pendingUsers.keyAt(i);  
17.         AlarmManager.AlarmClockInfo alarmClock = pendingUsers.valueAt(i);  
18.         Settings.System.putStringForUser(getContext().getContentResolver(),  
19.                 Settings.System.NEXT_ALARM_FORMATTED,  
20.                 formatNextAlarm(getContext(), alarmClock, userId),  
21.                 userId);  
22.   
23.         getContext().sendBroadcastAsUser(NEXT_ALARM_CLOCK_CHANGED_INTENT,  
24.                 new UserHandle(userId));//发送广播通知各个用户下，其AlarmClockInfo已经改变  
25.     }  
26. }  

增长了一个监控屏幕亮灭屏的广播receiver：

1. class InteractiveStateReceiver extends BroadcastReceiver {  
2.     public InteractiveStateReceiver() {  
3.         IntentFilter filter = new IntentFilter();  
4.         filter.addAction(Intent.ACTION_SCREEN_OFF);  
5.         filter.addAction(Intent.ACTION_SCREEN_ON);  
6.         filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);  
7.         getContext().registerReceiver(this, filter);  
8.     }  
9.   
10.     @Override  
11.     public void onReceive(Context context, Intent intent) {  
12.         synchronized (mLock) {  
13.             interactiveStateChangedLocked(Intent.ACTION_SCREEN_ON.equals(intent.getAction()));  
14.         }  
15.     }  
16. }  

收到屏幕变化后会调用interactiveStateChangedLocked函数：

1. void interactiveStateChangedLocked(boolean interactive) {  
2.     if (mInteractive != interactive) {  
3.         mInteractive = interactive;  
4.         final long nowELAPSED = SystemClock.elapsedRealtime();  
5.         if (interactive) {//亮屏，发送非唤醒类型的alarm  
6.             if (mPendingNonWakeupAlarms.size() > 0) {  
7.                 final long thisDelayTime = nowELAPSED - mStartCurrentDelayTime;  
8.                 mTotalDelayTime += thisDelayTime;  
9.                 if (mMaxDelayTime < thisDelayTime) {  
10.                     mMaxDelayTime = thisDelayTime;  
11.                 }  
12.                 deliverAlarmsLocked(mPendingNonWakeupAlarms, nowELAPSED);  
13.                 mPendingNonWakeupAlarms.clear();  
14.             }  
15.             if (mNonInteractiveStartTime > 0) {  
16.                 long dur = nowELAPSED - mNonInteractiveStartTime;  
17.                 if (dur > mNonInteractiveTime) {  
18.                     mNonInteractiveTime = dur;  
19.                 }  
20.             }  
21.         } else {//灭屏，更新mNonInteractiveStartTime   
22.             mNonInteractiveStartTime = nowELAPSED;  
23.         }  
24.     }  
25. }