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
plaincopy

public static long setAlarm(Context context, Alarm alarm) {

ContentValues values = createContentValues(alarm);

ContentResolver resolver = context.getContentResolver();

resolver.update(

ContentUris.withAppendedId(Alarm.Columns.CONTENT_URI, alarm.id),

values, null, null);

long timeInMillis = calculateAlarm(alarm);

if (alarm.enabled) {

// Disable the snooze if we just changed the snoozed alarm. This

// only does work if the snoozed alarm is the same as the given

// alarm.

// TODO: disableSnoozeAlert should have a better name.

disableSnoozeAlert(context, alarm.id);

// Disable the snooze if this alarm fires before the snoozed alarm.

// This works on every alarm since the user most likely intends to

// have the modified alarm fire next.

clearSnoozeIfNeeded(context, timeInMillis);

}

setNextAlert(context);

return timeInMillis;

}

然后这里面也会调用到

[cpp] view
plaincopy

public static void setNextAlert(final Context context) {

final Alarm alarm = calculateNextAlert(context);

if (alarm != null) {

enableAlert(context, alarm, alarm.time);

} else {

disableAlert(context);

}

}

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
plaincopy

public void set(int type, long triggerAtTime, PendingIntent operation) {

try {

mService.set(type, triggerAtTime, operation);

} catch (RemoteException ex) {

}

}

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

[cpp] view
plaincopy

public void set(int type, long triggerAtTime, PendingIntent operation) {

setRepeating(type, triggerAtTime, 0, operation);

}

然后继续调用

[cpp] view
plaincopy

public void setRepeating(int type, long triggerAtTime, long interval,

PendingIntent operation) {

.....

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);

}

}

}

然后就调用到

[cpp] view
plaincopy

private void setLocked(Alarm alarm)

{

......

set(mDescriptor, alarm.type, alarmSeconds, alarmNanoseconds); //mDescriptor 这里的文件是 /dev/alarm

.....

}

这里就调用到jni了

private native void set(int fd, int type, long seconds, long nanoseconds);

这就调用到了com_android_server_AlarmManagerService.cpp 里面

[cpp] view
plaincopy

static JNINativeMethod sMethods[] = {

/* name, signature, funcPtr */

{"init", "()I", (void*)android_server_AlarmManagerService_init},

{"close", "(I)V", (void*)android_server_AlarmManagerService_close},

{"set", "(IIJJ)V", (void*)android_server_AlarmManagerService_set},

{"waitForAlarm", "(I)I", (void*)android_server_AlarmManagerService_waitForAlarm},

{"setKernelTimezone", "(II)I", (void*)android_server_AlarmManagerService_setKernelTimezone},

};

set 对应的是android_server_AlarmManagerService_set， 具体是

[cpp] view
plaincopy

static void android_server_AlarmManagerService_set(JNIEnv* env, jobject obj, jint fd, jint type, jlong seconds, jlong nanoseconds)

{

#if HAVE_ANDROID_OS

struct timespec ts;

ts.tv_sec = seconds;

ts.tv_nsec = nanoseconds;

int result = ioctl(fd, ANDROID_ALARM_SET(type), &ts);

if (result < 0)

{

LOGE("Unable to set alarm to %lld.%09lld: %s\n", seconds, nanoseconds, strerror(errno));

}

#endif

}

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

[cpp] view
plaincopy

static long alarm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

{

int rv = 0;

unsigned long flags;

struct timespec new_alarm_time;

struct timespec new_rtc_time;

struct timespec tmp_time;

enum android_alarm_type alarm_type = ANDROID_ALARM_IOCTL_TO_TYPE(cmd);

uint32_t alarm_type_mask = 1U << alarm_type;

printk(">>%s cmd == %d\n",__FUNCTION__,cmd);

if (alarm_type >= ANDROID_ALARM_TYPE_COUNT)

return -EINVAL;

if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_GET_TIME(0)) {

if ((file->f_flags & O_ACCMODE) == O_RDONLY)

return -EPERM;

if (file->private_data == NULL &&

cmd != ANDROID_ALARM_SET_RTC) {

spin_lock_irqsave(&alarm_slock, flags);

if (alarm_opened) {

spin_unlock_irqrestore(&alarm_slock, flags);

return -EBUSY;

}

alarm_opened = 1;

file->private_data = (void *)1;

spin_unlock_irqrestore(&alarm_slock, flags);

}

}

switch (ANDROID_ALARM_BASE_CMD(cmd)) {

case ANDROID_ALARM_CLEAR(0):

spin_lock_irqsave(&alarm_slock, flags);

pr_alarm(IO, "alarm %d clear\n", alarm_type);

alarm_try_to_cancel(&alarms[alarm_type]);

if (alarm_pending) {

alarm_pending &= ~alarm_type_mask;

if (!alarm_pending && !wait_pending)

wake_unlock(&alarm_wake_lock);

}

alarm_enabled &= ~alarm_type_mask;

spin_unlock_irqrestore(&alarm_slock, flags);

break;

case ANDROID_ALARM_SET_OLD:

case ANDROID_ALARM_SET_AND_WAIT_OLD:

if (get_user(new_alarm_time.tv_sec, (int __user *)arg)) {

rv = -EFAULT;

goto err1;

}

new_alarm_time.tv_nsec = 0;

goto from_old_alarm_set;

case ANDROID_ALARM_SET_AND_WAIT(0):

case ANDROID_ALARM_SET(0):

if (copy_from_user(&new_alarm_time, (void __user *)arg,

sizeof(new_alarm_time))) {

rv = -EFAULT;

goto err1;

}

from_old_alarm_set:

spin_lock_irqsave(&alarm_slock, flags);

pr_alarm(IO, "alarm %d set %ld.%09ld\n", alarm_type,

new_alarm_time.tv_sec, new_alarm_time.tv_nsec);

alarm_enabled |= alarm_type_mask;

alarm_start_range(&alarms[alarm_type],

timespec_to_ktime(new_alarm_time),

timespec_to_ktime(new_alarm_time));

spin_unlock_irqrestore(&alarm_slock, flags);

if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_SET_AND_WAIT(0)

&& cmd != ANDROID_ALARM_SET_AND_WAIT_OLD)

break;

/* fall though */

case ANDROID_ALARM_WAIT:

spin_lock_irqsave(&alarm_slock, flags);

pr_alarm(IO, "alarm wait\n");

if (!alarm_pending && wait_pending) {

wake_unlock(&alarm_wake_lock);

wait_pending = 0;

}

spin_unlock_irqrestore(&alarm_slock, flags);

rv = wait_event_interruptible(alarm_wait_queue, alarm_pending);

if (rv)

goto err1;

spin_lock_irqsave(&alarm_slock, flags);

rv = alarm_pending;

wait_pending = 1;

alarm_pending = 0;

spin_unlock_irqrestore(&alarm_slock, flags);

break;

case ANDROID_ALARM_SET_RTC:

if (copy_from_user(&new_rtc_time, (void __user *)arg,

sizeof(new_rtc_time))) {

rv = -EFAULT;

goto err1;

}

rv = alarm_set_rtc(new_rtc_time);

spin_lock_irqsave(&alarm_slock, flags);

alarm_pending |= ANDROID_ALARM_TIME_CHANGE_MASK;

wake_up(&alarm_wait_queue);

spin_unlock_irqrestore(&alarm_slock, flags);

if (rv < 0)

goto err1;

break;

case ANDROID_ALARM_GET_TIME(0):

switch (alarm_type) {

case ANDROID_ALARM_RTC_WAKEUP:

case ANDROID_ALARM_RTC:

getnstimeofday(&tmp_time);

break;

case ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP:

case ANDROID_ALARM_ELAPSED_REALTIME:

tmp_time =

ktime_to_timespec(alarm_get_elapsed_realtime());

break;

case ANDROID_ALARM_TYPE_COUNT:

case ANDROID_ALARM_SYSTEMTIME:

ktime_get_ts(&tmp_time);

break;

}

if (copy_to_user((void __user *)arg, &tmp_time,

sizeof(tmp_time))) {

rv = -EFAULT;

goto err1;

}

break;

default:

rv = -EINVAL;

goto err1;

}

err1:

return rv;

}

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
plaincopy

int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)

{

....

err = rtc->ops->set_time(rtc->dev.parent, tm);

....

}

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

然后就到了

[cpp] view
plaincopy

static int hym8563_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], __u16 len)

{

int ret;

ret = i2c_master_reg8_send(client, reg, buf, (int)len, RTC_SPEED);

return ret;

}

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

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

[cpp] view
plaincopy

private class AlarmThread extends Thread

{

public AlarmThread()

{

super("AlarmManager");

}

public void run()

{

while (true)

{

int result = waitForAlarm(mDescriptor); //这里调用jni调用static jint android_server_AlarmManagerService_waitForAlarm，主要还是对 /dev/alarm 操作

....

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);

....

}

}

}

static jint android_server_AlarmManagerService_waitForAlarm(JNIEnv* env, jobject obj, jint fd)

{

#if HAVE_ANDROID_OS

int result = 0;

do

{

result = ioctl(fd, ANDROID_ALARM_WAIT);

} while (result < 0 && errno == EINTR);

if (result < 0)

{

LOGE("Unable to wait on alarm: %s\n", strerror(errno));

return 0;

}

return result;

#endif

}

系统没有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
plaincopy

public class AlarmReceiver extends BroadcastReceiver {

/** If the alarm is older than STALE_WINDOW, ignore. It

is probably the result of a time or timezone change */

private final static int STALE_WINDOW = 30 * 60 * 1000;

@Override

public void onReceive(Context context, Intent intent) {

.........

Intent alarmAlert = new Intent(context, c);

alarmAlert.putExtra(Alarms.ALARM_INTENT_EXTRA, alarm);

alarmAlert.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK

| Intent.FLAG_ACTIVITY_NO_USER_ACTION);

context.startActivity(alarmAlert);

........

}

到这里alarm 就显示出来了