Android Alarm自上而下 调试浅析

1.为了创建一个新的Alarm，使用set方法并指定一个Alarm类型、触发时间和在Alarm触发时要调用的Intent。如果你设定的Alarm发生在过去，那么，它将立即触发。

这里有4种Alarm类型。你的选择将决定你在set方法中传递的时间值代表什么，是特定的时间或者是时间流逝：

❑ RTC_WAKEUP

在指定的时刻（设置Alarm的时候），唤醒设备来触发Intent。

❑ RTC

在一个显式的时间触发Intent，但不唤醒设备。

❑ ELAPSED_REALTIME

从设备启动后，如果流逝的时间达到总时间，那么触发Intent，但不唤醒设备。流逝的时间包括设备睡眠的任何时间。注意一点的是，时间流逝的计算点是自从它最后一次启动算起。

❑ ELAPSED_REALTIME_WAKEUP

从设备启动后，达到流逝的总时间后，如果需要将唤醒设备并触发Intent。

2.Alarm 调用流程，alarm的流程实现了从上层应用一直到下面driver的调用流程，下面简单阐述：

点击Clock 应用程序，然后设置新闹钟，会调到  Alarms.java  里面的

[cpp]  view plain copy

1. public static long setAlarm(Context context, Alarm alarm) {  
2.     ContentValues values = createContentValues(alarm);  
3.     ContentResolver resolver = context.getContentResolver();  
4.     resolver.update(  
5.             ContentUris.withAppendedId(Alarm.Columns.CONTENT_URI, alarm.id),  
6.             values, null, null);  
7.   
8.     long timeInMillis = calculateAlarm(alarm);  
9.   
10.     if (alarm.enabled) {  
11.         // Disable the snooze if we just changed the snoozed alarm. This  
12.         // only does work if the snoozed alarm is the same as the given  
13.         // alarm.  
14.         // TODO: disableSnoozeAlert should have a better name.  
15.         disableSnoozeAlert(context, alarm.id);  
16.   
17.         // Disable the snooze if this alarm fires before the snoozed alarm.  
18.         // This works on every alarm since the user most likely intends to  
19.         // have the modified alarm fire next.  
20.         clearSnoozeIfNeeded(context, timeInMillis);  
21.     }  
22.   
23.     setNextAlert(context);  
24.   
25.     return timeInMillis;  
26. }  

然后这里面也会调用到

[cpp]  view plain copy

1. public static void setNextAlert(final Context context) {  
2.     final Alarm alarm = calculateNextAlert(context);  
3.     if (alarm != null) {  
4.         enableAlert(context, alarm, alarm.time);  
5.     } else {  
6.         disableAlert(context);  
7.     }  
8. }  

calculateNextAlert(context);   //new 一个新的alarm 
然后继续调用到

     private static void enableAlert(Context context, final Alarm alarm,final long atTimeInMillis)

其中am.set(AlarmManager.RTC_WAKEUP, atTimeInMillis, sender);//这里是RTC_WAKEUP, 这就保证了即使系统睡眠了，都能唤醒，闹钟工作（android平台关机闹钟好像不行）

然后就调用到了AlarmManager.java 里面方法

[cpp]  view plain copy

1. public void set(int type, long triggerAtTime, PendingIntent operation) {  
2.     try {  
3.         mService.set(type, triggerAtTime, operation);  
4.     } catch (RemoteException ex) {  
5.     }  
6. }  

然后就调用到了AlarmManagerService.java  里面方法

[cpp]  view plain copy

1. public void set(int type, long triggerAtTime, PendingIntent operation) {  
2.         setRepeating(type, triggerAtTime, 0, operation);  
3.     }  

然后继续调用

[cpp]  view plain copy

1. public void setRepeating(int type, long triggerAtTime, long interval,   
2.             PendingIntent operation) {  
3. .....  
4. synchronized (mLock) {  
5.             Alarm alarm = new Alarm();  
6.             alarm.type = type;  
7.             alarm.when = triggerAtTime;  
8.             alarm.repeatInterval = interval;  
9.             alarm.operation = operation;  
10.   
11.             // Remove this alarm if already scheduled.  
12.             removeLocked(operation);  
13.   
14.             if (localLOGV) Slog.v(TAG, "set: " + alarm);  
15.   
16.             int index = addAlarmLocked(alarm);  
17.             if (index == 0) {  
18.                 setLocked(alarm);  
19.             }  
20.         }  
21.     }  

然后就调用到

[cpp]  view plain copy

1. private void setLocked(Alarm alarm)  
2.     {  
3.     ......  
4.     set(mDescriptor, alarm.type, alarmSeconds, alarmNanoseconds);   //mDescriptor  这里的文件是 /dev/alarm  
5.     .....  
6. }  

这里就调用到jni了
private native void set(int fd, int type, long seconds, long nanoseconds);

这就调用到了com_android_server_AlarmManagerService.cpp 里面

[cpp]  view plain copy

1. static JNINativeMethod sMethods[] = {  
2.      /* name, signature, funcPtr */  
3.     {"init", "()I", (void*)android_server_AlarmManagerService_init},  
4.     {"close", "(I)V", (void*)android_server_AlarmManagerService_close},  
5.     {"set", "(IIJJ)V", (void*)android_server_AlarmManagerService_set},  
6.     {"waitForAlarm", "(I)I", (void*)android_server_AlarmManagerService_waitForAlarm},  
7.     {"setKernelTimezone", "(II)I", (void*)android_server_AlarmManagerService_setKernelTimezone},  
8. };  

set 对应的是android_server_AlarmManagerService_set， 具体是

[cpp]  view plain copy

1. static void android_server_AlarmManagerService_set(JNIEnv* env, jobject obj, jint fd, jint type, jlong seconds, jlong nanoseconds)  
2. {  
3. #if HAVE_ANDROID_OS  
4.     struct timespec ts;  
5.     ts.tv_sec = seconds;  
6.     ts.tv_nsec = nanoseconds;  
7.       
8.     int result = ioctl(fd, ANDROID_ALARM_SET(type), &ts);  
9.     if (result < 0)  
10.     {  
11.         LOGE("Unable to set alarm to %lld.%09lld: %s\n", seconds, nanoseconds, strerror(errno));  
12.     }  
13. #endif  
14. }  

然后ioctl 就调用到了alarm-dev.c

[cpp]  view plain copy

1. static long alarm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)  
2. {  
3.     int rv = 0;  
4.     unsigned long flags;  
5.     struct timespec new_alarm_time;  
6.     struct timespec new_rtc_time;  
7.     struct timespec tmp_time;  
8.     enum android_alarm_type alarm_type = ANDROID_ALARM_IOCTL_TO_TYPE(cmd);  
9.     uint32_t alarm_type_mask = 1U << alarm_type;  
10.     printk(">>%s cmd == %d\n",__FUNCTION__,cmd);  
11.     if (alarm_type >= ANDROID_ALARM_TYPE_COUNT)  
12.         return -EINVAL;  
13.   
14.     if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_GET_TIME(0)) {  
15.         if ((file->f_flags & O_ACCMODE) == O_RDONLY)  
16.             return -EPERM;  
17.         if (file->private_data == NULL &&  
18.             cmd != ANDROID_ALARM_SET_RTC) {  
19.             spin_lock_irqsave(&alarm_slock, flags);  
20.             if (alarm_opened) {  
21.                 spin_unlock_irqrestore(&alarm_slock, flags);  
22.                 return -EBUSY;  
23.             }  
24.             alarm_opened = 1;  
25.             file->private_data = (void *)1;  
26.             spin_unlock_irqrestore(&alarm_slock, flags);  
27.         }  
28.     }  
29.   
30.     switch (ANDROID_ALARM_BASE_CMD(cmd)) {  
31.     case ANDROID_ALARM_CLEAR(0):  
32.         spin_lock_irqsave(&alarm_slock, flags);  
33.         pr_alarm(IO, "alarm %d clear\n", alarm_type);  
34.         alarm_try_to_cancel(&alarms[alarm_type]);  
35.         if (alarm_pending) {  
36.             alarm_pending &= ~alarm_type_mask;  
37.             if (!alarm_pending && !wait_pending)  
38.                 wake_unlock(&alarm_wake_lock);  
39.         }  
40.         alarm_enabled &= ~alarm_type_mask;  
41.         spin_unlock_irqrestore(&alarm_slock, flags);  
42.         break;  
43.   
44.     case ANDROID_ALARM_SET_OLD:  
45.     case ANDROID_ALARM_SET_AND_WAIT_OLD:  
46.         if (get_user(new_alarm_time.tv_sec, (int __user *)arg)) {  
47.             rv = -EFAULT;  
48.             goto err1;  
49.         }  
50.         new_alarm_time.tv_nsec = 0;  
51.         goto from_old_alarm_set;  
52.   
53.     case ANDROID_ALARM_SET_AND_WAIT(0):  
54.     case ANDROID_ALARM_SET(0):  
55.         if (copy_from_user(&new_alarm_time, (void __user *)arg,  
56.             sizeof(new_alarm_time))) {  
57.             rv = -EFAULT;  
58.             goto err1;  
59.         }  
60. from_old_alarm_set:  
61.         spin_lock_irqsave(&alarm_slock, flags);  
62.         pr_alarm(IO, "alarm %d set %ld.%09ld\n", alarm_type,  
63.             new_alarm_time.tv_sec, new_alarm_time.tv_nsec);  
64.         alarm_enabled |= alarm_type_mask;  
65.         alarm_start_range(&alarms[alarm_type],  
66.             timespec_to_ktime(new_alarm_time),  
67.             timespec_to_ktime(new_alarm_time));  
68.         spin_unlock_irqrestore(&alarm_slock, flags);  
69.         if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_SET_AND_WAIT(0)  
70.             && cmd != ANDROID_ALARM_SET_AND_WAIT_OLD)  
71.             break;  
72.         /* fall though */  
73.     case ANDROID_ALARM_WAIT:  
74.         spin_lock_irqsave(&alarm_slock, flags);  
75.         pr_alarm(IO, "alarm wait\n");  
76.         if (!alarm_pending && wait_pending) {  
77.             wake_unlock(&alarm_wake_lock);  
78.             wait_pending = 0;  
79.         }  
80.         spin_unlock_irqrestore(&alarm_slock, flags);  
81.         rv = wait_event_interruptible(alarm_wait_queue, alarm_pending);  
82.         if (rv)  
83.             goto err1;  
84.         spin_lock_irqsave(&alarm_slock, flags);  
85.         rv = alarm_pending;  
86.         wait_pending = 1;  
87.         alarm_pending = 0;  
88.         spin_unlock_irqrestore(&alarm_slock, flags);  
89.         break;  
90.     case ANDROID_ALARM_SET_RTC:  
91.         if (copy_from_user(&new_rtc_time, (void __user *)arg,  
92.             sizeof(new_rtc_time))) {  
93.             rv = -EFAULT;  
94.             goto err1;  
95.         }  
96.         rv = alarm_set_rtc(new_rtc_time);  
97.         spin_lock_irqsave(&alarm_slock, flags);  
98.         alarm_pending |= ANDROID_ALARM_TIME_CHANGE_MASK;  
99.         wake_up(&alarm_wait_queue);  
100.         spin_unlock_irqrestore(&alarm_slock, flags);  
101.         if (rv < 0)  
102.             goto err1;  
103.         break;  
104.     case ANDROID_ALARM_GET_TIME(0):  
105.         switch (alarm_type) {  
106.         case ANDROID_ALARM_RTC_WAKEUP:  
107.         case ANDROID_ALARM_RTC:  
108.             getnstimeofday(&tmp_time);  
109.             break;  
110.         case ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP:  
111.         case ANDROID_ALARM_ELAPSED_REALTIME:  
112.             tmp_time =  
113.                 ktime_to_timespec(alarm_get_elapsed_realtime());  
114.             break;  
115.         case ANDROID_ALARM_TYPE_COUNT:  
116.         case ANDROID_ALARM_SYSTEMTIME:  
117.             ktime_get_ts(&tmp_time);  
118.             break;  
119.         }  
120.         if (copy_to_user((void __user *)arg, &tmp_time,  
121.             sizeof(tmp_time))) {  
122.             rv = -EFAULT;  
123.             goto err1;  
124.         }  
125.         break;  
126.   
127.     default:  
128.         rv = -EINVAL;  
129.         goto err1;  
130.     }  
131. err1:  
132.     return rv;  
133. }  

alarm.c  里面实现了 alarm_suspend  alarm_resume 函数
就是如果系统没有suspend的时候，设置闹钟并不会往rtc 芯片的寄存器上写数据，因为不需要唤醒系统，所以闹钟数据时间什么的就通过上层写到设备文件/dev/alarm
里面就可以了，AlarmThread 会不停的去轮寻下一个时间有没有闹钟，直接从设备文件 /dev/alarm 里面读取
第二种，系统要是进入susupend的话，alarm 的alarm_suspend  就会写到下层的rtc芯片的寄存器上去， 然后即使系统suspend之后，闹钟通过rtc 也能唤醒系统。

这里就调用到了interface.c 里面   //这里面 int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 差不多 也是跟下面一样

[cpp]  view plain copy

1. int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)  
2. {  
3. ....  
4.     err = rtc->ops->set_time(rtc->dev.parent, tm);  
5. ....  
6. }  

然后set_time 就看到具体的是那个RTC芯片，这边我们是rtc-hym8563.c
然后就到了

[cpp]  view plain copy

1. static int hym8563_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], __u16 len)  
2. {  
3.     int ret;   
4.     ret = i2c_master_reg8_send(client, reg, buf, (int)len, RTC_SPEED);  
5.     return ret;  
6. }  

到此，闹钟时间就已经写到rtc 芯片的寄存器里面，第二个参数就是寄存器的名字，后面的buf就是要写入的时间，rtc芯片是额外供电的，所以系统suspend之后，系统kernel都关了，但是rtc里面还有电，寄存器里面数据还是有的（掉电就会丢失数据），所以闹钟到了，通过硬件中断机制就可以唤醒系统。

3.下面是系统唤醒之后，闹钟怎么工作的流程，简单阐述

[cpp]  view plain copy

1.  private class AlarmThread extends Thread  
2.     {  
3.         public AlarmThread()  
4.         {  
5.             super("AlarmManager");  
6.         }  
7.           
8.         public void run()  
9.         {   
10.         while (true)  
11.             {  
12.         int result = waitForAlarm(mDescriptor); //这里调用jni调用static jint android_server_AlarmManagerService_waitForAlarm，主要还是对 /dev/alarm  操作  
13.         ....  
14.         Alarm alarm = it.next();  
15.                         try {  
16.                             if (localLOGV) Slog.v(TAG, "sending alarm " + alarm);  
17.                             alarm.operation.send(mContext, 0,  
18.                                     mBackgroundIntent.putExtra(  
19.                                             Intent.EXTRA_ALARM_COUNT, alarm.count),  
20.                                     mResultReceiver, mHandler);  
21.         ....  
22.         }  
23.   
24.     }  
25.       }  
26.   
27.   
28. static jint android_server_AlarmManagerService_waitForAlarm(JNIEnv* env, jobject obj, jint fd)  
29. {  
30. #if HAVE_ANDROID_OS  
31.     int result = 0;  
32.       
33.     do  
34.     {  
35.         result = ioctl(fd, ANDROID_ALARM_WAIT);  
36.     } while (result < 0 && errno == EINTR);  
37.       
38.     if (result < 0)  
39.     {  
40.         LOGE("Unable to wait on alarm: %s\n", strerror(errno));  
41.         return 0;  
42.     }  
43.       
44.     return result;  
45. #endif  
46. }  

系统没有suspend的话直接走下面流程，如果suspend的话会被RTC唤醒，然后还是走下面的流程
AlarmManagerService  里面有个AlarmThread  会一直轮询 /dev/alarm文件，如果打开失败就直接返回，成功就会做一些动作，比如查找时间最近的
alarm，比如睡眠被闹钟唤醒的时候，这边就发一个intent出去，然后在AlarmReceiver.java里面弹出里面会收到就会调用下面的
        context.startActivity(alarmAlert);
然后弹出alarm  这个界面
        Class c = AlarmAlert.class;
其中public class AlarmAlert extends AlarmAlertFullScreen  所以系统睡眠之后被alarm唤醒弹出的alarm就是这边start的

[cpp]  view plain copy

1. public class AlarmReceiver extends BroadcastReceiver {  
2.   
3.     /** If the alarm is older than STALE_WINDOW, ignore.  It 
4.         is probably the result of a time or timezone change */  
5.     private final static int STALE_WINDOW = 30 * 60 * 1000;  
6.   
7.     @Override  
8.     public void onReceive(Context context, Intent intent) {  
9.     .........  
10.         Intent alarmAlert = new Intent(context, c);  
11.         alarmAlert.putExtra(Alarms.ALARM_INTENT_EXTRA, alarm);  
12.         alarmAlert.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK  
13.                 | Intent.FLAG_ACTIVITY_NO_USER_ACTION);  
14.         context.startActivity(alarmAlert);  
15.     ........  
16. }  

到这里alarm 就显示出来了