Android 闹钟详解_android 定时闹钟覆盖

最近再做一个项目需要用到Android中的闹钟提醒，在这个过程中遇到很多问题，今天在这里总结分享给大家，希望能对读者有所帮助：

我们都知道Android总共有三种内置的闹钟类型，如下：

（1）set(int type，long startTime，PendingIntent pi)；

该方法用于设置一次性闹钟，第一个参数表示闹钟类型，第二个参数表示闹钟执行时间，第三个参数表示闹钟响应动作。

（2）setRepeating(int type，long startTime，long intervalTime，PendingIntent pi)；

该方法用于设置重复闹钟，第一个参数表示闹钟类型，第二个参数表示闹钟首次执行时间，第三个参数表示闹钟两次执行的间隔时间，第三个参数表示闹钟响应动作。

（3）setInexactRepeating（int type，long startTime，long intervalTime，PendingIntent pi）；

该方法也用于设置重复闹钟，与第二个方法相似，不过其两个闹钟执行的间隔时间不是固定的而已。

在项目中用到了第一种和第二种，第三种没有涉及到。

现在先说一下前两种闹钟最基本的用法（摘自于网络），再详细讲述我在项目中遇到的问题和最终是如何解决的。

为了测试的方便直接在Android studio中自动生成activity的oncreate方法里测试了：

一、（1）在指定时长后执行某项操作

代码如下：

public class MainActivity extends AppCompatActivity {
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent =new Intent(this, AlarmReceiver.class);
        PendingIntent sender= PendingIntent.getBroadcast(this, 0, intent, 0);
        Calendar calendar= Calendar.getInstance();
        calendar.setTimeInMillis(System.currentTimeMillis());//将时间设定为系统目前的时间
        calendar.add(Calendar.SECOND, 5);//系统时间推迟五秒钟，如果为-5，那么就是比系统时间提前五秒钟
        AlarmManager alarm=(AlarmManager)getSystemService(ALARM_SERVICE);
        alarm.set(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), sender);
    }
}

Toast.makeText(context, "short alarm", Toast.LENGTH_LONG).show();

为了测试的方便我们定义了一个广播接收器，代码如下：

public class AlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Toast.makeText(context, "short alarm", Toast.LENGTH_LONG).show();
    }
}

这段代码什么时候执行呢？我们先讲讲在上面activity中用到的令人非常头疼的PendingIntent ，最令人头疼的就是第二个和第四个参数了，暂且定为0（ 稍后会讲 ）

PendingIntent sender：是闹钟的执行动作，比如发送一个广播、给出提示等等。PendingIntent是Intent的封装类。需要注意的是，如果是通过启动服务来实现闹钟提示的话，PendingIntent对象的获取就应该采用Pending.getService( Context  c,int i,Intent intent,int j)方法；如果是通过广播来实现闹钟提示的话PendingIntent对象的获取就应该采用PendingIntent.getBroadcast(Context c,int i,Intent intent,int j)方法；如果是采用Activity的方式来实现闹钟提示的话，PendingIntent对象的获取就应该采用PendingIntent.getActivity(Context c,int i,Intent intent,int j)方法。如果这三种方法错用了的话，虽然不会报错，但是看不到闹钟提示效果。

从某种意义上来说PendingIntent 其实就是一个延迟的Intent,它将Intent进行了封装，为什么说是延迟呢，是因为当达到某种条件后他才会触发Intent的动作。在本例中就是到运行之后的五秒钟触发Intent的动作，也就是发送一条广播了，提示闹钟设定成功了。至此，上面的例子也就解释的差不多了。顺便把

AlarmManager类型如下：

AlarmManager.RTC，硬件闹钟，不唤醒手机（也可能是其它设备）休眠；当手机休眠时不发射闹钟。


AlarmManager.RTC_WAKEUP，硬件闹钟，当闹钟发射时唤醒手机休眠；


AlarmManager.ELAPSED_REALTIME，真实时间流逝闹钟，不唤醒手机休眠；当手机休眠时不发射闹钟。


AlarmManager.ELAPSED_REALTIME_WAKEUP，真实时间流逝闹钟，当闹钟发射时唤醒手机休眠；
RTC闹钟和ELAPSED_REALTIME最大的差别就是前者可以通过修改手机时间触发闹钟事件，后者要通过真实时间的流逝，即使在休眠状态，时间也会被计算。

（2）周期性的执行某项操作

public class MainActivity extends AppCompatActivity {
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent =new Intent(this, AlarmReceiver.class);
        PendingIntent sender= PendingIntent.getBroadcast(this, 0, intent, 0);
        long firstime = SystemClock.elapsedRealtime();
        AlarmManager am=(AlarmManager)getSystemService(ALARM_SERVICE);
        //5秒一个周期，不停的发送广播
        am.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, firstime, 5 * 1000, sender);
    }
}

public class AlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Toast.makeText(context, "short alarm", Toast.LENGTH_LONG).show();
    }
}

上面的例子是一个周期性的，每五秒发送一条广播

二、在实际项目中遇到的以下问题及解决办法

项目中有这么一个需求，有很多不同的日程需要不同周期的提醒，如下：

在实际编码中可能你会想到以下的一个循环

        switch (repeatType) {  //repeatType闹钟周期重复的类型
            case NEVER: //永不
                AlarmManager manager1 = (AlarmManager) getSystemService(ALARM_SERVICE);
                Intent intent1 = new Intent(this, AlarmReceiver.class);
                PendingIntent pi1 = PendingIntent.getBroadcast(this, 0, intent2, 0);
                manager.set(AlarmManager.RTC_WAKEUP, startTime,intervalTime1 , pi1);
                break;
            case EVERY_DAY: //每天
                AlarmManager manager2 = (AlarmManager) getSystemService(ALARM_SERVICE);
                Intent intent2 = new Intent(this, AlarmReceiver.class);
                PendingIntent pi2 = PendingIntent.getBroadcast(this, 0, intent2, 0);
                manager.setRepeating(AlarmManager.RTC_WAKEUP, startTime,intervalTime2, pi2);//如果当前时间大于了开始时间，则还会提醒了
                break;
            case EVERY_WEEK:  //每周
                AlarmManager manager3 = (AlarmManager) getSystemService(ALARM_SERVICE);
                Intent intent3 = new Intent(this, AlarmReceiver.class);
                PendingIntent pi3 = PendingIntent.getBroadcast(this, 0, intent3, 0);
                manager3.setRepeating(AlarmManager.RTC_WAKEUP,startTime,intervalTime3,pi3);//如果当前时间大于了开始时间，则还会提醒了
                break;
            case TWO_WEEK:   //每两周
                AlarmManager manager4 = (AlarmManager) getSystemService(ALARM_SERVICE);
                Intent intent4 = new Intent(this, AlarmReceiver.class);
                PendingIntent pi4 = PendingIntent.getBroadcast(this, 0, intent4, 0);
                manager4.setRepeating(AlarmManager.RTC_WAKEUP,startTime,intervalTime4,pi4);
                break;
            case EVERY_MONTH: //每月
                AlarmManager manager5 = (AlarmManager) getSystemService(ALARM_SERVICE);
                Intent intent5 = new Intent(this, AlarmReceiver.class);
                PendingIntent pi5 = PendingIntent.getBroadcast(this, 0, intent5, 0);
                manager5.setRepeating(AlarmManager.RTC_WAKEUP,startTime,intervalTime5,pi5);
    }

上面的intervalTime对应的是间隔时间也就日、周、两周、月…………
这样的思路是没有问题的，但是这样做会出现两个问题：

第一问题：假设现在是八点，你设定的闹钟是七点，那么程序一运行接着就会触发闹钟，这一点需要避免，直接加个判断语句，现在的时间要小于设定时间的时候才能触发闹钟

第二个问题：闹钟的覆盖。Android中的闹钟如果是一样的话，后面的闹钟会覆盖掉前面的闹钟，例如设定了八点和七点的闹钟，那么八点的闹钟会覆盖掉七点的闹钟，最后只会响应一个八点的闹钟。那么怎么区分出不同的闹钟呢，那么就是我们将要讲的 PendingIntent pi = PendingIntent.getBroadcast(this, 0, intent, 0);里面的第二个参数了，这个参数来区分不同的闹钟，我们只需要传进去一个不同的整形值就不再覆盖之前的闹钟了，可以取一个全局变量i,然后这样定义 PendingIntent pi1 = PendingIntent.getBroadcast(this, i++, intent2, 0);,这样就避免了闹钟的覆盖。那么接着问题又来了，我们假设要取消其中的一个周期闹钟，我们应该怎么办呢？

我采用的方法如下

结合上面的讲解，这样定义一个PendingIntent:

  Intent intent = new Intent(this, AlarmReceiver.class);
        intent.putExtra("alarm_type", ++alarmCount + "");
        PendingIntent pi = PendingIntent.getBroadcast(this, alarmCount, intent, 0);
 manager.setRepeating(AlarmManager.RTC_WAKEUP,startTime,intervalTime,pi);

然后当时间到了之后会发送一条广播，我们在广播接收器里取消闹钟，注意和上面的代码对比一下，要取消的是同一个闹钟

public class AlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        AlarmManager manager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
        PendingIntent pi = PendingIntent.getBroadcast(context, Integer.parseInt(intent.getStringExtra("alarm_type")), intent, 0);
        manager.cancel(pi);
    }
}

通过上面的办法就可以取消想要取消的闹钟

后来在结合的代码的时候，主管提出新的要求了：如果两个不同的事件定在同一个时间提醒，如果按照上面的办法会同时弹出两个对话框提醒（因为是两个不同的闹钟），现在要做的就是要合并到一个闹钟，采用列表的形式提醒用户这两个事件到了时间提醒了，也就是一个闹钟。在这个过程中又遇到了一个问题，纠结了我一下午才解决出来，最后只是一个参数的问题，上代码吧：

    private void setAlarmTime(long startTime, ArrayList<Agenda> oneListAgenda) {
 
        AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
        String[] titleArray = new String[oneListAgenda.size()];
        for (int i = 0; i < oneListAgenda.size(); i++) {
            titleArray[i] = oneListAgenda.get(i).getAg_title();
        }
        
        intentReceiver.putExtra("titleArray", titleArray);
        PendingIntent pi = PendingIntent.getBroadcast(this, alarmCount, intentReceiver,0);
        manager.set(AlarmManager.RTC_WAKEUP, startTime, pi);
    }

上面的titleArray数组存着相同时间的日程，这样会出现什么问题呢？

假设设定了一个事件，接着执行了这段代码，接着PendingIntent就会被注册了，如果设定同一个时间的另一个事件，再运行这段代码的时候，这样titleArray里面就是两个值，但是我在广播接收器里取出这个数组的时候，却变成了一个值，究其原因就是PendingIntent 的最后一个参数问题，运行到此处时重新注册一个PendingIntent 就可以了，设置如下：

 PendingIntent pi = PendingIntent.getBroadcast(this, alarmCount, intentReceiver, PendingIntent.FLAG_UPDATE_CURRENT);

上面就是我在项目中遇到的问题，希望对像我一样刚入门的人有所帮助！