App定时提醒（AlarmManager实现，适配不同版本）

最新推荐文章于 2022-06-22 15:34:54 发布
最新推荐文章于 2022-06-22 15:34:54 发布
阅读量1.9k 收藏 5
点赞数
分类专栏： 系统层面内容 组件
原文链接：https://blog.csdn.net/jackzhang_0522/article/details/90694679
版权

本文主要介绍App定时提醒的实现方式及原理。篇幅较长，先提供demo地址。

项目Demo地址
AlarmSample

App定时提醒方案探讨
方案一：利用 Handler 实现。Handler可以使用 sendEmptyMessageDelayed 来实现定时发送消息(提醒)的功能，但 sendEmptyMessageDelayed 方法是依赖于 Handler 所在的线程的，如果线程结束，就起不到定时任务的效果，故不适用
方案二：利用 Timer 实现。使用 Timer 可以精确地做到定时操作，但如果手机关屏后长时间不使用， CPU 就会进入休眠模式。这个使用如果使用 Timer 来执行定时任务就会失败，因为 Timer 无法唤醒 CPU。
方案三：利用 AlarmManager 实现。AlarmManager 依赖的是 Android 系统的服务，具备唤醒机制。
AlarmManager概述
AlarmManager是Android的全局定时器。就是在指定时间做一个事情（封装在PendingIntent）。通过PendingIntent的getActivity()、getService()或getBroadcast()来执行。听起来AlarmManager和Timer很类似，但是Timer有可能因为手机休眠而被杀掉服务，但是AlarmManager可以做到唤醒手机。

AlarmManager提供了对系统定时服务的访问接口，使得开发者可以安排在未来的某个时间运行应用。当到达闹铃设定时间，系统就会广播闹铃之前注册的Intent。如果此时目标应用没有被启动，系统还会帮你自动启动目标应用。**即使设备已经进入睡眠已注册的闹铃也会被保持，只有当设备关闭或是重启的时候会被清除。**下面基于Android 8.0源码来一起学习一下。

创建方式

AlarmManager am = (AlarmManager) getSystemService(ALARM_SERVICE);



注：ALARM_SERVICE是Context的一个常量。

闹铃类型
AlarmManager中一共提供了四种闹钟类型，前两种对应的System.currentTimeMillis()（系统当前时间）时间，后两种对应SystemClock.elapsedRealtime()（系统运行时间）时间，以WAKEUP结尾的类型能够唤醒设备，其他的类型不能唤醒设备，直到设备被唤醒才能出发警报提醒。

public static final int RTC_WAKEUP = 0;// 表示闹钟在睡眠状态下唤醒系统并执行提示功能，绝对时间。
public static final int RTC = 1;// 睡眠状态下不可用，绝对时间。
public static final int ELAPSED_REALTIME_WAKEUP = 2;// 睡眠状态下可用，相对时间。
public static final int ELAPSED_REALTIME = 3;// 睡眠状态下不可用，相对时间。


注1：以上绝对时间就是手机的时间，相对时间是相对于当前开机时间来说(包含了手机睡眠时间)。例如如果是绝对时间，那么你测试可以通过修改系统时间来提前触发。而相对时间的使用场景是强调多久之后触发，例如2小时后，这个时候把时间修改到2小时后也是没用的。
注2：不同闹钟类型对应的任务首次时间的获取方法：若为ELAPSED_REALTIME_WAKEUP，那么当前时间就为 SystemClock.elapsedRealtime()；若为RTC_WAKEUP，那么当前时间就为System.currentTimeMillis()。
注3：以前还有一个POWER_OFF_WAKEUP，即使在关机后还能提醒，但是Android4.0以后就没有了。

常用方法
设置时间
在AlarmMananger中提供了setTime和setTimeZone方法分别用来设置系统时间和系统默认时区。其中，设置系统时间需要"android.permission.SET_TIME"权限。

返回值    公开方法
void    setTime(long millis)
void    setTimeZone(String timeZone)
设置闹铃
返回值    公开方法
void    set(int type, long triggerAtMillis, PendingIntent operation)
void    set(int type, long triggerAtMillis, String tag, AlarmManager.OnAlarmListener listener, Handler targetHandler)
void    setAlarmClock(AlarmManager.AlarmClockInfo info, PendingIntent operation)
void    setAndAllowWhileIdle(int type, long triggerAtMillis, PendingIntent operation)
void    setExact(int type, long triggerAtMillis, PendingIntent operation)
void    setExact(int type, long triggerAtMillis, String tag, AlarmManager.OnAlarmListener listener, Handler targetHandler)
void    setExactAndAllowWhileIdle(int type, long triggerAtMillis, PendingIntent operation)
void    setInexactRepeating(int type, long triggerAtMillis, long intervalMillis, PendingIntent operation)
void    setRepeating(int type, long triggerAtMillis, long intervalMillis, PendingIntent operation)
void    setWindow(int type, long windowStartMillis, long windowLengthMillis, PendingIntent operation)
void    setWindow(int type, long windowStartMillis, long windowLengthMillis, String tag, AlarmManager.OnAlarmListener listener, Handler targetHandler)
设置闹铃方法整理总结
1. set方法
返回值    公开方法
void    set(int type, long triggerAtMillis, PendingIntent operation)
void    set(int type, long triggerAtMillis, String tag, AlarmManager.OnAlarmListener listener, Handler targetHandler)
**用于设置一次性闹铃，执行时间在设置时间附近，为非精确闹铃。**方法一和方法二的区别：到达设定时间时方法一会广播PendingIntent中设定的Intent，而方法二会直接回调OnAlarmListener 中的onAlarm()方法。

2. setExact方法
返回值    公开方法
void    setExact(int type, long triggerAtMillis, PendingIntent operation)
void    setExact(int type, long triggerAtMillis, String tag, AlarmManager.OnAlarmListener listener, Handler targetHandler)
void    setAlarmClock(AlarmManager.AlarmClockInfo info, PendingIntent operation)
**用于设置一次性闹铃，执行时间更为精准，为精确闹铃。**方法一和二的区别参见上面set的区别。setAlarmClock方法等同于通过setExact方法设置的RTC_WAKEUP类型的闹铃，所以把他归在setExact中介绍。其中AlarmClockInfo实现了Android序列化接口Parcelable，里面包含了mTriggerTime（执行时间）和mShowIntent（执行动作）两个成员变量，可以看做是对闹铃事件的一个封装类。

3. setInexactRepeating方法和setRepeating方法
返回值    公开方法
void    setInexactRepeating(int type, long triggerAtMillis, long intervalMillis, PendingIntent operation)
void    setRepeating(int type, long triggerAtMillis, long intervalMillis, PendingIntent operation)
setInexactRepeating和setRepeating两种方法都是用来设置重复闹铃的，setRepeating执行时间更为精准。在Android 4.4之后，Android系统为了省电把时间相近的闹铃打包到一起进行批量处理，这就使得setRepeating方法设置的闹铃不能被精确的执行，必须要使用setExact来代替。

4. setAndAllowWhileIdle方法和setExactAndAllowWhileIdle方法
返回值    公开方法
void    setAndAllowWhileIdle(int type, long triggerAtMillis, PendingIntent operation)
void    setExactAndAllowWhileIdle(int type, long triggerAtMillis, PendingIntent operation)
**使用setAndAllowWhileIdle和setExactAndAllowWhileIdle方法设置一次闹铃，可以在低功耗模式下被执行，setExactAndAllowWhileIdle执行时间更为精准。**手机灭屏以后会进入低功耗模式（low-power idle modes），这个时候你会发现通过setExact设置的闹铃也不是100%准确了，需要用setExactAndAllowWhileIdle方法来设置，闹铃才能在低功耗模式下被执行。

5. setWindow方法
返回值    公开方法
void    setWindow(int type, long windowStartMillis, long windowLengthMillis, PendingIntent operation)
void    setWindow(int type, long windowStartMillis, long windowLengthMillis, String tag, AlarmManager.OnAlarmListener listener, Handler targetHandler)
**用于设置某个时间段内的一次闹铃。**比如，我想在下午的2点到4点之间设置一次提醒。两个方法的区别同set。

取消闹铃
返回值    公开方法
void    cancel(PendingIntent operation)
void    cancel(AlarmManager.OnAlarmListener listener)
用于取消设置过的闹铃，分别对应于PendingIntent和AlarmManager.OnAlarmListener方式注册的闹铃。

获得下一次闹铃事件
返回值    公开方法
AlarmManager.AlarmClockInfo    getNextAlarmClock()
用于获得下一次闹铃事件。

常用时间定义
AlarmManager类已经帮我们定义好了常用的时间常量。

public static final long INTERVAL_FIFTEEN_MINUTES = 15 * 60 * 1000;
public static final long INTERVAL_HALF_HOUR = 2*INTERVAL_FIFTEEN_MINUTES;
public static final long INTERVAL_HOUR = 2*INTERVAL_HALF_HOUR;
public static final long INTERVAL_HALF_DAY = 12*INTERVAL_HOUR;
public static final long INTERVAL_DAY = 2*INTERVAL_HALF_DAY;



设置多个闹钟
若连续设置多个闹钟，则只有最后一个闹钟会生效，那么这种情况我们怎么处理呢？其实很简单。我们可以给每个闹钟设置唯一的id，保证id唯一性即可，案例见AlarmSample。
在取消闹钟时我们也可以根据这个id关闭不同的闹钟。

不同SDK版本注意事项
SDK API < 19
正常使用 set() 和 setRepeating() 即可。

示例代码：

alarmManager.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime(), TIME_INTERVAL, pendingIntent);



SDK API >= 19 && SDK API < 23
Google 为了追求系统省电，所以“偷偷加工”了一下唤醒的时间间隔。如果在 Android 4.4 及以上的设备还要追求精准的闹钟定时任务，要使用 setExact() 方法。

示例代码：

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    alarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime(), pendingIntent);
} else {
    alarmManager.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime(), TIME_INTERVAL, pendingIntent);
}

private BroadcastReceiver alarmReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        // 重复定时任务
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            alarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + TIME_INTERVAL, pendingIntent);
        }
        // to do something
        doSomething();
    }
};


SDK API >= 23
Android 6.0 中引入了低电耗模式和应用待机模式，根据官方指导对低电耗模式和应用待机模式进行针对性优化我们需要使用 setExactAndAllowWhileIdle() 来解决在低电耗模式下的闹钟触发。

示例代码：

// pendingIntent 为发送广播
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    alarmManager.setExactAndAllowWhileIdle(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime(), pendingIntent);
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    alarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime(), pendingIntent);
} else {
    alarmManager.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime(), TIME_INTERVAL, pendingIntent);
}

private BroadcastReceiver alarmReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        // 重复定时任务
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            alarmManager.setExactAndAllowWhileIdle(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + TIME_INTERVAL, pendingIntent);
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            alarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + TIME_INTERVAL, pendingIntent);
        }
        // to do something
        doSomething();
    }
};


SDK API >= 26
Android 8.0 应用不能对大部分的广播进行静态注册，所以推荐使用Service来实现定时提醒功能，案例见AlarmSample

源码分析
设置闹铃
**通过深入分析AlarmManager的源码，发现上面提到的所有与闹铃设置有关的方法（setXXX）最终都会调用setImpl方法，区别在于不同的应用场景设置的参数不同。**setImpl方法的源码如下：   

private void setImpl(@AlarmType int type, long triggerAtMillis, long windowMillis,
            long intervalMillis, int flags, PendingIntent operation, final OnAlarmListener listener,
            String listenerTag, Handler targetHandler, WorkSource workSource,
            AlarmClockInfo alarmClock) {
        // 处理非法时间的设置
        if (triggerAtMillis < 0) {
            triggerAtMillis = 0;
        }

        // 把 OnAlarmListener 封装起来
        ListenerWrapper recipientWrapper = null;
        if (listener != null) {
            synchronized (AlarmManager.class) {
                if (sWrappers == null) {
                    sWrappers = new ArrayMap<OnAlarmListener, ListenerWrapper>();
                }

                recipientWrapper = sWrappers.get(listener);
                // no existing wrapper => build a new one
                if (recipientWrapper == null) {
                    recipientWrapper = new ListenerWrapper(listener);
                    sWrappers.put(listener, recipientWrapper);
                }
            }

            final Handler handler = (targetHandler != null) ? targetHandler : mMainThreadHandler;
            recipientWrapper.setHandler(handler);
        }
        // 调用Service的set方法
        try {
            mService.set(mPackageName, type, triggerAtMillis, windowMillis, intervalMillis, flags,
                    operation, recipientWrapper, listenerTag, workSource, alarmClock);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }


那么这个mService是哪来的呢？通过搜索在SystemServiceRegistry类中找到了一段静态方法，**SystemServiceRegistry是用来管理所有能由Context.getSystemService方法获得系统服务的类，通过ServiceManager.getServiceOrThrow根据服务名字来查找到对应的IBinder，进而生成IAlarmManager实例并作为参数传递给AlarmManager。**mService就是这个IAlarmManager实例。

   

android-8.1.0_r2/frameworks/base/core/java/android/app/SystemServiceRegistry.java
    static {  
           ...
       registerService(Context.ALARM_SERVICE, AlarmManager.class,
                new CachedServiceFetcher<AlarmManager>() {
            @Override
            public AlarmManager createService(ContextImpl ctx) throws ServiceNotFoundException {
                IBinder b = ServiceManager.getServiceOrThrow(Context.ALARM_SERVICE);
                IAlarmManager service = IAlarmManager.Stub.asInterface(b);
                return new AlarmManager(service, ctx);
            }});
          ...
    }



接下来看看 IAlarmManager 是由谁实现的呢？熟悉Android源码的同学自然而然就会想到有可能有一个AlarmManagerService类来提供具体的实现机制。搜一搜还真有这个类，进一步搜索 IAlarmManager 查看哪里实现了这个接口类（当然，熟悉AIDL机制的同学也可以直接搜索 IAlarmManager ，也能找到）。   

private final IBinder mService = new IAlarmManager.Stub() {
        // 设置闹铃的方法
        @Override
        public void set(String callingPackage,
                int type, long triggerAtTime, long windowLength, long interval, int flags,
                PendingIntent operation, IAlarmListener directReceiver, String listenerTag,
                WorkSource workSource, AlarmManager.AlarmClockInfo alarmClock) {
            final int callingUid = Binder.getCallingUid();

            // make sure the caller is not lying about which package should be blamed for
            // wakelock time spent in alarm delivery
            mAppOps.checkPackage(callingUid, callingPackage);

            // Repeating alarms must use PendingIntent, not direct listener
            if (interval != 0) {
                if (directReceiver != null) {
                    throw new IllegalArgumentException("Repeating alarms cannot use AlarmReceivers");
                }
            }

            if (workSource != null) {
                getContext().enforcePermission(
                        android.Manifest.permission.UPDATE_DEVICE_STATS,
                        Binder.getCallingPid(), callingUid, "AlarmManager.set");
            }

            // No incoming callers can request either WAKE_FROM_IDLE or
            // ALLOW_WHILE_IDLE_UNRESTRICTED -- we will apply those later as appropriate.
            flags &= ~(AlarmManager.FLAG_WAKE_FROM_IDLE
                    | AlarmManager.FLAG_ALLOW_WHILE_IDLE_UNRESTRICTED);

            // Only the system can use FLAG_IDLE_UNTIL -- this is used to tell the alarm
            // manager when to come out of idle mode, which is only for DeviceIdleController.
            if (callingUid != Process.SYSTEM_UID) {
                flags &= ~AlarmManager.FLAG_IDLE_UNTIL;
            }

            // If this is an exact time alarm, then it can't be batched with other alarms.
            if (windowLength == AlarmManager.WINDOW_EXACT) {
                flags |= AlarmManager.FLAG_STANDALONE;
            }

            // If this alarm is for an alarm clock, then it must be standalone and we will
            // use it to wake early from idle if needed.
            if (alarmClock != null) {
                flags |= AlarmManager.FLAG_WAKE_FROM_IDLE | AlarmManager.FLAG_STANDALONE;

            // If the caller is a core system component or on the user's whitelist, and not calling
            // to do work on behalf of someone else, then always set ALLOW_WHILE_IDLE_UNRESTRICTED.
            // This means we will allow these alarms to go off as normal even while idle, with no
            // timing restrictions.
            } else if (workSource == null && (callingUid < Process.FIRST_APPLICATION_UID
                    || callingUid == mSystemUiUid
                    || Arrays.binarySearch(mDeviceIdleUserWhitelist,
                            UserHandle.getAppId(callingUid)) >= 0)) {
                flags |= AlarmManager.FLAG_ALLOW_WHILE_IDLE_UNRESTRICTED;
                flags &= ~AlarmManager.FLAG_ALLOW_WHILE_IDLE;
            }
            // 最终会调用AlarmManagerService的setImpl方法
            setImpl(type, triggerAtTime, windowLength, interval, operation, directReceiver,
                    listenerTag, flags, workSource, alarmClock, callingUid, callingPackage);
        }
        ...
    };


从上面这段源码可以看出，set方法最终会调用AlarmManagerService的setImpl方法。在setImpl中，根据传递的参数经过一系列的计算，传递给setImplLocked方法进行下一步处理。

   

 void setImpl(int type, long triggerAtTime, long windowLength, long interval,
            PendingIntent operation, IAlarmListener directReceiver, String listenerTag,
            int flags, WorkSource workSource, AlarmManager.AlarmClockInfo alarmClock,
            int callingUid, String callingPackage) {
        ...
        synchronized (mLock) {
            ...
            setImplLocked(type, triggerAtTime, triggerElapsed, windowLength, maxElapsed,
                    interval, operation, directReceiver, listenerTag, flags, true, workSource,
                    alarmClock, callingUid, callingPackage);
        }
    }



setImplLocked方法会把传递过来的参数封装成一个Alarm对象，调用setImplLocked的另一个重载方法。在setImplLocked中，会去计算Alarm所属的批次（Batch），然后根据批次进行重新打包，打包后对内核Alarm进行重新规划，更新下一个Alarm时间。   

private void setImplLocked(int type, long when, long whenElapsed, long windowLength,
            long maxWhen, long interval, PendingIntent operation, IAlarmListener directReceiver,
            String listenerTag, int flags, boolean doValidate, WorkSource workSource,
            AlarmManager.AlarmClockInfo alarmClock, int callingUid, String callingPackage) {
        // 参数封装成一个Alarm对象
        Alarm a = new Alarm(type, when, whenElapsed, windowLength, maxWhen, interval,
                operation, directReceiver, listenerTag, workSource, flags, alarmClock,
                callingUid, callingPackage);
        try {
            if (ActivityManager.getService().isAppStartModeDisabled(callingUid, callingPackage)) {
                Slog.w(TAG, "Not setting alarm from " + callingUid + ":" + a
                        + " -- package not allowed to start");
                return;
            }
        } catch (RemoteException e) {
        }
        removeLocked(operation, directReceiver);
        setImplLocked(a, false, doValidate);
    }

    private void setImplLocked(Alarm a, boolean rebatching, boolean doValidate) {
        // 计算alarm所属的批次
        int whichBatch = ((a.flags&AlarmManager.FLAG_STANDALONE) != 0)
                ? -1 : attemptCoalesceLocked(a.whenElapsed, a.maxWhenElapsed);
        if (whichBatch < 0) {
            Batch batch = new Batch(a);
            addBatchLocked(mAlarmBatches, batch);
        } else {
            Batch batch = mAlarmBatches.get(whichBatch);
            if (batch.add(a)) {
                // The start time of this batch advanced, so batch ordering may
                // have just been broken.  Move it to where it now belongs.
                mAlarmBatches.remove(whichBatch);
                addBatchLocked(mAlarmBatches, batch);
            }
        }
       ...
        if (!rebatching) {
            ...
            if (needRebatch) {
                // 重新打包所有的Alarm
                rebatchAllAlarmsLocked(false);
            }
            // 重新规划内核的Alarm
            rescheduleKernelAlarmsLocked();
            // 更新下一个Alarm的时间
            updateNextAlarmClockLocked();
        }
    }


在rescheduleKernelAlarmsLocked方法中会调用setLocked方法，setLocked方法内部会去调用native方法set，最终把Alarm设置到内核中去。   

private void setLocked(int type, long when) {
        if (mNativeData != 0) {
            // The kernel never triggers alarms with negative wakeup times
            // so we ensure they are positive.
            long alarmSeconds, alarmNanoseconds;
            if (when < 0) {
                alarmSeconds = 0;
                alarmNanoseconds = 0;
            } else {
                alarmSeconds = when / 1000;
                alarmNanoseconds = (when % 1000) * 1000 * 1000;
            }
            // native方法
            set(mNativeData, type, alarmSeconds, alarmNanoseconds);
        } else {
            Message msg = Message.obtain();
            msg.what = ALARM_EVENT;

            mHandler.removeMessages(ALARM_EVENT);
            mHandler.sendMessageAtTime(msg, when);
        }
    }


取消闹铃
**在AlarmManager提供了两个cancel方法来取消闹铃，调用时候需要传递一个PendingIntent或是OnAlarmListener实例作为参数，从此也可以看出闹铃服务内部是以PendingIntent或是OnAlarmListener作为区分不同闹铃的唯一标识的。**cancel(PendingIntent operation) 和 cancel(OnAlarmListener listener) 的实现原理是差不多的，最终都会调用mService.remove方法来移除闹铃，这里以 cancel(PendingIntent operation) 方法为例进行详细分析。   

public void cancel(PendingIntent operation) {
        // 如果 PendingIntent 为空，在N和之后的版本会抛出空指针异常
        if (operation == null) {
            final String msg = "cancel() called with a null PendingIntent";
            if (mTargetSdkVersion >= Build.VERSION_CODES.N) {
                throw new NullPointerException(msg);
            } else {
                Log.e(TAG, msg);
                return;
            }
        }

        try {
            // mService是一个IBinder，由来及对应方法的实现同上面设置闹铃中的解析
            mService.remove(operation, null);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }


mService.remove方法中首先会去判断PendingIntent 和 IAlarmListener 是否都为空，有一个不为空则调用removeLocked继续进行处理。

   

private final IBinder mService = new IAlarmManager.Stub() {
        ...
         // 取消闹铃的方法
        @Override
        public void remove(PendingIntent operation, IAlarmListener listener) {
            // PendingIntent 和 IAlarmListener 必须有一个不为空
            if (operation == null && listener == null) {
                Slog.w(TAG, "remove() with no intent or listener");
                return;
            }
            synchronized (mLock) {
                // 调用AlarmManagerService中的removeLocked方法
                removeLocked(operation, listener);
            }
        }
        ...
    };



在removeLocked方法中，会根据传递过来的参数在mAlarmBatches和mPendingWhileIdleAlarms两个列表中查询当前要删除的Alarm，如果匹配到则删除。删除后会对所有闹铃重新打包，如果删除的是非低功耗模式下启动的闹铃则需要刷新非低功耗下启动的闹铃设置，最后更新下一次闹铃时间。   

private void removeLocked(PendingIntent operation, IAlarmListener directReceiver) {
        // 遍历查询并删除匹配的Alarms
        boolean didRemove = false;
        for (int i = mAlarmBatches.size() - 1; i >= 0; i--) {
            Batch b = mAlarmBatches.get(i);
            didRemove |= b.remove(operation, directReceiver);
            if (b.size() == 0) {
                mAlarmBatches.remove(i);
            }
        }
        for (int i = mPendingWhileIdleAlarms.size() - 1; i >= 0; i--) {
            if (mPendingWhileIdleAlarms.get(i).matches(operation, directReceiver)) {
                // Don't set didRemove, since this doesn't impact the scheduled alarms.
                mPendingWhileIdleAlarms.remove(i);
            }
        }

        if (didRemove) {
            if (DEBUG_BATCH) {
                Slog.v(TAG, "remove(operation) changed bounds; rebatching");
            }
            boolean restorePending = false;
            if (mPendingIdleUntil != null && mPendingIdleUntil.matches(operation, directReceiver)) {
                mPendingIdleUntil = null;
                restorePending = true;
            }
            if (mNextWakeFromIdle != null && mNextWakeFromIdle.matches(operation, directReceiver)) {
                mNextWakeFromIdle = null;
            }
            // 重新打包所有的闹铃
            rebatchAllAlarmsLocked(true);
            if (restorePending) {
                // 重新存储非低功耗下启动的闹铃
                restorePendingWhileIdleAlarmsLocked();
            }
            // 更新下一次闹铃时间
            updateNextAlarmClockLocked();
        }
    }


最终在restorePendingWhileIdleAlarmsLocked方法中会调用rescheduleKernelAlarmsLocked和updateNextAlarmClockLocked 重新规划内核的Alarm并更新下一个Alarm的时间。

    void restorePendingWhileIdleAlarmsLocked() {
        ...
        // 重新规划内核的Alarm
        rescheduleKernelAlarmsLocked();
        // 更新下一个Alarm的时间
        updateNextAlarmClockLocked();
        ...
    }



获得下一次闹铃事件
AlarmManager提供了getNextAlarmClock方法来获得下一次闹铃事件，该方法中会把当前的UserId作为查询依据传递到AlarmManagerService中的getNextAlarmClockImpl方法，从而查询出当前用户所对应的下一次闹铃事件。    frameworks/base/core/java/android/app/AlarmManager.java
   

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

    public AlarmClockInfo getNextAlarmClock(int userId) {
        try {
            return mService.getNextAlarmClock(userId);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }

    frameworks/base/services/core/java/com/android/server/AlarmManagerService.java
    private final IBinder mService = new IAlarmManager.Stub() {
        ...
         // 获得下次闹铃事件
        @Override
        public AlarmManager.AlarmClockInfo getNextAlarmClock(int userId) {
            userId = ActivityManager.handleIncomingUser(Binder.getCallingPid(),
                    Binder.getCallingUid(), userId, false /* allowAll */, false /* requireFull */,
                    "getNextAlarmClock", null);

            return getNextAlarmClockImpl(userId);
        }
        ...
    };

    AlarmManager.AlarmClockInfo getNextAlarmClockImpl(int userId) {
        synchronized (mLock) {
            return mNextAlarmClockForUser.get(userId);
        }
    }


设置系统时间
设置系统时间的功能实现流程比较简单，在AlarmManager提供的setTime方法中直接调用mService.setTime方法，进而通过AlarmManagerService中声明的native方法setKernelTime把时间设置到底层内核中去。

    frameworks/base/core/java/android/app/AlarmManager.java
   

public void setTime(long millis) {
        try {
            mService.setTime(millis);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    } 

 

frameworks/base/services/core/java/com/android/server/AlarmManagerService.java
   

private final IBinder mService = new IAlarmManager.Stub() {
        ...
         // 设置系统时钟的方法
        @Override
        public boolean setTime(long millis) {
            // 注意，设置系统时间需要"android.permission.SET_TIME"权限
            getContext().enforceCallingOrSelfPermission(
                    "android.permission.SET_TIME",
                    "setTime");

            if (mNativeData == 0) {
                Slog.w(TAG, "Not setting time since no alarm driver is available.");
                return false;
            }

            synchronized (mLock) {
                // native 方法，直接设置到底层kernel中
                return setKernelTime(mNativeData, millis) == 0;
            }
        }
        ...
    };


设置系统时区
在AlarmManager提供的setTimeZone方法中直接调用mService的setTimeZone方法，进而调用AlarmManagerService的setTimeZoneImpl方法，并由此方法完成整个系统时区设置的相关逻辑（包括系统属性值修改、设置内核时区和广播系统时区变化）。

    frameworks/base/core/java/android/app/AlarmManager.java
   

 public void setTimeZone(String timeZone) {
        ...
        try {
            mService.setTimeZone(timeZone);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    } 

 

frameworks/base/services/core/java/com/android/server/AlarmManagerService.java
   

private final IBinder mService = new IAlarmManager.Stub() {
        ...
         // 设置系统默认时区的方法
        @Override
        public void setTimeZone(String tz) {
            getContext().enforceCallingOrSelfPermission(
                    "android.permission.SET_TIME_ZONE",
                    "setTimeZone");

            final long oldId = Binder.clearCallingIdentity();
            try {
                setTimeZoneImpl(tz);
            } finally {
                Binder.restoreCallingIdentity(oldId);
            }
        }
        ...
    };

    void setTimeZoneImpl(String tz) {
        ...
        boolean timeZoneWasChanged = false;
        synchronized (this) {
            String current = SystemProperties.get(TIMEZONE_PROPERTY);
            if (current == null || !current.equals(zone.getID())) {
                timeZoneWasChanged = true;
                // 设置SystemProperties中时区对应的字段值
                SystemProperties.set(TIMEZONE_PROPERTY, zone.getID());
            }

            int gmtOffset = zone.getOffset(System.currentTimeMillis());
            // native 方法，直接设置到底层kernel中
            setKernelTimezone(mNativeData, -(gmtOffset / 60000));
        }

        TimeZone.setDefault(null);
        // 广播系统时区变化
        if (timeZoneWasChanged) {
            Intent intent = new Intent(Intent.ACTION_TIMEZONE_CHANGED);
            intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING
                    | Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND
                    | Intent.FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS);
            intent.putExtra("time-zone", zone.getID());
            getContext().sendBroadcastAsUser(intent, UserHandle.ALL);
        }
    }



总结
设置系统时间需要"android.permission.SET_TIME"权限。
每当有新的Alarm设置或删除定时服务都会重新计算所属批次，把时间相近的Alarm打包到一个批次里(Batch)一起执行，起到优化电池节省耗电的目的。这就是导致非精确Alarm执行时间存在不确定误差的根本原因。
如果想要在低耗电模式下触发闹铃需要通过 setAndAllowWhileIdle 和 setExactAndAllowWhileIdle 方法来设置闹铃。
如果设置的闹铃时间已经过了，闹铃会被立即触发。这个问题可以通过比较闹铃设置时间和当前时间来解决。
根据实际需求选择是否设置精确闹铃以达到优化电池节省耗电的目的。
通过设置时区的源码可知，如果想要获取系统时区的相关信息可以通过监听Intent.ACTION_TIMEZONE_CHANGED广播或是直接读取系统属性TIMEZONE_PROPERTY。
————————————————
版权声明：本文为CSDN博主「Typist夫少」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/jackzhang_0522/article/details/90694679

锐湃
关注
专栏目录
android 如何在完全退出APP后延时调出通知，实现定时推送信息到通知栏
yue_233的博客
04-23 4923
android 如何在完全退出APP后延时调出通知（类似于保活） 很好，项目总监在我开心的YY的时候过来提了一个需求：当游戏退出时，请注意不是退出后台，是完全退出的那种，你给加个功能：8小时后弹出通知，你要赶紧起来玩游戏了，睡什么睡！！！ 好强盗，上有政策，中有孙策，下有玄策，好嘛，这把开局有点难打,那么开干吧，看在钱的面子上------ 实现定时推送信息到通知栏 分析： 1.如何触发通知，那肯...
使用AlarmManager实现定时提醒，解决锁屏后无法正常唤醒CPU和屏幕的问题
泥巴城 的博客
04-10 7907
之前写过一个demo来实现定时操作，最近帮别人写项目的时候又用到了这个需求，于是coding起来。 首先来说一下我的实现思路：用户选择好闹钟提醒时间后我要启动一个Service，在这个Service里面设置闹钟，通过闹钟直接打开一个Activity来显示提醒信息。我想要创建一个不在通知栏中显示notification的前台Service，这样就可以让Service一直运行了，除非你在手机的“最近任...
Android实现每天定时提醒功能
08-30
本文主要介绍了Android每天定时提醒功能、定时功能、闹钟的相关知识。具有很好的参考价值，下面跟着小编一起来看下吧
android实现每天定时提醒的功能
袁震的博客
12-27 6903
有时开发中有这样的需求，每天几点定时提醒等等，下面就来实现这个功能。 首先新建一个广播接收者 public class AlarmReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { Log.e("-----...
Android中AlarmManager+Notification实现定时通知提醒功能
08-29
本篇文章主要介绍了Android中AlarmManager+Notification实现定时通知提醒功能，非常具有实用价值，需要的朋友可以参考下
android定时提醒功能,Android后台定时提醒功能实现
weixin_33174392的博客
05-30 1438
需要类似的功能，找了很久，估计这个能让我实现。转一下。https://blog.csdn.net/qq_34445403/article/details/78727477考虑到自己每次在敲代码或者打游戏的时候总是会不注意时间，一不留神就对着电脑连续3个小时以上，对眼睛的伤害还是挺大的，重度近视了可是会遗传给将来的孩子的呀，可能老婆都跟别人跑了。于是，为了保护眼睛，便做了个如下的应用：打开后效果：好...
提醒AndroidApp
02-19
为了实现良好的用户体验，"提醒AndroidApp"可能还包含了对触摸事件、滑动手势的支持，以及适配不同屏幕尺寸和方向的布局资源。此外，单元测试和集成测试是确保应用稳定性和功能完整性不可或缺的步骤。 总的来说，...
Android 闹钟app 源码 可以自己设定时间 ，适配android 8,9,10,11
12-23
10. **版本适配**: 源码特别提到适配Android 8到11，这意味着它可能包含了针对不同Android版本的兼容性处理，例如使用Support Library或AndroidX库，处理API级别的差异。 通过深入研究这个源码，开发者不仅可以学习...
定时静音app
06-03
8. 电池优化：为了让定时静音功能在电池优化模式下依然有效，应用需要适配Doze模式和App Standby特性，确保AlarmManager在这些模式下仍能正常工作。 总结起来，【定时静音app】是一个基于安卓平台的实用工具，利用...
android中定时提醒Demo（调用系统闹钟）
08-12
android定时提醒，调用系统闹钟程序定时，定时时间到了，响铃通知
AlarmManager实现精准定时任务
11-03
app进程中，需要实现一个定时任务，只要设备处于开机状态，每隔半个小时，就需要定时向服务器上传一次位置信息，并且只要是有网络和获取到GPS信号，进程不能死，如果进程死掉了，需要自动重启。
Android定时闹钟完美实现
11-14
这个是一个完美实现闹钟的实例，模仿手机系统的闹钟实现方式，定时设置时间，设置星期1-7，设置震动和延迟时间，设置闹铃。可以定时的提醒用户
Android健康计步系统app源码设计与实现
开发一个完整的Android应用是一个复杂的工程，需要面对各种挑战，包括但不限于应用性能优化、内存泄漏预防、适配不同屏幕尺寸和分辨率、以及各种Android设备和系统版本的兼容性问题。本项目作为本科毕业设计，其源码...
Android 广播事件机制
白璐 | 产品经理
12-27 1699
学习Android广播事件机制，并实现简单的定时提醒功能 涉及的主要内容：1) AlarmManager 和 PendingIntent 2) BroadReceiver 3) Notification and NotificationManager     1.Android广播事件机制      Android的广播事件处理类似于普通的事件处理。不同之处在于，后者是靠点击按钮这样的组件
android 定时提醒 - Notification
07-14 498
定时弹出 demo ,代码如下: 1.MainActivity.java public class MainActivity extends Activity implements OnClickListener { private static Context sContext = null; private EditText date; priv...
安卓手机上如何设置待办定时提醒？
cuicq77的博客
06-22 384
随着国产安卓手机的发展，现在越来越多的网友都开始选择国产的安卓手机了，例如小米、荣耀、OPPO、vivo等品牌就是非常不错的国产手机厂商，受到了很多用户的青睐。但是大家在使用手机设置一些待办事项提醒的时候，发现手机上除了闹钟之外，就没有专业的定时提醒软件了，而手机闹钟上的定时提醒功能，并不能够满足日常设置多种形式提醒时间的需求。那么有没有一款支持在安卓手机端使用的定时提醒软件推荐呢？答案当然是有的，云便签这款多功能记事、提醒手机便签待办就是值得推荐的。首先作为一款记事软件，云便签的便签分类中是支持我们添加文
android 实现定时通知,在Android中创建定时通知(例如,针对事件)
weixin_39520393的博客
05-26 409
对于某些Android应用程序,我想集成以下功能：用户可以定义他想要被提醒的时间.当时间到了,应用程序应该在通知栏中创建通知,即使此时用户没有使用该应用程序.为此,需要查看AlarmManager,NotificationManager和Notification.Builder类,对吧？那么我该如何提前创建定时通知呢？我的代码(到目前为止)是这样的：将其添加到AndroidManifest下以注册...
Android应用的定时通知实现
WoodyHD的专栏
09-04 3121
在移动应用的开发中，我们经常会遇到定时提醒用户的需求，比如：电影票预订后在电影开始前两个小时提醒用户电影时间。 我的思路大致如下： 1.使用AlarmManager设置闹钟 既然要使用定时服务，那么自然第一个想到的是闹钟。AlarmManager可在指定的时间或者指定周期启动其他组件（包括Activity、Service、BroadcastReceiver）。 比如： // 指定启动A
Android后台定时提醒实现：Service与AlarmManager结合
"Android后台定时提醒功能实现" 在Android开发中，创建一个后台定时提醒功能是一项常见的需求，尤其对于健康或时间管理类的应用来说至关重要。以下将详细解释如何利用Service、AlarmManager以及Notification来实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值