_dowork
_dowork

Android 6.0 之AlarmManagerService源码分析

AlarmManager实质上是一个全局定时器，是Android中常用的一种系统服务级别的提示服务，在指定时间或周期性启动其他组件（Activity、Service、BroadcastReceiver）。

之前有篇文章专门介绍了AlarmManager定时器的使用方法，获取到服务后，调用该服务的一些设置方法，在设定时间到达后就会启动指定的组件。

AlarmManagerService和JobSchedulerService一样都是系统服务，故它们的启动流程也类似，先看下时序图：

Android 6.0 之AlarmManagerService源码分析_第1张图片

Zygote进程启动后会启动System进程，在System进程启动过程中会启动系统中的关键服务，如AMS、PMS、JobSchedulerService以及这里要分析的AlarmManagerService。

SystemServer启动AlarmManagerService服务调用的是SystemServiceManager类的startService方法：

[java] view plain copy
  1. private void startOtherServices() {  
  2.     try {  
  3.         . . .  
  4.         mSystemServiceManager.startService(AlarmManagerService.class);  
  5.         . . .  
  6.     } catch (RuntimeException e) {  
  7.         Slog.e("System", "******************************************");  
  8.         Slog.e("System", "************ Failure starting core service", e);  
  9.     }  
  10. }  


SystemServiceManager类的startService方法在JobSchedulerService的分析中已经分析过，这里粘贴写代码：

[java] view plain copy
  1. private final ArrayList mServices = new ArrayList();  
  2.   
  3. /** 
  4.  * 创建并启动一个继承自SystemService类的系统服务。 
  5.  * 
  6.  * @param 一个继承自SystemService类的服务类  
  7.  * @return 服务类的实例 
  8.  * @throws 如果服务启动失败则抛RuntimeException异常 
  9.  */  
  10. @SuppressWarnings("unchecked")  
  11. public extends SystemService> T startService(Class serviceClass) {  
  12.     // 获取服务类的类名  
  13.     final String name = serviceClass.getName();  
  14.     Slog.i(TAG, "Starting " + name);  
  15.   
  16.     // 判断服务类是否是SystemService的子类  
  17.     if (!SystemService.class.isAssignableFrom(serviceClass)) {  
  18.         throw new RuntimeException("Failed to create " + name  
  19.                 + ": service must extend " + SystemService.class.getName());  
  20.     }  
  21.     final T service;  
  22.     try {  
  23.         // 获取服务类包含一个Context参数的构造方法  
  24.         Constructor constructor = serviceClass.getConstructor(Context.class);  
  25.         // 创建这个服务类的实例  
  26.         service = constructor.newInstance(mContext);  
  27.     } catch (InstantiationException ex) {  
  28.         throw new RuntimeException("Failed to create service " + name  
  29.                 + ": service could not be instantiated", ex);  
  30.     } catch (IllegalAccessException ex) {  
  31.         throw new RuntimeException("Failed to create service " + name  
  32.                 + ": service must have a public constructor with a Context argument", ex);  
  33.     } catch (NoSuchMethodException ex) {  
  34.         throw new RuntimeException("Failed to create service " + name  
  35.                 + ": service must have a public constructor with a Context argument", ex);  
  36.     } catch (InvocationTargetException ex) {  
  37.         throw new RuntimeException("Failed to create service " + name  
  38.                 + ": service constructor threw an exception", ex);  
  39.     }  
  40.   
  41.     // 把服务添加到mServices列表中，方便后续使用时取出  
  42.     mServices.add(service);  
  43.   
  44.     try {  
  45.         // 回调服务的onStart方法  
  46.         service.onStart();  
  47.     } catch (RuntimeException ex) {  
  48.         throw new RuntimeException("Failed to start service " + name  
  49.                 + ": onStart threw an exception", ex);  
  50.     }  
  51.     return service;  
  52. }  


在开启AlarmManagerService服务时，会创建服务的实例，看下该服务的创建过程：

[java] view plain copy
  1. final AlarmHandler mHandler = new AlarmHandler();  
  2. final Constants mConstants;  
  3.   
  4. public AlarmManagerService(Context context) {  
  5.     super(context);  
  6.     // 初始化Handler和常量Constants类  
  7.     mConstants = new Constants(mHandler);  
  8. }  


初始化Handler的代码后面调用时再分析，这里先看下常量类的实现：

[java] view plain copy
  1. /** 
  2.  * 该类中所有的时间单位都是毫秒。 
  3.  * 这些常量保持与系统全局设置一致。 
  4.  * 任何访问该类或该类中的字段都要持有AlarmManagerService.mLock锁 
  5.  */  
  6. private final class Constants extends ContentObserver {  
  7.     // 在设置中保存的键值  
  8.     private static final String KEY_MIN_FUTURITY = "min_futurity";  
  9.     private static final String KEY_MIN_INTERVAL = "min_interval";  
  10.     private static final String KEY_ALLOW_WHILE_IDLE_SHORT_TIME = "allow_while_idle_short_time";  
  11.     private static final String KEY_ALLOW_WHILE_IDLE_LONG_TIME = "allow_while_idle_long_time";  
  12.     private static final String KEY_ALLOW_WHILE_IDLE_WHITELIST_DURATION  
  13.             = "allow_while_idle_whitelist_duration";  
  14.   
  15.     private static final long DEFAULT_MIN_FUTURITY = 5 * 1000;  
  16.     private static final long DEFAULT_MIN_INTERVAL = 60 * 1000;  
  17.     private static final long DEFAULT_ALLOW_WHILE_IDLE_SHORT_TIME = DEFAULT_MIN_FUTURITY;  
  18.     private static final long DEFAULT_ALLOW_WHILE_IDLE_LONG_TIME = 9*60*1000;  
  19.     private static final long DEFAULT_ALLOW_WHILE_IDLE_WHITELIST_DURATION = 10*1000;  
  20.   
  21.     // Minimum futurity of a new alarm  
  22.     public long MIN_FUTURITY = DEFAULT_MIN_FUTURITY;  
  23.   
  24.     // Minimum alarm recurrence interval  
  25.     public long MIN_INTERVAL = DEFAULT_MIN_INTERVAL;  
  26.   
  27.     // 从系统非空闲状态到可以执行flag为ALLOW_WHILE_IDLE的alarm的最小时间间隔:5秒钟  
  28.     public long ALLOW_WHILE_IDLE_SHORT_TIME = DEFAULT_ALLOW_WHILE_IDLE_SHORT_TIME;  
  29.   
  30.     // 从系统空闲状态到可以执行flag为ALLOW_WHILE_IDLE的alarm的最小时间间隔:9分钟  
  31.     public long ALLOW_WHILE_IDLE_LONG_TIME = DEFAULT_ALLOW_WHILE_IDLE_LONG_TIME;  
  32.   
  33.     // BroadcastOptions.setTemporaryAppWhitelistDuration() to use for FLAG_ALLOW_WHILE_IDLE.  
  34.     public long ALLOW_WHILE_IDLE_WHITELIST_DURATION  
  35.             = DEFAULT_ALLOW_WHILE_IDLE_WHITELIST_DURATION;  
  36.   
  37.     private ContentResolver mResolver;  
  38.     private final KeyValueListParser mParser = new KeyValueListParser(',');  
  39.     private long mLastAllowWhileIdleWhitelistDuration = -1;  
  40.   
  41.     public Constants(Handler handler) {  
  42.         super(handler);  
  43.         // 更新可以开始执行flag为ALLOW_WHILE_IDLE的alarm的最小时间间隔  
  44.         updateAllowWhileIdleMinTimeLocked();  
  45.         updateAllowWhileIdleWhitelistDurationLocked();  
  46.     }  
  47.   
  48.     // 系统启动后会调用该方法，注册数据库监听  
  49.     public void start(ContentResolver resolver) {  
  50.         mResolver = resolver;  
  51.         // 监听数据库变化  
  52.         mResolver.registerContentObserver(Settings.Global.getUriFor(  
  53.                 Settings.Global.ALARM_MANAGER_CONSTANTS), false, this);  
  54.         updateConstants();  
  55.     }  
  56.   
  57.     // 更新可以开始执行flag为ALLOW_WHILE_IDLE的alarm的最小时间间隔  
  58.     public void updateAllowWhileIdleMinTimeLocked() {  
  59.         mAllowWhileIdleMinTime = mPendingIdleUntil != null  
  60.                 ? ALLOW_WHILE_IDLE_LONG_TIME : ALLOW_WHILE_IDLE_SHORT_TIME;  
  61.     }  
  62.   
  63.     public void updateAllowWhileIdleWhitelistDurationLocked() {  
  64.         if (mLastAllowWhileIdleWhitelistDuration != ALLOW_WHILE_IDLE_WHITELIST_DURATION) {  
  65.             mLastAllowWhileIdleWhitelistDuration = ALLOW_WHILE_IDLE_WHITELIST_DURATION;  
  66.             BroadcastOptions opts = BroadcastOptions.makeBasic();  
  67.             opts.setTemporaryAppWhitelistDuration(ALLOW_WHILE_IDLE_WHITELIST_DURATION);  
  68.             mIdleOptions = opts.toBundle();  
  69.         }  
  70.     }  
  71.   
  72.     @Override  
  73.     public void onChange(boolean selfChange, Uri uri) {  
  74.         // 数据库内容变化时，更新一些本地变量  
  75.         updateConstants();  
  76.     }  
  77.     . . .  
  78. }  


看下AlarmManagerService类的onStart方法：

[java] view plain copy
  1. long mNativeData;  
  2. // 下一个包含wakeup的batch的start时间  
  3. private long mNextWakeup;  
  4. // 下一个包含Rtc wakeup的batch的start时间  
  5. private long mNextRtcWakeup;  
  6. // 下一个非wakeup的batch的start时间  
  7. private long mNextNonWakeup;  
  8. static final String TIMEZONE_PROPERTY = "persist.sys.timezone";  
  9. PowerManager.WakeLock mWakeLock;  
  10. // 时间变化发送者  
  11. PendingIntent mTimeTickSender;  
  12. // 日期变化发送者  
  13. PendingIntent mDateChangeSender;  
  14. // 时间变化的广播接收者  
  15. ClockReceiver mClockReceiver;  
  16. // 监听息屏/亮屏的广播接收者  
  17. InteractiveStateReceiver mInteractiveStateReceiver;  
  18. // 监听卸载的广播接收者  
  19. private UninstallReceiver mUninstallReceiver;  
  20.   
  21. @Override  
  22. public void onStart() {  
  23.     // 通过JNI对mNativeData进行初始化操作:  
  24.     // 打开设备驱动"/dev/alarm"返回一个long型的与fd文件描述符有关的值  
  25.     mNativeData = init();  
  26.     mNextWakeup = mNextRtcWakeup = mNextNonWakeup = 0;  
  27.   
  28.     // 把当前时区信息保存到内核  
  29.     setTimeZoneImpl(SystemProperties.get(TIMEZONE_PROPERTY));  
  30.   
  31.     // 初始化wakelock  
  32.     PowerManager pm = (PowerManager) getContext().getSystemService(Context.POWER_SERVICE);  
  33.     mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*alarm*");  
  34.   
  35.     // 初始化时间变化的广播发送者，因为这里的接收者是ALL，所以所有的应用程序收到的ACTION_TIME_TICK广播都是这里发送的  
  36.     mTimeTickSender = PendingIntent.getBroadcastAsUser(getContext(), 0,  
  37.             new Intent(Intent.ACTION_TIME_TICK).addFlags(  
  38.                     Intent.FLAG_RECEIVER_REGISTERED_ONLY  
  39.                     | Intent.FLAG_RECEIVER_FOREGROUND), 0,  
  40.                     UserHandle.ALL);  
  41.     // 初始化mDateChangeSender  
  42.     Intent intent = new Intent(Intent.ACTION_DATE_CHANGED);  
  43.     intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);  
  44.     mDateChangeSender = PendingIntent.getBroadcastAsUser(getContext(), 0, intent,  
  45.             Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT, UserHandle.ALL);  
  46.       
  47.     // 初始化驱动来调度alarm  
  48.     // 注册时间/日期变化广播接收者  
  49.     mClockReceiver = new ClockReceiver();  
  50.     // 调度时间变化事件，第一次发送时间变化广播，实现：在当前时间延迟一分钟后发送  
  51.     // 在ClockReceiver的onReceive方法中接收到时间变化的广博就会调用  
  52.     // scheduleTimeTickEvent方法发送一分钟后的广播  
  53.     mClockReceiver.scheduleTimeTickEvent();  
  54.     // 调度日期变化事件，每天0点发送一次广播  
  55.     mClockReceiver.scheduleDateChangedEvent();  
  56.     // 初始化监听息屏/亮屏的广播接收者  
  57.     mInteractiveStateReceiver = new InteractiveStateReceiver();  
  58.     // 监听应用卸载和SD卡不可用的广播，判断是否移除alarm  
  59.     mUninstallReceiver = new UninstallReceiver();  
  60.       
  61.     if (mNativeData != 0) {  
  62.         // 初始化AlarmThread并运行它的run方法  
  63.         AlarmThread waitThread = new AlarmThread();  
  64.         waitThread.start();  
  65.     } else {  
  66.         Slog.w(TAG, "Failed to open alarm driver. Falling back to a handler.");  
  67.     }  
  68.   
  69.     // 发布服务  
  70.     publishBinderService(Context.ALARM_SERVICE, mService);  
  71. }  
  72.   
  73. private native long init();  
  74.   
  75. // 把当前时区保存到内核  
  76. void setTimeZoneImpl(String tz) {  
  77.     if (TextUtils.isEmpty(tz)) {  
  78.         return;  
  79.     }  
  80.   
  81.     // 获取要保存的时区  
  82.     TimeZone zone = TimeZone.getTimeZone(tz);  
  83.     // 写入时区时，避免同时写  
  84.     boolean timeZoneWasChanged = false;  
  85.     synchronized (this) {  
  86.         // 再次获取要保存的时区  
  87.         String current = SystemProperties.get(TIMEZONE_PROPERTY);  
  88.         // 如果两次获取的时区不一致则说明时区发生变化，并重新把当前时区保存到设置中  
  89.         if (current == null || !current.equals(zone.getID())) {  
  90.             if (localLOGV) {  
  91.                 Slog.v(TAG, "timezone changed: " + current + ", new=" + zone.getID());  
  92.             }  
  93.             timeZoneWasChanged = true;  
  94.             SystemProperties.set(TIMEZONE_PROPERTY, zone.getID());  
  95.         }  
  96.   
  97.         // Update the kernel timezone information  
  98.         // Kernel tracks time offsets as 'minutes west of GMT'  
  99.         // 更新内核时区信息  
  100.         // 内核跟踪时间偏移为GMT以西的分钟数  
  101.         int gmtOffset = zone.getOffset(System.currentTimeMillis());  
  102.         // 保存时区到内核  
  103.         setKernelTimezone(mNativeData, -(gmtOffset / 60000));  
  104.     }  
  105.   
  106.     TimeZone.setDefault(null);  
  107.   
  108.     // 如果时区发生改变则发送时区改变的广播  
  109.     if (timeZoneWasChanged) {  
  110.         Intent intent = new Intent(Intent.ACTION_TIMEZONE_CHANGED);  
  111.         intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);  
  112.         intent.putExtra("time-zone", zone.getID());  
  113.         getContext().sendBroadcastAsUser(intent, UserHandle.ALL);  
  114.     }  
  115. }  
  116.   
  117. // 保存时区信息到内核中  
  118. private native int setKernelTimezone(long nativeData, int minuteswest);  
  119.   
  120. // 时间/日期变化广播接收者  
  121. class ClockReceiver extends BroadcastReceiver {  
  122.     public ClockReceiver() {  
  123.         // 注册时间/日期变化的广播接收者  
  124.         IntentFilter filter = new IntentFilter();  
  125.         filter.addAction(Intent.ACTION_TIME_TICK);  
  126.         filter.addAction(Intent.ACTION_DATE_CHANGED);  
  127.         getContext().registerReceiver(this, filter);  
  128.     }  
  129.       
  130.     @Override  
  131.     public void onReceive(Context context, Intent intent) {  
  132.         if (intent.getAction().equals(Intent.ACTION_TIME_TICK)) {  
  133.             if (DEBUG_BATCH) {  
  134.                 Slog.v(TAG, "Received TIME_TICK alarm; rescheduling");  
  135.             }  
  136.             // 收到时间变化的广播，发送时间变化的广播给所有的接收者  
  137.             scheduleTimeTickEvent();  
  138.         } else if (intent.getAction().equals(Intent.ACTION_DATE_CHANGED)) {  
  139.             // 由于内核不跟踪DST时间，所以需要在每天开始时，基于当前时区的gmt偏移 + 用户空间跟踪保存的信息来重置时区信息  
  140.             TimeZone zone = TimeZone.getTimeZone(SystemProperties.get(TIMEZONE_PROPERTY));  
  141.             int gmtOffset = zone.getOffset(System.currentTimeMillis());  
  142.             // 日期变化时更新内核保存的时区信息  
  143.             setKernelTimezone(mNativeData, -(gmtOffset / 60000));  
  144.             // 调度日期变化事件  
  145.             scheduleDateChangedEvent();  
  146.         }  
  147.     }  
  148.       
  149.     // 一分钟后给所有接收ACTION_TIME_TICK广播的接收者发送广播  
  150.     public void scheduleTimeTickEvent() {  
  151.         final long currentTime = System.currentTimeMillis();  
  152.         final long nextTime = 60000 * ((currentTime / 60000) + 1);  
  153.   
  154.         // 下一次执行事件的延迟时间  
  155.         final long tickEventDelay = nextTime - currentTime;  
  156.   
  157.         final WorkSource workSource = null; // Let system take blame for time tick events.  
  158.         // 调用setImpl方法设置给所有接收ACTION_TIME_TICK广播的接收者发送广播  
  159.         setImpl(ELAPSED_REALTIME, SystemClock.elapsedRealtime() + tickEventDelay, 0,  
  160.                 0, mTimeTickSender, AlarmManager.FLAG_STANDALONE, workSource, null,  
  161.                 Process.myUid());  
  162.     }  
  163.   
  164.     // 调度日期变化事件  
  165.     public void scheduleDateChangedEvent() {  
  166.         Calendar calendar = Calendar.getInstance();  
  167.         calendar.setTimeInMillis(System.currentTimeMillis());  
  168.         calendar.set(Calendar.HOUR, 0);  
  169.         calendar.set(Calendar.MINUTE, 0);  
  170.         calendar.set(Calendar.SECOND, 0);  
  171.         calendar.set(Calendar.MILLISECOND, 0);  
  172.         calendar.add(Calendar.DAY_OF_MONTH, 1);  
  173.   
  174.         final WorkSource workSource = null; // Let system take blame for date change events.  
  175.         // 设置mDateChangeSender  
  176.         setImpl(RTC, calendar.getTimeInMillis(), 0, 0, mDateChangeSender,  
  177.                 AlarmManager.FLAG_STANDALONE, workSource, null, Process.myUid());  
  178.     }  
  179. }  
  180.   
  181. // 修正参数并设置传递过来的PendingIntent  
  182. void setImpl(int type, long triggerAtTime, long windowLength, long interval,  
  183.         PendingIntent operation, int flags, WorkSource workSource,  
  184.         AlarmManager.AlarmClockInfo alarmClock, int callingUid) {  
  185.     if (operation == null) {  
  186.         Slog.w(TAG, "set/setRepeating ignored because there is no intent");  
  187.         return;  
  188.     }  
  189.   
  190.     /*下面要修正传递过来的PendingIntent各相关参数了，所以可以在这里增加对alarm的管控规则*/  
  191.   
  192.     // 检查时间窗长度，如果超过半天就转换成一小时。  
  193.     if (windowLength > AlarmManager.INTERVAL_HALF_DAY) {  
  194.         Slog.w(TAG, "Window length " + windowLength  
  195.                 + "ms suspiciously long; limiting to 1 hour");  
  196.         windowLength = AlarmManager.INTERVAL_HOUR;  
  197.     }  
  198.   
  199.     // 检查alarm的执行周期，如果alarm的执行周期小于1分钟，则转换为1分钟。  
  200.     // 从这里可以得知周期性alarm的最小有效周期为1分钟，若要执行周期小于1分钟的事，不能使用alarm实现  
  201.     final long minInterval = mConstants.MIN_INTERVAL;// 1分钟  
  202.     if (interval > 0 && interval < minInterval) {  
  203.         Slog.w(TAG, "Suspiciously short interval " + interval  
  204.                 + " millis; expanding to " + (minInterval/1000)  
  205.                 + " seconds");  
  206.         interval = minInterval;  
  207.     }  
  208.   
  209.     // 检查type的合法性  
  210.     if (type < RTC_WAKEUP || type > RTC_POWEROFF_WAKEUP) {  
  211.         throw new IllegalArgumentException("Invalid alarm type " + type);  
  212.     }  
  213.   
  214.     // 检查triggerAtTime的合法性  
  215.     if (triggerAtTime < 0) {  
  216.         final long what = Binder.getCallingPid();  
  217.         Slog.w(TAG, "Invalid alarm trigger time! " + triggerAtTime + " from uid=" + callingUid  
  218.                 + " pid=" + what);  
  219.         triggerAtTime = 0;  
  220.     }  
  221.   
  222.     final long nowElapsed = SystemClock.elapsedRealtime();  
  223.     // 把RTC格式的转换成elapsedRealtime格式的触发时间  
  224.     final long nominalTrigger = convertToElapsed(triggerAtTime, type);  
  225.     // 为了防止alarm频繁滥发执行，这里把当前时间延迟5秒当做alarm的最早触发时间  
  226.     final long minTrigger = nowElapsed + mConstants.MIN_FUTURITY;// 5秒  
  227.     final long triggerElapsed = (nominalTrigger > minTrigger) ? nominalTrigger : minTrigger;  
  228.   
  229.     final long maxElapsed;  
  230.     if (windowLength == AlarmManager.WINDOW_EXACT) {  
  231.         // 如果alarm的时间窗为0，说明为精确时间执行的alarm，则把上面计算得到的触发时间赋值给最晚触发时间  
  232.         maxElapsed = triggerElapsed;  
  233.     } else if (windowLength < 0) {  
  234.         // 计算alarm的最晚触发时间  
  235.         maxElapsed = maxTriggerTime(nowElapsed, triggerElapsed, interval);  
  236.         // 根据最晚触发时间修正alarm的时间窗时间  
  237.         windowLength = maxElapsed - triggerElapsed;  
  238.     } else {  
  239.         // 如果时间窗时间大于0，则把触发时间+时间窗时间赋值给最晚触发时间  
  240.         maxElapsed = triggerElapsed + windowLength;  
  241.     }  
  242.   
  243.     synchronized (mLock) {  
  244.         if (DEBUG_BATCH) {  
  245.             Slog.v(TAG, "set(" + operation + ") : type=" + type  
  246.                     + " triggerAtTime=" + triggerAtTime + " win=" + windowLength  
  247.                     + " tElapsed=" + triggerElapsed + " maxElapsed=" + maxElapsed  
  248.                     + " interval=" + interval + " flags=0x" + Integer.toHexString(flags));  
  249.         }  
  250.         // 根据修正后的各参数进一步设置alarm  
  251.         setImplLocked(type, triggerAtTime, triggerElapsed, windowLength, maxElapsed,  
  252.                 interval, operation, flags, true, workSource, alarmClock, callingUid);  
  253.     }  
  254. }  
  255.   
  256. // 如果alarm的执行时间设置的是RTC则需要转换成开机时间  
  257. static long convertToElapsed(long when, int type) {  
  258.     final boolean isRtc = (type == RTC || type == RTC_WAKEUP  
  259.             || type == RTC_POWEROFF_WAKEUP);  
  260.     if (isRtc) {  
  261.         when -= System.currentTimeMillis() - SystemClock.elapsedRealtime();  
  262.     }  
  263.     return when;  
  264. }  
  265.   
  266. // 最小重复周期  
  267. static final long MIN_FUZZABLE_INTERVAL = 10000;  
  268.   
  269. // 最晚触发时间  
  270. static long maxTriggerTime(long now, long triggerAtTime, long interval) {  
  271.     long futurity = (interval == 0)  
  272.             ? (triggerAtTime - now)  
  273.             : interval;  
  274.     // 如果下一次触发的时间小于10秒则不为alarm增加最晚触发时间  
  275.     if (futurity < MIN_FUZZABLE_INTERVAL) {  
  276.         futurity = 0;  
  277.     }  
  278.     // 把0.75倍的下次触发时间+触发时间赋值给alarm的maxElapsed  
  279.     return triggerAtTime + (long)(.75 * futurity);  
  280. }  
  281.   
  282. // 根据传递来的各alarm相关参数进一步设置alarm  
  283. private void setImplLocked(int type, long when, long whenElapsed, long windowLength,  
  284.         long maxWhen, long interval, PendingIntent operation, int flags,  
  285.         boolean doValidate, WorkSource workSource, AlarmManager.AlarmClockInfo alarmClock,  
  286.         int uid) {  
  287.     // 根据传递过来的参数重新创建一个alarm实例  
  288.     Alarm a = new Alarm(type, when, whenElapsed, windowLength, maxWhen, interval,  
  289.             operation, workSource, flags, alarmClock, uid);  
  290.     // 根据operation参数从所在列表中移除该alarm  
  291.     removeLocked(operation);  
  292.     // 把新创建的alarm添加到相关列表  
  293.     setImplLocked(a, false, doValidate);  
  294. }  
  295.   
  296. // alarm批处理对象列表  
  297. final ArrayList mAlarmBatches = new ArrayList<>();  
  298. // 延迟到空闲状态时执行的alarm列表  
  299. ArrayList mPendingWhileIdleAlarms = new ArrayList<>();  
  300. // 由于空闲时开始执行的alarm只有一个，故后续其他也需要在空闲时开始执行的alarm就需要保存在mPendingWhileIdleAlarms列表中  
  301. Alarm mPendingIdleUntil = null;  
  302. // 下一个请求退出空闲模式的alarm  
  303. Alarm mNextWakeFromIdle = null;  
  304.   
  305. // 根据operation从各列表中查找alarm并移除  
  306. private void removeLocked(PendingIntent operation) {  
  307.     boolean didRemove = false;  
  308.     // 遍历mAlarmBatches查找目标alarm  
  309.     for (int i = mAlarmBatches.size() - 1; i >= 0; i--) {  
  310.         Batch b = mAlarmBatches.get(i);  
  311.         ArrayList alarmList = b.alarms;  
  312.         Alarm alarm = null;  
  313.         for (int j = alarmList.size() - 1; j >= 0; j--) {  
  314.             alarm = alarmList.get(j);  
  315.             if (alarm.type == RTC_POWEROFF_WAKEUP && alarm.operation.equals(operation)) {  
  316.                 long alarmSeconds, alarmNanoseconds;  
  317.                 alarmSeconds = alarm.when / 1000;  
  318.                 alarmNanoseconds = (alarm.when % 1000) * 1000 * 1000;  
  319.                 // 遍历所有alarm，找到和目标operation相同的alarm，  
  320.                 // 如果该alarm的类型是Rtc wakeup的则清空在驱动中的相关设置  
  321.                 clear(mNativeData, alarm.type, alarmSeconds, alarmNanoseconds);  
  322.                 mNextRtcWakeup = 0;  
  323.             }  
  324.         }  
  325.         // 把和目标operation相同的alarm从批处理中移除掉  
  326.         didRemove |= b.remove(operation);  
  327.         // 移除alarm后，如果批处理的长度为0，则从mAlarmBatches中移除掉该批处理对象  
  328.         if (b.size() == 0) {  
  329.             mAlarmBatches.remove(i);  
  330.         }  
  331.     }  
  332.     // 遍历mPendingWhileIdleAlarms查找目标alarm并移除  
  333.     for (int i = mPendingWhileIdleAlarms.size() - 1; i >= 0; i--) {  
  334.         if (mPendingWhileIdleAlarms.get(i).operation.equals(operation)) {  
  335.             // 从mPendingWhileIdleAlarms列表中移除alarm不用设置didRemove字段，  
  336.             // 因为该列表中的alarm都是在手机转变到空闲状态时执行的，并不影响alarm的调度。  
  337.             mPendingWhileIdleAlarms.remove(i);  
  338.         }  
  339.     }  
  340.   
  341.     // 如果从相关列表中移除相关alarm，则需要重新处理各相关列表中的alarm  
  342.     if (didRemove) {  
  343.         if (DEBUG_BATCH) {  
  344.             Slog.v(TAG, "remove(operation) changed bounds; rebatching");  
  345.         }  
  346.         boolean restorePending = false;  
  347.         // 查找目标alarm是否为mPendingIdleUntil，如果是则赋null，下面会重新存储空闲时延迟执行的alarm  
  348.         if (mPendingIdleUntil != null && mPendingIdleUntil.operation.equals(operation)) {  
  349.             mPendingIdleUntil = null;  
  350.             restorePending = true;  
  351.         }  
  352.         // 查找目标alarm是否为mNextWakeFromIdle，如果是则赋null  
  353.         if (mNextWakeFromIdle != null && mNextWakeFromIdle.operation.equals(operation)) {  
  354.             mNextWakeFromIdle = null;  
  355.         }  
  356.         // 对所有的alarm进行重新批处理操作  
  357.         rebatchAllAlarmsLocked(true);  
  358.         if (restorePending) {  
  359.             // 由于mPendingIdleUntil变量改变，所以需要重新存储空闲时延迟执行的alarm  
  360.             restorePendingWhileIdleAlarmsLocked();  
  361.         }  
  362.         // 更新下一个alarm的alarmClock  
  363.         updateNextAlarmClockLocked();  
  364.     }  
  365. }  
  366.   
  367. // 根据alarm的类型、触发时间等参数从驱动中移除掉该alarm  
  368. private native void clear(long nativeData, int type, long seconds, long nanoseconds);  
  369.   
  370. // 对所有的alarm进行重新批处理操作  
  371. void rebatchAllAlarmsLocked(boolean doValidate) {  
  372.     ArrayList oldSet = (ArrayList) mAlarmBatches.clone();  
  373.     mAlarmBatches.clear();  
  374.     Alarm oldPendingIdleUntil = mPendingIdleUntil;  
  375.     final long nowElapsed = SystemClock.elapsedRealtime();  
  376.     final int oldBatches = oldSet.size();  
  377.     for (int batchNum = 0; batchNum < oldBatches; batchNum++) {  
  378.         Batch batch = oldSet.get(batchNum);  
  379.         final int N = batch.size();  
  380.         for (int i = 0; i < N; i++) {  
  381.             // 重新添加alarm到mAlarmBatches列表中  
  382.             reAddAlarmLocked(batch.get(i), nowElapsed, doValidate);  
  383.         }  
  384.     }  
  385.     if (oldPendingIdleUntil != null && oldPendingIdleUntil != mPendingIdleUntil) {  
  386.         Slog.wtf(TAG, "Rebatching: idle until changed from " + oldPendingIdleUntil  
  387.                 + " to " + mPendingIdleUntil);  
  388.         if (mPendingIdleUntil == null) {  
  389.             // mPendingIdleUntil变化导致需要重新存储空闲时延迟执行的alarm  
  390.             restorePendingWhileIdleAlarmsLocked();  
  391.         }  
  392.     }  
  393.     // 重新设置几个核心alarm  
  394.     rescheduleKernelAlarmsLocked();  
  395.     // 更新下一个alarm的alarmClock  
  396.     updateNextAlarmClockLocked();  
  397. }  
  398.   
  399. // 重新添加alarm到mAlarmBatches列表中  
  400. void reAddAlarmLocked(Alarm a, long nowElapsed, boolean doValidate) {  
  401.     a.when = a.origWhen;  
  402.     long whenElapsed = convertToElapsed(a.when, a.type);  
  403.     final long maxElapsed;  
  404.     // windowLength：alarm执行的时间窗时间  
  405.     if (a.windowLength == AlarmManager.WINDOW_EXACT) {  
  406.         // 精确执行时间  
  407.         maxElapsed = whenElapsed;  
  408.     } else {  
  409.         // 非精确执行时间，即允许在时间窗误差内触发  
  410.         maxElapsed = (a.windowLength > 0)  
  411.                 ? (whenElapsed + a.windowLength)  
  412.                 : maxTriggerTime(nowElapsed, whenElapsed, a.repeatInterval);  
  413.     }  
  414.     a.whenElapsed = whenElapsed;  
  415.     a.maxWhenElapsed = maxElapsed;  
  416.     // 重新添加alarm到各相关列表中  
  417.     setImplLocked(a, true, doValidate);  
  418. }  
  419.   
  420. Random mRandom;  
  421. // 下一个将要执行的alarm的开始执行时间是否可能改变  
  422. private boolean mNextAlarmClockMayChange;  
  423.   
  424. // 把alarm添加各相关列表中  
  425. private void setImplLocked(Alarm a, boolean rebatching, boolean doValidate) {  
  426.     // 判断alarm是否设置了FLAG_IDLE_UNTIL  
  427.     if ((a.flags&AlarmManager.FLAG_IDLE_UNTIL) != 0) {  
  428.         // 这是一个特殊的alarm，它将系统进入空闲模式，直到该alarm执行完毕。  
  429.         // 虽然调用者A设置了alarm的开始执行时间，但是如果存在在更早的时间请求退出空闲状态的alarm，则需要让A的alarm提前执行  
  430.         if (mNextWakeFromIdle != null && a.whenElapsed > mNextWakeFromIdle.whenElapsed) {  
  431.             // 令alarm的开始执行时间等于请求退出空闲状态的alarm的开始执行时间  
  432.             a.when = a.whenElapsed = a.maxWhenElapsed = mNextWakeFromIdle.whenElapsed;  
  433.         }  
  434.         // 由于上面令alarm的开始执行时间等于请求退出空闲状态的alarm的开始执行时间，所以alarm的开始执行时间还要提前。  
  435.         // 这里增加模糊时间，让alarm比实际开始执行时间早一点执行。  
  436.         final long nowElapsed = SystemClock.elapsedRealtime();  
  437.         // 计算模糊时间  
  438.         final int fuzz = fuzzForDuration(a.whenElapsed-nowElapsed);  
  439.         if (fuzz > 0) {  
  440.             if (mRandom == null) {  
  441.                 mRandom = new Random();  
  442.             }  
  443.             // 根据模糊时间取一个随机数  
  444.             final int delta = mRandom.nextInt(fuzz);  
  445.             // alarm的开始执行时间减去随机数，让alarm早执行一点  
  446.             a.whenElapsed -= delta;  
  447.             if (false) {  
  448.                 Slog.d(TAG, "Alarm when: " + a.whenElapsed);  
  449.                 Slog.d(TAG, "Delta until alarm: " + (a.whenElapsed-nowElapsed));  
  450.                 Slog.d(TAG, "Applied fuzz: " + fuzz);  
  451.                 Slog.d(TAG, "Final delta: " + delta);  
  452.                 Slog.d(TAG, "Final when: " + a.whenElapsed);  
  453.             }  
  454.             a.when = a.maxWhenElapsed = a.whenElapsed;  
  455.         }  
  456.   
  457.     } else if (mPendingIdleUntil != null) {  
  458.         // 调用该方法时，该alarm可能设置了FLAG_ALLOW_WHILE_IDLE，所以只要mPendingIdleUntil不为null  
  459.         // 且没有明确表示要在空闲状态时运行，则就需要将它添加到mPendingWhileIdleAlarms延迟开始执行列表中  
  460.         if ((a.flags&(AlarmManager.FLAG_ALLOW_WHILE_IDLE  
  461.                 | AlarmManager.FLAG_ALLOW_WHILE_IDLE_UNRESTRICTED  
  462.                 | AlarmManager.FLAG_WAKE_FROM_IDLE))  
  463.                 == 0) {  
  464.             mPendingWhileIdleAlarms.add(a);  
  465.             return;  
  466.         }  
  467.     }  
  468.   
  469.     // 获取批处理对象在mAlarmBatches列表中的索引值  
  470.     int whichBatch = ((a.flags&AlarmManager.FLAG_STANDALONE) != 0)  
  471.             ? -1 : attemptCoalesceLocked(a.whenElapsed, a.maxWhenElapsed);  
  472.     if (whichBatch < 0) {  
  473.         // 如果alarm是独立的，则它不能和其他alarm一起进行批处理操作  
  474.         Batch batch = new Batch(a);  
  475.         // 把批处理对象添加到mAlarmBatches列表中  
  476.         addBatchLocked(mAlarmBatches, batch);  
  477.     } else {  
  478.         Batch batch = mAlarmBatches.get(whichBatch);  
  479.         // 把alarm添加到批处理对象中，如果批处理对象的start时间变大则返回true  
  480.         if (batch.add(a)) {  
  481.             // 批处理的开始时间提前导致批处理的alarm顺序可能被打破。所以要把批处理对象移动到正确的位置  
  482.             mAlarmBatches.remove(whichBatch);  
  483.             // 重新把批处理对象添加到mAlarmBatches列表中的正确位置上  
  484.             addBatchLocked(mAlarmBatches, batch);  
  485.         }  
  486.     }  
  487.   
  488.     if (a.alarmClock != null) {  
  489.         mNextAlarmClockMayChange = true;  
  490.     }  
  491.   
  492.     boolean needRebatch = false;  
  493.   
  494.     // 判断alarm是否设置了FLAG_IDLE_UNTIL  
  495.     if ((a.flags&AlarmManager.FLAG_IDLE_UNTIL) != 0) {  
  496.         // 由于该alarm设置了FLAG_ALLOW_WHILE_IDLE,所以把该alarm赋值给mPendingIdleUntil变量  
  497.         mPendingIdleUntil = a;  
  498.         // 更新可以开始执行flag为ALLOW_WHILE_IDLE的alarm的最小时间间隔  
  499.         mConstants.updateAllowWhileIdleMinTimeLocked();  
  500.         // 给mPendingIdleUntil变量赋值可能导致alarm的执行时间延后，故需要重新进行批处理  
  501.         needRebatch = true;  
  502.     // 判断alarm是否设置了FLAG_WAKE_FROM_IDLE  
  503.     } else if ((a.flags&AlarmManager.FLAG_WAKE_FROM_IDLE) != 0) {  
  504.         // 如果下一个请求退出空闲状态的alarm为null或者下一个请求退出空闲状态的alarm的开始执行时间大于a的开始执行时间  
  505.         if (mNextWakeFromIdle == null || mNextWakeFromIdle.whenElapsed > a.whenElapsed) {  
  506.             // 则把a赋值给mNextWakeFromIdle  
  507.             mNextWakeFromIdle = a;  
  508.             // 如果延迟到空闲时开始执行的alarm不为null，因为两者开始执行时间可能会有冲突，所以需要重新进行批处理  
  509.             if (mPendingIdleUntil != null) {  
  510.                 needRebatch = true;  
  511.             }  
  512.         }  
  513.     }  
  514.   
  515.     if (!rebatching) {  
  516.         if (needRebatch) {  
  517.             // 由于相关alarm变量改变，所以需要对所有的alarm进行重新批处理操作  
  518.             rebatchAllAlarmsLocked(false);  
  519.         }  
  520.   
  521.         // 重新设置几个核心alarm  
  522.         rescheduleKernelAlarmsLocked();  
  523.         // 更新下一个alarm的alarmClock  
  524.         updateNextAlarmClockLocked();  
  525.     }  
  526. }  
  527.   
  528. // 计算模糊时间  
  529. static int fuzzForDuration(long duration) {  
  530.     if (duration < 15*60*1000) {  
  531.         // 如果距离开始执行alarm的时间duration小于15分钟，则fuzz就等于duration  
  532.         return (int)duration;  
  533.     } else if (duration < 90*60*1000) {  
  534.         // 如果duration小于1.5小时，则令fuzz等于15分钟  
  535.         return 15*60*1000;  
  536.     } else {  
  537.         // 否则，令fuzz等于30分钟  
  538.         return 30*60*1000;  
  539.     }  
  540. }  
  541.   
  542. // 返回匹配的批处理对象的索引，如果不存在则返回-1  
  543. int attemptCoalesceLocked(long whenElapsed, long maxWhen) {  
  544.     final int N = mAlarmBatches.size();  
  545.     for (int i = 0; i < N; i++) {  
  546.         Batch b = mAlarmBatches.get(i);  
  547.         if ((b.flags&AlarmManager.FLAG_STANDALONE) == 0 && b.canHold(whenElapsed, maxWhen)) {  
  548.             return i;  
  549.         }  
  550.     }  
  551.     return -1;  
  552. }  
  553.   
  554. // 根据批处理对象的start时间从小到大排序  
  555. static final BatchTimeOrder sBatchOrder = new BatchTimeOrder();  
  556.   
  557. // 如果批处理对象添加到列表的第一位则返回true  
  558. static boolean addBatchLocked(ArrayList list, Batch newBatch) {  
  559.     // 根据sBatchOrder在list中用二分法查找newBatch元素，查到返回索引值，否则返回-1  
  560.     int index = Collections.binarySearch(list, newBatch, sBatchOrder);  
  561.     if (index < 0) {  
  562.         index = 0 - index - 1;  
  563.     }  
  564.     list.add(index, newBatch);  
  565.     return (index == 0);  
  566. }  
  567.   
  568. static class BatchTimeOrder implements Comparator {  
  569.     public int compare(Batch b1, Batch b2) {  
  570.         long when1 = b1.start;  
  571.         long when2 = b2.start;  
  572.         if (when1 - when2 > 0) {  
  573.             return 1;  
  574.         }  
  575.         if (when1 - when2 < 0) {  
  576.             return -1;  
  577.         }  
  578.         return 0;  
  579.     }  
  580. }  
  581.   
  582. // 延迟执行的非wakeup的alarm列表  
  583. ArrayList mPendingNonWakeupAlarms = new ArrayList<>();  
  584. // 下一次非wakeup类型的alarm传递的时间  
  585. long mNextNonWakeupDeliveryTime;  
  586. // 重新设置几个核心alarm（几个单独命名的特定alarm）  
  587. void rescheduleKernelAlarmsLocked() {  
  588.     // Schedule the next upcoming wakeup alarm.  If there is a deliverable batch  
  589.     // prior to that which contains no wakeups, we schedule that as well.  
  590.     // 调度下一个即将执行的wakeup alarm。如果之前有一个非wakeup的批处理对象，我们也调度它。  
  591.     long nextNonWakeup = 0;  
  592.     if (mAlarmBatches.size() > 0) {  
  593.         // 获取第一个包含wakeup的批处理对象  
  594.         final Batch firstWakeup = findFirstWakeupBatchLocked();  
  595.         // 获取mAlarmBatches列表中的第一个批处理对象  
  596.         final Batch firstBatch = mAlarmBatches.get(0);  
  597.         // 获取第一个包含Rtc wakeup的批处理对象  
  598.         final Batch firstRtcWakeup = findFirstRtcWakeupBatchLocked();  
  599.         if (firstWakeup != null && mNextWakeup != firstWakeup.start) {  
  600.             // 更新mNextWakeup  
  601.             mNextWakeup = firstWakeup.start;  
  602.             // 把alarm设置到驱动中  
  603.             setLocked(ELAPSED_REALTIME_WAKEUP, firstWakeup.start);  
  604.         }  
  605.         if (firstRtcWakeup != null && mNextRtcWakeup != firstRtcWakeup.start) {  
  606.             // 更新mNextRtcWakeup  
  607.             mNextRtcWakeup = firstRtcWakeup.start;  
  608.             // 根据alarm.whenElapsed获取alarm.when  
  609.             long when = firstRtcWakeup.getWhenByElapsedTime(mNextRtcWakeup);  
  610.             if (when != 0) {  
  611.                 setLocked(RTC_POWEROFF_WAKEUP, when);  
  612.             }  
  613.         }  
  614.         if (firstBatch != firstWakeup) {  
  615.             // 把mAlarmBatches列表中的第一个批处理对象的start赋值给nextNonWakeup  
  616.             nextNonWakeup = firstBatch.start;  
  617.         }  
  618.     }  
  619.     if (mPendingNonWakeupAlarms.size() > 0) {  
  620.         if (nextNonWakeup == 0 || mNextNonWakeupDeliveryTime < nextNonWakeup) {  
  621.             // 更新nextNonWakeup  
  622.             nextNonWakeup = mNextNonWakeupDeliveryTime;  
  623.         }  
  624.     }  
  625.     if (nextNonWakeup != 0 && mNextNonWakeup != nextNonWakeup) {  
  626.         // 更新mNextNonWakeup  
  627.         mNextNonWakeup = nextNonWakeup;  
  628.         setLocked(ELAPSED_REALTIME, nextNonWakeup);  
  629.     }  
  630. }  
  631.   
  632. // 查找第一个包含wakeup的批处理对象  
  633. private Batch findFirstWakeupBatchLocked() {  
  634.     final int N = mAlarmBatches.size();  
  635.     for (int i = 0; i < N; i++) {  
  636.         Batch b = mAlarmBatches.get(i);  
  637.         if (b.hasWakeups()) {  
  638.             return b;  
  639.         }  
  640.     }  
  641.     return null;  
  642. }  
  643.   
  644. // 查找第一个包含Rtc wakeup的批处理对象  
  645. private Batch findFirstRtcWakeupBatchLocked() {  
  646.     final int N = mAlarmBatches.size();  
  647.     for (int i = 0; i < N; i++) {  
  648.         Batch b = mAlarmBatches.get(i);  
  649.         long intervalTime  = b.start - SystemClock.elapsedRealtime();  
  650.         if (b.isRtcPowerOffWakeup()) {  
  651.             return b;  
  652.         }  
  653.     }  
  654.     return null;  
  655. }  
  656.   
  657. // 把alarm设置到驱动中  
  658. private void setLocked(int type, long when) {  
  659.     if (mNativeData != 0) {  
  660.         // The kernel never triggers alarms with negative wakeup times  
  661.         // so we ensure they are positive.  
  662.         // 秒、纳秒  
  663.         long alarmSeconds, alarmNanoseconds;  
  664.         if (when < 0) {  
  665.             alarmSeconds = 0;  
  666.             alarmNanoseconds = 0;  
  667.         } else {  
  668.             alarmSeconds = when / 1000;  
  669.             alarmNanoseconds = (when % 1000) * 1000 * 1000;  
  670.         }  
  671.           
  672.         // 把alarm设置到驱动中  
  673.         set(mNativeData, type, alarmSeconds, alarmNanoseconds);  
  674.     } else {  
  675.         Message msg = Message.obtain();  
  676.         msg.what = ALARM_EVENT;  
  677.           
  678.         mHandler.removeMessages(ALARM_EVENT);  
  679.         mHandler.sendMessageAtTime(msg, when);  
  680.     }  
  681. }  
  682.   
  683. // 设置alarm只跟类型、触发时间相关，跟alarm的其他参数无关  
  684. private native void set(long nativeData, int type, long seconds, long nanoseconds);  
  685.   
  686. private final SparseArray mTmpSparseAlarmClockArray =  
  687.         new SparseArray<>();  
  688. private final SparseArray mNextAlarmClockForUser =  
  689.         new SparseArray<>();  
  690.   
  691. /** 
  692.  * 更新下一个alarm的alarmClock 
  693.  */  
  694. private void updateNextAlarmClockLocked() {  
  695.     // 如果下一个将要执行的alarm的开始执行时间没有改变则直接返回  
  696.     if (!mNextAlarmClockMayChange) {  
  697.         return;  
  698.     }  
  699.     mNextAlarmClockMayChange = false;  
  700.   
  701.     SparseArray nextForUser = mTmpSparseAlarmClockArray;  
  702.     nextForUser.clear();  
  703.   
  704.     final int N = mAlarmBatches.size();  
  705.     for (int i = 0; i < N; i++) {  
  706.         ArrayList alarms = mAlarmBatches.get(i).alarms;  
  707.         final int M = alarms.size();  
  708.   
  709.         for (int j = 0; j < M; j++) {  
  710.             Alarm a = alarms.get(j);  
  711.             if (a.alarmClock != null) {  
  712.                 final int userId = UserHandle.getUserId(a.uid);  
  713.   
  714.                 if (DEBUG_ALARM_CLOCK) {  
  715.                     Log.v(TAG, "Found AlarmClockInfo at " +  
  716.                             formatNextAlarm(getContext(), a.alarmClock, userId) +  
  717.                             " for user " + userId);  
  718.                 }  
  719.   
  720.                 // Alarms and batches are sorted by time, no need to compare times here.  
  721.                 if (nextForUser.get(userId) == null) {  
  722.                     // 把userId和alarmClock以键值对的形式添加到nextForUser中  
  723.                     nextForUser.put(userId, a.alarmClock);  
  724.                 }  
  725.             }  
  726.         }  
  727.     }  
  728.   
  729.     // Update mNextAlarmForUser with new values.  
  730.     final int NN = nextForUser.size();  
  731.     for (int i = 0; i < NN; i++) {  
  732.         AlarmManager.AlarmClockInfo newAlarm = nextForUser.valueAt(i);  
  733.         int userId = nextForUser.keyAt(i);  
  734.         AlarmManager.AlarmClockInfo currentAlarm = mNextAlarmClockForUser.get(userId);  
  735.         if (!newAlarm.equals(currentAlarm)) {  
  736.             // 更新mNextAlarmClockForUser  
  737.             updateNextAlarmInfoForUserLocked(userId, newAlarm);  
  738.         }  
  739.     }  
  740.   
  741.     // Remove users without any alarm clocks scheduled.  
  742.     final int NNN = mNextAlarmClockForUser.size();  
  743.     for (int i = NNN - 1; i >= 0; i--) {  
  744.         int userId = mNextAlarmClockForUser.keyAt(i);  
  745.         if (nextForUser.get(userId) == null) {  
  746.             // 更新mNextAlarmClockForUser  
  747.             updateNextAlarmInfoForUserLocked(userId, null);  
  748.         }  
  749.     }  
  750. }  
  751.   
  752. private final SparseBooleanArray mPendingSendNextAlarmClockChangedForUser =  
  753.         new SparseBooleanArray();  
  754.   
  755. // 更新mNextAlarmClockForUser  
  756. private void updateNextAlarmInfoForUserLocked(int userId,  
  757.         AlarmManager.AlarmClockInfo alarmClock) {  
  758.     if (alarmClock != null) {  
  759.         if (DEBUG_ALARM_CLOCK) {  
  760.             Log.v(TAG, "Next AlarmClockInfoForUser(" + userId + "): " +  
  761.                     formatNextAlarm(getContext(), alarmClock, userId));  
  762.         }  
  763.         mNextAlarmClockForUser.put(userId, alarmClock);  
  764.     } else {  
  765.         if (DEBUG_ALARM_CLOCK) {  
  766.             Log.v(TAG, "Next AlarmClockInfoForUser(" + userId + "): None");  
  767.         }  
  768.         mNextAlarmClockForUser.remove(userId);  
  769.     }  
  770.   
  771.     mPendingSendNextAlarmClockChangedForUser.put(userId, true);  
  772.     mHandler.removeMessages(AlarmHandler.SEND_NEXT_ALARM_CLOCK_CHANGED);  
  773.     mHandler.sendEmptyMessage(AlarmHandler.SEND_NEXT_ALARM_CLOCK_CHANGED);  
  774. }  
  775.   
  776. // 重新存储延迟到空闲时执行的alarm  
  777. void restorePendingWhileIdleAlarmsLocked() {  
  778.     if (mPendingWhileIdleAlarms.size() > 0) {  
  779.         ArrayList alarms = mPendingWhileIdleAlarms;  
  780.         mPendingWhileIdleAlarms = new ArrayList<>();  
  781.         final long nowElapsed = SystemClock.elapsedRealtime();  
  782.         for (int i=alarms.size() - 1; i >= 0; i--) {  
  783.             Alarm a = alarms.get(i);  
  784.             // 重新添加alarm到mAlarmBatches列表中  
  785.             reAddAlarmLocked(a, nowElapsed, false);  
  786.         }  
  787.     }  
  788.   
  789.     // 更新可以开始执行flag为ALLOW_WHILE_IDLE的alarm的最小时间间隔  
  790.     mConstants.updateAllowWhileIdleMinTimeLocked();  
  791.   
  792.     // Reschedule everything.  
  793.     // 重新设置几个核心alarm  
  794.     rescheduleKernelAlarmsLocked();  
  795.     // 更新下一个alarm的alarmClock  
  796.     updateNextAlarmClockLocked();  
  797.   
  798.     // And send a TIME_TICK right now, since it is important to get the UI updated.  
  799.     try {  
  800.         // 执行和PendingIntent关联的操作  
  801.         mTimeTickSender.send();  
  802.     } catch (PendingIntent.CanceledException e) {  
  803.     }  
  804. }  
  805.   
  806. // 监听息屏/亮屏的广播接收者  
  807. class InteractiveStateReceiver extends BroadcastReceiver {  
  808.     public InteractiveStateReceiver() {  
  809.         IntentFilter filter = new IntentFilter();  
  810.         filter.addAction(Intent.ACTION_SCREEN_OFF);  
  811.         filter.addAction(Intent.ACTION_SCREEN_ON);  
  812.         filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);  
  813.         getContext().registerReceiver(this, filter);  
  814.     }  
  815.   
  816.     @Override  
  817.     public void onReceive(Context context, Intent intent) {  
  818.         synchronized (mLock) {  
  819.             // 息屏/亮屏状态发生变化  
  820.             interactiveStateChangedLocked(Intent.ACTION_SCREEN_ON.equals(intent.getAction()));  
  821.         }  
  822.     }  
  823. }  
  824.   
  825. // 记录上次亮屏状态，亮屏为true  
  826. boolean mInteractive = true;  
  827. // 延迟执行的非wakeup的alarm的开始延迟的时间点  
  828. long mStartCurrentDelayTime;  
  829. // 延迟执行的非wakeup的alarm的总延迟时间  
  830. long mTotalDelayTime = 0;  
  831. // 延迟执行的非wakeup的alarm的最大一次延迟时间  
  832. long mMaxDelayTime = 0;  
  833. // 最长的息屏时间，后面打log用  
  834. long mNonInteractiveTime;  
  835. // 开始息屏的时间  
  836. long mNonInteractiveStartTime;  
  837.   
  838. // 息屏/亮屏状态发生变化  
  839. void interactiveStateChangedLocked(boolean interactive) {  
  840.     if (mInteractive != interactive) {  
  841.         mInteractive = interactive;  
  842.         final long nowELAPSED = SystemClock.elapsedRealtime();  
  843.         // 如果当前是亮屏状态  
  844.         if (interactive) {  
  845.             // 判断延迟执行的非wakeup的alarm列表是否大于0  
  846.             if (mPendingNonWakeupAlarms.size() > 0) {  
  847.                 // 计算本次延迟时间  
  848.                 final long thisDelayTime = nowELAPSED - mStartCurrentDelayTime;  
  849.                 // 累加到总延迟时间中  
  850.                 mTotalDelayTime += thisDelayTime;  
  851.                 // 更新最大一次延迟时间  
  852.                 if (mMaxDelayTime < thisDelayTime) {  
  853.                     mMaxDelayTime = thisDelayTime;  
  854.                 }  
  855.                 // 执行mPendingNonWakeupAlarms列表中的alarm  
  856.                 deliverAlarmsLocked(mPendingNonWakeupAlarms, nowELAPSED);  
  857.                 // 清空列表  
  858.                 mPendingNonWakeupAlarms.clear();  
  859.             }  
  860.             // 保存最长的息屏时间  
  861.             if (mNonInteractiveStartTime > 0) {  
  862.                 long dur = nowELAPSED - mNonInteractiveStartTime;  
  863.                 if (dur > mNonInteractiveTime) {  
  864.                     mNonInteractiveTime = dur;  
  865.                 }  
  866.             }  
  867.         } else {  
  868.             // 如果当前是息屏状态则开始息屏的时间  
  869.             mNonInteractiveStartTime = nowELAPSED;  
  870.         }  
  871.     }  
  872. }  
  873.   
  874. // 上次传递alarm的时间  
  875. long mLastAlarmDeliveryTime;  
  876. static final boolean RECORD_ALARMS_IN_HISTORY = true;  
  877. static final Intent mBackgroundIntent = new Intent()  
  878.         .addFlags(Intent.FLAG_FROM_BACKGROUND);  
  879. int mBroadcastRefCount = 0;  
  880. // 执行中的alarm的信息列表  
  881. ArrayList mInFlight = new ArrayList<>();  
  882. // 触发执行的alarm所在应用程序的uid列表  
  883. private final ArrayList mTriggeredUids = new ArrayList();  
  884. final ResultReceiver mResultReceiver = new ResultReceiver();  
  885.   
  886. // 执行triggerList中的alarm  
  887. void deliverAlarmsLocked(ArrayList triggerList, long nowELAPSED) {  
  888.     mLastAlarmDeliveryTime = nowELAPSED;  
  889.     for (int i=0; i
  890.         Alarm alarm = triggerList.get(i);  
  891.         final boolean allowWhileIdle = (alarm.flags&AlarmManager.FLAG_ALLOW_WHILE_IDLE) != 0;  
  892.         try {  
  893.             if (localLOGV) {  
  894.                 Slog.v(TAG, "sending alarm " + alarm);  
  895.             }  
  896.             if (RECORD_ALARMS_IN_HISTORY) {  
  897.                 if (alarm.workSource != null && alarm.workSource.size() > 0) {  
  898.                     for (int wi=0; wi
  899.                         // 通过Binder对象调用AMS的noteAlarmStart方法  
  900.                         ActivityManagerNative.noteAlarmStart(  
  901.                                 alarm.operation, alarm.workSource.get(wi), alarm.tag);  
  902.                     }  
  903.                 } else {  
  904.                     ActivityManagerNative.noteAlarmStart(  
  905.                             alarm.operation, -1, alarm.tag);  
  906.                 }  
  907.             }  
  908.             // 执行和PendingIntent关联的操作  
  909.             alarm.operation.send(getContext(), 0,  
  910.                     mBackgroundIntent.putExtra(  
  911.                             Intent.EXTRA_ALARM_COUNT, alarm.count),  
  912.                     mResultReceiver, mHandler, null, allowWhileIdle ? mIdleOptions : null);  
  913.   
  914.             // we have an active broadcast so stay awake.  
  915.             // 获取wakelock  
  916.             if (mBroadcastRefCount == 0 || !mWakeLock.isHeld()) {  
  917.                 setWakelockWorkSource(alarm.operation, alarm.workSource,  
  918.                         alarm.type, alarm.tag, true);  
  919.                 mWakeLock.acquire();  
  920.             }  
  921.             final InFlight inflight = new InFlight(AlarmManagerService.this,  
  922.                                                    alarm.operation,  
  923.                                                    alarm.workSource,  
  924.                                                    alarm.type, alarm.tag,  
  925.                                                    nowELAPSED, alarm.uid);  
  926.             mInFlight.add(inflight);  
  927.             mBroadcastRefCount++;  
  928.             mTriggeredUids.add(new Integer(alarm.uid));  
  929.             // 释放wakelock  
  930.             if (checkReleaseWakeLock()) {  
  931.                 if (mWakeLock.isHeld()) {  
  932.                     mWakeLock.release();  
  933.                     if (localLOGV) Slog.v(TAG, "AM WakeLock Released Internally deliverAlarms");  
  934.                 }  
  935.             }  
  936.   
  937.             if (allowWhileIdle) {  
  938.                 // Record the last time this uid handled an ALLOW_WHILE_IDLE alarm.  
  939.                 mLastAllowWhileIdleDispatch.put(alarm.uid, nowELAPSED);  
  940.             }  
  941.   
  942.             final BroadcastStats bs = inflight.mBroadcastStats;  
  943.             bs.count++;  
  944.             if (bs.nesting == 0) {  
  945.                 bs.nesting = 1;  
  946.                 bs.startTime = nowELAPSED;  
  947.             } else {  
  948.                 bs.nesting++;  
  949.             }  
  950.             final FilterStats fs = inflight.mFilterStats;  
  951.             fs.count++;  
  952.             if (fs.nesting == 0) {  
  953.                 fs.nesting = 1;  
  954.                 fs.startTime = nowELAPSED;  
  955.             } else {  
  956.                 fs.nesting++;  
  957.             }  
  958.             // 判断是否为WAKEUP类型的alarm  
  959.             if (alarm.type == ELAPSED_REALTIME_WAKEUP  
  960.                     || alarm.type == RTC_WAKEUP  
  961.                     || alarm.type == RTC_POWEROFF_WAKEUP) {  
  962.                 bs.numWakeup++;  
  963.                 fs.numWakeup++;  
  964.                 if (alarm.workSource != null && alarm.workSource.size() > 0) {  
  965.                     for (int wi=0; wi
  966.                         // 通过Binder对象调用AMS中的noteWakeupAlarm方法  
  967.                         ActivityManagerNative.noteWakeupAlarm(  
  968.                                 alarm.operation, alarm.workSource.get(wi),  
  969.                                 alarm.workSource.getName(wi), alarm.tag);  
  970.                     }  
  971.                 } else {  
  972.                     ActivityManagerNative.noteWakeupAlarm(  
  973.                             alarm.operation, -1, null, alarm.tag);  
  974.                 }  
  975.             }  
  976.         } catch (PendingIntent.CanceledException e) {  
  977.             if (alarm.repeatInterval > 0) {  
  978.                 // This IntentSender is no longer valid, but this  
  979.                 // is a repeating alarm, so toss the hoser.  
  980.                 removeImpl(alarm.operation);  
  981.             }  
  982.         } catch (RuntimeException e) {  
  983.             Slog.w(TAG, "Failure sending alarm.", e);  
  984.         }  
  985.     }  
  986. }  
  987.   
  988. // 等待执行alarm所在应用程序的uid列表  
  989. private final ArrayList mBlockedUids = new ArrayList();  
  990.   
  991. // 判断是否可以释放wakelock  
  992. boolean checkReleaseWakeLock() {  
  993.     if (mTriggeredUids.size() == 0 || mBlockedUids.size() == 0)  
  994.         return false;  
  995.   
  996.     int uid;  
  997.     for (int i = 0; i <  mTriggeredUids.size(); i++) {  
  998.         uid = mTriggeredUids.get(i);  
  999.         // 只要等待执行列表中有未处理的alarm就返回false  
  1000.         if (!mBlockedUids.contains(uid)) {  
  1001.             return false;  
  1002.         }  
  1003.     }  
  1004.     return true;  
  1005. }  
  1006.   
  1007. // 监听应用卸载和SD卡不可用的广播，判断是否移除alarm  
  1008. class UninstallReceiver extends BroadcastReceiver {  
  1009.     public UninstallReceiver() {  
  1010.         IntentFilter filter = new IntentFilter();  
  1011.         filter.addAction(Intent.ACTION_PACKAGE_REMOVED);  
  1012.         filter.addAction(Intent.ACTION_PACKAGE_RESTARTED);  
  1013.         filter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART);  
  1014.         filter.addDataScheme("package");  
  1015.         getContext().registerReceiverAsUser(this, UserHandle.ALL, filter, null, null);  
  1016.         IntentFilter sdFilter = new IntentFilter();  
  1017.         sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);  
  1018.         sdFilter.addAction(Intent.ACTION_USER_STOPPED);  
  1019.         sdFilter.addAction(Intent.ACTION_UID_REMOVED);  
  1020.         getContext().registerReceiverAsUser(this, UserHandle.ALL, sdFilter, null, null);  
  1021.     }  
  1022.       
  1023.     @Override  
  1024.     public void onReceive(Context context, Intent intent) {  
  1025.         synchronized (mLock) {  
  1026.             String action = intent.getAction();  
  1027.             String pkgList[] = null;  
  1028.             int userHandle = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, -1);  
  1029.   
  1030.             if (Intent.ACTION_QUERY_PACKAGE_RESTART.equals(action)) {  
  1031.                 pkgList = intent.getStringArrayExtra(Intent.EXTRA_PACKAGES);  
  1032.                 for (String packageName : pkgList) {  
  1033.                     if (lookForPackageLocked(packageName, userHandle)) {  
  1034.                         setResultCode(Activity.RESULT_OK);  
  1035.                         return;  
  1036.                     }  
  1037.                 }  
  1038.                 return;  
  1039.             } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(action)) {  
  1040.                 pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);  
  1041.             } else if (Intent.ACTION_USER_STOPPED.equals(action)) {  
  1042.                 if (userHandle >= 0) {  
  1043.                     removeUserLocked(userHandle);  
  1044.                 }  
  1045.             } else if (Intent.ACTION_UID_REMOVED.equals(action)) {  
  1046.                 int uid = intent.getIntExtra(Intent.EXTRA_UID, -1);  
  1047.                 if (uid >= 0) {  
  1048.                     mLastAllowWhileIdleDispatch.delete(uid);  
  1049.                 }  
  1050.             } else {  
  1051.                 if (Intent.ACTION_PACKAGE_REMOVED.equals(action)  
  1052.                         && intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) {  
  1053.                     // This package is being updated; don't kill its alarms.  
  1054.                     return;  
  1055.                 }  
  1056.                 Uri data = intent.getData();  
  1057.                 if (data != null) {  
  1058.                     String pkg = data.getSchemeSpecificPart();  
  1059.                     if (pkg != null) {  
  1060.                         pkgList = new String[]{pkg};  
  1061.                     }  
  1062.                 }  
  1063.             }  
  1064.             if (pkgList != null && (pkgList.length > 0)) {  
  1065.                 for (String pkg : pkgList) {  
  1066.                     removeLocked(pkg, userHandle);  
  1067.                     removePackagePrio(pkg, userHandle);  
  1068.                     for (int i=mBroadcastStats.size()-1; i>=0; i--) {  
  1069.                         ArrayMap uidStats = mBroadcastStats.valueAt(i);  
  1070.                         BroadcastStats stat = uidStats.get(pkg);  
  1071.                         if (stat != null && UserHandle.getUserId(stat.mUid) == userHandle &&  
  1072.                                 stat.mPackageName.equals(pkg)) {  
  1073.                             if (uidStats.remove(pkg) != null) {  
  1074.                                 if (uidStats.size() <= 0) {  
  1075.                                     mBroadcastStats.removeAt(i);  
  1076.                                 }  
  1077.                             }  
  1078.                         }  
  1079.                     }  
  1080.                 }  
  1081.             }  
  1082.         }  
  1083.     }  
  1084. }  
  1085.   
  1086. static final int TIME_CHANGED_MASK = 1 << 16;  
  1087. // 上一次时间变化的时钟时间  
  1088. long mLastTimeChangeClockTime;  
  1089. // 上一次时间变化的开机时间  
  1090. long mLastTimeChangeRealtime;  
  1091. static final boolean WAKEUP_STATS = false;  
  1092.   
  1093. private class AlarmThread extends Thread  
  1094. {  
  1095.     public AlarmThread()  
  1096.     {  
  1097.         super("AlarmManager");  
  1098.     }  
  1099.       
  1100.     public void run()  
  1101.     {  
  1102.         ArrayList triggerList = new ArrayList();  
  1103.   
  1104.         // 死循环  
  1105.         while (true)  
  1106.         {  
  1107.             // 等待驱动触发alarm的执行  
  1108.             int result = waitForAlarm(mNativeData);  
  1109.   
  1110.             triggerList.clear();  
  1111.   
  1112.             final long nowRTC = System.currentTimeMillis();  
  1113.             final long nowELAPSED = SystemClock.elapsedRealtime();  
  1114.   
  1115.             if ((result & TIME_CHANGED_MASK) != 0) {  
  1116.                 // 由于内核内部小的调整可能导致内核给我们发送虚假的时间更改通知，所以这里要过滤出来。  
  1117.                 final long lastTimeChangeClockTime;  
  1118.                 final long expectedClockTime;  
  1119.                 synchronized (mLock) {  
  1120.                     lastTimeChangeClockTime = mLastTimeChangeClockTime;  
  1121.                     expectedClockTime = lastTimeChangeClockTime  
  1122.                             + (nowELAPSED - mLastTimeChangeRealtime);  
  1123.                 }  
  1124.                 if (lastTimeChangeClockTime == 0 || nowRTC < (expectedClockTime-500)  
  1125.                         || nowRTC > (expectedClockTime+500)) {  
  1126.                     // The change is by at least +/- 500 ms (or this is the first change),  
  1127.                     // let's do it!  
  1128.                     if (DEBUG_BATCH) {  
  1129.                         Slog.v(TAG, "Time changed notification from kernel; rebatching");  
  1130.                     }  
  1131.                     // 由于时间变化，所以要重新批处理所有的alarm  
  1132.                     removeImpl(mTimeTickSender);  
  1133.                     rebatchAllAlarms();  
  1134.                     mClockReceiver.scheduleTimeTickEvent();  
  1135.                     synchronized (mLock) {  
  1136.                         mNumTimeChanged++;  
  1137.                         mLastTimeChangeClockTime = nowRTC;  
  1138.                         mLastTimeChangeRealtime = nowELAPSED;  
  1139.                     }  
  1140.                     // 发送时间变化的广播  
  1141.                     Intent intent = new Intent(Intent.ACTION_TIME_CHANGED);  
  1142.                     intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING  
  1143.                             | Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);  
  1144.                     getContext().sendBroadcastAsUser(intent, UserHandle.ALL);  
  1145.   
  1146.                     // The world has changed on us, so we need to re-evaluate alarms  
  1147.                     // regardless of whether the kernel has told us one went off.  
  1148.                     result |= IS_WAKEUP_MASK;  
  1149.                 }  
  1150.             }  
  1151.   
  1152.             if (result != TIME_CHANGED_MASK) {  
  1153.                 // If this was anything besides just a time change, then figure what if  
  1154.                 // anything to do about alarms.  
  1155.                 synchronized (mLock) {  
  1156.                     if (localLOGV) Slog.v(  
  1157.                         TAG, "Checking for alarms... rtc=" + nowRTC  
  1158.                         + ", elapsed=" + nowELAPSED);  
  1159.   
  1160.                     // 触发开始执行alarm，如果有wakeup类型的alarm则返回true  
  1161.                     boolean hasWakeup = triggerAlarmsLocked(triggerList, nowELAPSED, nowRTC);  
  1162.                     if (!hasWakeup && checkAllowNonWakeupDelayLocked(nowELAPSED)) {  
  1163.                         // 如果是非wakeup类型的alarm且处于息屏状态，可以延迟执行alarm  
  1164.                           
  1165.                         if (mPendingNonWakeupAlarms.size() == 0) {  
  1166.                             // 记录延迟执行的非wakeup的alarm的开始延迟的时间点  
  1167.                             mStartCurrentDelayTime = nowELAPSED;  
  1168.                             // 计算下一次非wakeup类型的alarm传递的时间  
  1169.                             mNextNonWakeupDeliveryTime = nowELAPSED  
  1170.                                     + ((currentNonWakeupFuzzLocked(nowELAPSED)*3)/2);  
  1171.                         }  
  1172.                           
  1173.                         // 把所有的alarm都添加到延迟执行列表中  
  1174.                         mPendingNonWakeupAlarms.addAll(triggerList);  
  1175.                         mNumDelayedAlarms += triggerList.size();  
  1176.                         rescheduleKernelAlarmsLocked();  
  1177.                         updateNextAlarmClockLocked();  
  1178.                     } else {  
  1179.                         // 现在传递alarm的intents，如果有延迟的非wakeup类型的alarm，则需要合并它们到列表中。  
  1180.                         rescheduleKernelAlarmsLocked();  
  1181.                         updateNextAlarmClockLocked();  
  1182.                         if (mPendingNonWakeupAlarms.size() > 0) {  
  1183.                             // 计算延迟执行alarm的传递优先级  
  1184.                             calculateDeliveryPriorities(mPendingNonWakeupAlarms);  
  1185.                             triggerList.addAll(mPendingNonWakeupAlarms);  
  1186.                             Collections.sort(triggerList, mAlarmDispatchComparator);  
  1187.                             final long thisDelayTime = nowELAPSED - mStartCurrentDelayTime;  
  1188.                             mTotalDelayTime += thisDelayTime;  
  1189.                             if (mMaxDelayTime < thisDelayTime) {  
  1190.                                 mMaxDelayTime = thisDelayTime;  
  1191.                             }  
  1192.                             mPendingNonWakeupAlarms.clear();  
  1193.                               
  1194.                         }  
  1195.                         // 执行alarm  
  1196.                         deliverAlarmsLocked(triggerList, nowELAPSED);  
  1197.                     }  
  1198.                 }  
  1199.             }  
  1200.         }  
  1201.     }  
  1202. }  
  1203.   
  1204. void removeImpl(PendingIntent operation) {  
  1205.     if (operation == null) {  
  1206.         return;  
  1207.     }  
  1208.   
  1209.     synchronized (mLock) {  
  1210.         // 移除掉alarm的PendingIntent  
  1211.         removeLocked(operation);  
  1212.     }  
  1213. }  
  1214.   
  1215. /** 
  1216.  * key是uid，value是alarm的上一次执行时间 
  1217.  */  
  1218. final SparseLongArray mLastAllowWhileIdleDispatch = new SparseLongArray();  
  1219. // 可以开始执行flag为ALLOW_WHILE_IDLE的alarm的最小时间间隔  
  1220. long mAllowWhileIdleMinTime;  
  1221.   
  1222. int mCurrentSeq = 0;  
  1223.   
  1224.   
  1225. // 执行alarm  
  1226. boolean triggerAlarmsLocked(ArrayList triggerList, final long nowELAPSED,  
  1227.         final long nowRTC) {  
  1228.     boolean hasWakeup = false;  
  1229.     while (mAlarmBatches.size() > 0) {  
  1230.         // 从列表中取出第一个批处理对象  
  1231.         Batch batch = mAlarmBatches.get(0);  
  1232.         // 如果第一个批处理对象的开始时间大于手机开机时间，说明当前还没有要开始执行的alarm，那么直接结束循环  
  1233.         if (batch.start > nowELAPSED) {  
  1234.             // Everything else is scheduled for the future  
  1235.             break;  
  1236.         }  
  1237.   
  1238.         // 下面要处理这个批处理对象了，所以这里将该批处理对象从列表中移除，以避免其他地方访问该批处理对象  
  1239.         mAlarmBatches.remove(0);  
  1240.   
  1241.         // 获取批处理对象中Alarm的数量  
  1242.         final int N = batch.size();  
  1243.         for (int i = 0; i < N; i++) {  
  1244.             Alarm alarm = batch.get(i);  
  1245.   
  1246.             // 判断alarm是否设置了空闲时允许执行任务的flag  
  1247.             if ((alarm.flags&AlarmManager.FLAG_ALLOW_WHILE_IDLE) != 0) {  
  1248.                 // 如果该alarm设置了ALLOW_WHILE_IDLE，则需要限制应用程序调度这些alarm的频率，这里是增加了执行间隔时间。  
  1249.                   
  1250.                 // 根据uid获取alarm的上一次开始执行时间  
  1251.                 long lastTime = mLastAllowWhileIdleDispatch.get(alarm.uid, 0);  
  1252.                 // alarm下一次最早开始执行的时间：上一次开始执行时间+最小时间间隔  
  1253.                 long minTime = lastTime + mAllowWhileIdleMinTime;  
  1254.                 // 判断当前开机时间是否小于alarm的下一次最早开始执行时间  
  1255.                 if (nowELAPSED < minTime) {  
  1256.                     // 自上次执行完此alarm后还没有足够的时间以再次开始执行。所以要重新调度该alarm的正确开始执行时间。  
  1257.                       
  1258.                     // 把下一次的最早开始执行时间赋值给alarm的whenElapsed变量  
  1259.                     alarm.whenElapsed = minTime;  
  1260.                     // 判断alarm的最迟开始执行时间是否小于alarm的下一次最早开始执行时间  
  1261.                     if (alarm.maxWhenElapsed < minTime) {  
  1262.                         alarm.maxWhenElapsed = minTime;  
  1263.                     }  
  1264.                     // 由于alarm相关的参数发生变化，所以需要重新把该alarm添加到相关列表中  
  1265.                     setImplLocked(alarm, true, false);  
  1266.                     continue;  
  1267.                 }  
  1268.             }  
  1269.   
  1270.             // 设置alarm的执行次数为1  
  1271.             alarm.count = 1;  
  1272.             // 如果alarm不需要重新调度，则就把该alarm添加到triggerList列表中  
  1273.             triggerList.add(alarm);  
  1274.             if ((alarm.flags&AlarmManager.FLAG_WAKE_FROM_IDLE) != 0) {  
  1275.                 EventLogTags.writeDeviceIdleWakeFromIdle(mPendingIdleUntil != null ? 1 : 0,  
  1276.                         alarm.tag);  
  1277.             }  
  1278.             // 判断该alarm是否是延迟到空闲时开始执行的alarm  
  1279.             if (mPendingIdleUntil == alarm) {  
  1280.                 // 因为该alarm就要开始执行，所以要把mPendingIdleUntil置为null，后面会根据各alarm的开始执行时间重新赋值  
  1281.                 mPendingIdleUntil = null;  
  1282.                 // 由于mPendingIdleUntil变量改变，所以需要对所有的alarm进行重新批处理操作  
  1283.                 rebatchAllAlarmsLocked(false);  
  1284.                 // 由于mPendingIdleUntil变量改变，所以需要重新存储空闲时延迟执行的alarm  
  1285.                 restorePendingWhileIdleAlarmsLocked();  
  1286.             }  
  1287.             // 判断该alarm是否是下一个请求退出空闲模式的alarm  
  1288.             if (mNextWakeFromIdle == alarm) {  
  1289.                 // 因为该alarm就要开始执行，所以要把mNextWakeFromIdle置为null，后面会根据各alarm的执行时间重新赋值  
  1290.                 mNextWakeFromIdle = null;  
  1291.                 // 对所有的alarm进行重新批处理操作  
  1292.                 rebatchAllAlarmsLocked(false);  
  1293.             }  
  1294.   
  1295.             if (alarm.repeatInterval > 0) {  
  1296.                 // 计算重复执行的alarm从开始执行到现在的执行次数  
  1297.                 alarm.count += (nowELAPSED - alarm.whenElapsed) / alarm.repeatInterval;  
  1298.   
  1299.                 // 计算alarm的下一次开始执行时间  
  1300.                 final long delta = alarm.count * alarm.repeatInterval;  
  1301.                 final long nextElapsed = alarm.whenElapsed + delta;  
  1302.                 // 根据新得到的alarm参数，设置下次触发的alarm  
  1303.                 setImplLocked(alarm.type, alarm.when + delta, nextElapsed, alarm.windowLength,  
  1304.                         maxTriggerTime(nowELAPSED, nextElapsed, alarm.repeatInterval),  
  1305.                         alarm.repeatInterval, alarm.operation, alarm.flags, true,  
  1306.                         alarm.workSource, alarm.alarmClock, alarm.uid);  
  1307.             }  
  1308.   
  1309.             if (alarm.wakeup) {  
  1310.                 hasWakeup = true;  
  1311.             }  
  1312.   
  1313.             // We removed an alarm clock. Let the caller recompute the next alarm clock.  
  1314.             if (alarm.alarmClock != null) {  
  1315.                 mNextAlarmClockMayChange = true;  
  1316.             }  
  1317.         }  
  1318.     }  
  1319.   
  1320.     // This is a new alarm delivery set; bump the sequence number to indicate that  
  1321.     // all apps' alarm delivery classes should be recalculated.  
  1322.     // 这是一个新的alarm传递集合,序列号表示所有应用程序的alarm传递等级都需要重新计算  
  1323.     mCurrentSeq++;  
  1324.     // 重新计算alarm的传递优先级  
  1325.     calculateDeliveryPriorities(triggerList);  
  1326.     // 根据优先级排序  
  1327.     Collections.sort(triggerList, mAlarmDispatchComparator);  
  1328.   
  1329.     if (localLOGV) {  
  1330.         for (int i=0; i
  1331.             Slog.v(TAG, "Triggering alarm #" + i + ": " + triggerList.get(i));  
  1332.         }  
  1333.     }  
  1334.   
  1335.     return hasWakeup;  
  1336. }  
  1337.   
  1338. // alarm传递优先级定义  
  1339. static final int PRIO_TICK = 0;  
  1340. static final int PRIO_WAKEUP = 1;  
  1341. static final int PRIO_NORMAL = 2;  
  1342.   
  1343. // 计算alarm的传递优先级  
  1344. void calculateDeliveryPriorities(ArrayList alarms) {  
  1345.     final int N = alarms.size();  
  1346.     for (int i = 0; i < N; i++) {  
  1347.         Alarm a = alarms.get(i);  
  1348.   
  1349.         final int alarmPrio;  
  1350.         if (Intent.ACTION_TIME_TICK.equals(a.operation.getIntent().getAction())) {  
  1351.             alarmPrio = PRIO_TICK;  
  1352.         } else if (a.wakeup) {  
  1353.             alarmPrio = PRIO_WAKEUP;  
  1354.         } else {  
  1355.             alarmPrio = PRIO_NORMAL;  
  1356.         }  
  1357.   
  1358.         PriorityClass packagePrio = a.priorityClass;  
  1359.         if (packagePrio == null) {  
  1360.             packagePrio = a.priorityClass = new PriorityClass(); // lowest prio & stale sequence  
  1361.         }  
  1362.         a.priorityClass = packagePrio;  
  1363.   
  1364.         if (packagePrio.seq != mCurrentSeq) {  
  1365.             // first alarm we've seen in the current delivery generation from this package  
  1366.             packagePrio.priority = alarmPrio;  
  1367.             packagePrio.seq = mCurrentSeq;  
  1368.         } else {  
  1369.             // Multiple alarms from this package being delivered in this generation;  
  1370.             // bump the package's delivery class if it's warranted.  
  1371.             // TICK < WAKEUP < NORMAL  
  1372.             if (alarmPrio < packagePrio.priority) {  
  1373.                 packagePrio.priority = alarmPrio;  
  1374.             }  
  1375.         }  
  1376.     }  
  1377. }  
  1378.   
  1379. final class PriorityClass {  
  1380.     int seq;  
  1381.     int priority;  
  1382.   
  1383.     PriorityClass() {  
  1384.         seq = mCurrentSeq - 1;  
  1385.         priority = PRIO_NORMAL;  
  1386.     }  
  1387. }  
  1388.   
  1389. // 根据优先级排序，优先级相同的则根据开始执行时间排序  
  1390. final Comparator mAlarmDispatchComparator = new Comparator() {  
  1391.     @Override  
  1392.     public int compare(Alarm lhs, Alarm rhs) {  
  1393.         // priority class trumps everything.  TICK < WAKEUP < NORMAL  
  1394.         if (lhs.priorityClass.priority < rhs.priorityClass.priority) {  
  1395.             return -1;  
  1396.         } else if (lhs.priorityClass.priority > rhs.priorityClass.priority) {  
  1397.             return 1;  
  1398.         }  
  1399.   
  1400.         // within each class, sort by nominal delivery time  
  1401.         if (lhs.whenElapsed < rhs.whenElapsed) {  
  1402.             return -1;  
  1403.         } else if (lhs.whenElapsed > rhs.whenElapsed) {  
  1404.             return 1;  
  1405.         }  
  1406.   
  1407.         // same priority class + same target delivery time  
  1408.         return 0;  
  1409.     }  
  1410. };  
  1411.   
  1412. private native int waitForAlarm(long nativeData);  
  1413.   
  1414. // 检查是否允许非wakeup类型的alarm延迟执行  
  1415. boolean checkAllowNonWakeupDelayLocked(long nowELAPSED) {  
  1416.       
  1417.     /*由于非wakeup的alarm在息屏状态可能会有延迟，若不希望此情况发生，可直接在这里返回false*/  
  1418.       
  1419.     // 如果当前是亮屏状态，则返回false  
  1420.     if (mInteractive) {  
  1421.         return false;  
  1422.     }  
  1423.     if (mLastAlarmDeliveryTime <= 0) {  
  1424.         return false;  
  1425.     }  
  1426.     if (mPendingNonWakeupAlarms.size() > 0 && mNextNonWakeupDeliveryTime < nowELAPSED) {  
  1427.         // This is just a little paranoia, if somehow we have pending non-wakeup alarms  
  1428.         // and the next delivery time is in the past, then just deliver them all.  This  
  1429.         // avoids bugs where we get stuck in a loop trying to poll for alarms.  
  1430.         return false;  
  1431.     }  
  1432.     long timeSinceLast = nowELAPSED - mLastAlarmDeliveryTime;  
  1433.     // 判断上次alarm传递的时间是否小于延迟时间  
  1434.     return timeSinceLast <= currentNonWakeupFuzzLocked(nowELAPSED);  
  1435. }  
  1436.   
  1437. // 根据息屏状态持续的时间决定延迟的时间  
  1438. long currentNonWakeupFuzzLocked(long nowELAPSED) {  
  1439.     // 息屏状态持续时间=当前时间-开始息屏的时间  
  1440.     long timeSinceOn = nowELAPSED - mNonInteractiveStartTime;  
  1441.     if (timeSinceOn < 5*60*1000) {  
  1442.         // If the screen has been off for 5 minutes, only delay by at most two minutes.  
  1443.         return 2*60*1000;  
  1444.     } else if (timeSinceOn < 30*60*1000) {  
  1445.         // If the screen has been off for 30 minutes, only delay by at most 15 minutes.  
  1446.         return 15*60*1000;  
  1447.     } else {  
  1448.         // Otherwise, we will delay by at most an hour.  
  1449.         return 60*60*1000;  
  1450.     }  
  1451. }  
  1452.   
  1453. private final IAlarmManager mService;  
  1454.   
  1455. private final IBinder mService = new IAlarmManager.Stub() {  
  1456.     @Override  
  1457.     public void set(int type, long triggerAtTime, long windowLength, long interval, int flags,  
  1458.             PendingIntent operation, WorkSource workSource,  
  1459.             AlarmManager.AlarmClockInfo alarmClock) {  
  1460.         final int callingUid = Binder.getCallingUid();  
  1461.         if (workSource != null) {  
  1462.             getContext().enforcePermission(  
  1463.                     android.Manifest.permission.UPDATE_DEVICE_STATS,  
  1464.                     Binder.getCallingPid(), callingUid, "AlarmManager.set");  
  1465.         }  
  1466.   
  1467.         // No incoming callers can request either WAKE_FROM_IDLE or  
  1468.         // ALLOW_WHILE_IDLE_UNRESTRICTED -- we will apply those later as appropriate.  
  1469.         flags &= ~(AlarmManager.FLAG_WAKE_FROM_IDLE  
  1470.                 | AlarmManager.FLAG_ALLOW_WHILE_IDLE_UNRESTRICTED);  
  1471.   
  1472.         // Only the system can use FLAG_IDLE_UNTIL -- this is used to tell the alarm  
  1473.         // manager when to come out of idle mode, which is only for DeviceIdleController.  
  1474.         if (callingUid != Process.SYSTEM_UID) {  
  1475.             flags &= ~AlarmManager.FLAG_IDLE_UNTIL;  
  1476.         }  
  1477.   
  1478.         // If the caller is a core system component, and not calling to do work on behalf  
  1479.         // of someone else, then always set ALLOW_WHILE_IDLE_UNRESTRICTED.  This means we  
  1480.         // will allow these alarms to go off as normal even while idle, with no timing  
  1481.         // restrictions.  
  1482.         if (callingUid < Process.FIRST_APPLICATION_UID && workSource == null) {  
  1483.             flags |= AlarmManager.FLAG_ALLOW_WHILE_IDLE_UNRESTRICTED;  
  1484.         }  
  1485.   
  1486.         // If this is an exact time alarm, then it can't be batched with other alarms.  
  1487.         if (windowLength == AlarmManager.WINDOW_EXACT) {  
  1488.             flags |= AlarmManager.FLAG_STANDALONE;  
  1489.         }  
  1490.   
  1491.         // If this alarm is for an alarm clock, then it must be standalone and we will  
  1492.         // use it to wake early from idle if needed.  
  1493.         if (alarmClock != null) {  
  1494.             flags |= AlarmManager.FLAG_WAKE_FROM_IDLE | AlarmManager.FLAG_STANDALONE;  
  1495.         }  
  1496.   
  1497.         // 调用AlarmManagerService类的setImpl方法设置alarm  
  1498.         setImpl(type, triggerAtTime, windowLength, interval, operation,  
  1499.                 flags, workSource, alarmClock, callingUid);  
  1500.     }  
  1501.   
  1502.     @Override  
  1503.     public boolean setTime(long millis) {  
  1504.         getContext().enforceCallingOrSelfPermission(  
  1505.                 "android.permission.SET_TIME",  
  1506.                 "setTime");  
  1507.   
  1508.         if (mNativeData == 0) {  
  1509.             Slog.w(TAG, "Not setting time since no alarm driver is available.");  
  1510.             return false;  
  1511.         }  
  1512.   
  1513.         synchronized (mLock) {  
  1514.             return setKernelTime(mNativeData, millis) == 0;  
  1515.         }  
  1516.     }  
  1517.   
  1518.     @Override  
  1519.     public void setTimeZone(String tz) {  
  1520.         getContext().enforceCallingOrSelfPermission(  
  1521.                 "android.permission.SET_TIME_ZONE",  
  1522.                 "setTimeZone");  
  1523.   
  1524.         final long oldId = Binder.clearCallingIdentity();  
  1525.         try {  
  1526.             setTimeZoneImpl(tz);  
  1527.         } finally {  
  1528.             Binder.restoreCallingIdentity(oldId);  
  1529.         }  
  1530.     }  
  1531.   
  1532.     @Override  
  1533.     public void remove(PendingIntent operation) {  
  1534.         removeImpl(operation);  
  1535.   
  1536.     }  
  1537.   
  1538.     @Override  
  1539.     public long getNextWakeFromIdleTime() {  
  1540.         return getNextWakeFromIdleTimeImpl();  
  1541.     }  
  1542.   
  1543.     @Override  
  1544.     public AlarmManager.AlarmClockInfo getNextAlarmClock(int userId) {  
  1545.         userId = ActivityManager.handleIncomingUser(Binder.getCallingPid(),  
  1546.                 Binder.getCallingUid(), userId, false /* allowAll */, false /* requireFull */,  
  1547.                 "getNextAlarmClock", null);  
  1548.   
  1549.         return getNextAlarmClockImpl(userId);  
  1550.     }  
  1551.   
  1552.     @Override  
  1553.     protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {  
  1554.         . . .  
  1555.     }  
  1556.   
  1557.     @Override  
  1558.     /* updates the blocked uids, so if a wake lock is acquired to only fire 
  1559.      * alarm for it, it can be released. 
  1560.      */  
  1561.     public void updateBlockedUids(int uid, boolean isBlocked) {  
  1562.   
  1563.         if (localLOGV) Slog.v(TAG, "UpdateBlockedUids: uid = " + uid +  
  1564.                               " isBlocked = " + isBlocked);  
  1565.   
  1566.         if (Binder.getCallingUid() != Process.SYSTEM_UID) {  
  1567.             if (localLOGV) Slog.v(TAG, "UpdateBlockedUids is not allowed");  
  1568.             return;  
  1569.         }  
  1570.   
  1571.         synchronized(mLock) {  
  1572.             if(isBlocked) {  
  1573.                 mBlockedUids.add(new Integer(uid));  
  1574.                 if (checkReleaseWakeLock()) {  
  1575.                     /* all the uids for which the alarms are triggered 
  1576.                      * are either blocked or have called onSendFinished. 
  1577.                      */  
  1578.                     if (mWakeLock.isHeld()) {  
  1579.                         mWakeLock.release();  
  1580.                         if (localLOGV)  
  1581.                             Slog.v(TAG, "AM WakeLock Released Internally in updateBlockedUids");  
  1582.                     }  
  1583.                 }  
  1584.             } else {  
  1585.                 mBlockedUids.clear();  
  1586.             }  
  1587.         }  
  1588.     }  
  1589. };  
  1590.   
  1591. SystemService类中的publishBinderService方法：  
  1592. /** 
  1593. * 发布服务，以便其他服务或应用程序能调用该服务。 
  1594. */  
  1595. protected final void publishBinderService(String name, IBinder service) {  
  1596.     publishBinderService(name, service, false);  
  1597. }  
  1598.      
  1599. /** 
  1600. * 发布服务，以便其他服务或应用程序能调用该服务。 
  1601. */  
  1602. protected final void publishBinderService(String name, IBinder service,  
  1603.         boolean allowIsolated) {  
  1604.     // 把服务添加到ServiceManager中，以便其他服务或应用程序能够调用该服务  
  1605.     // getSystemService时就是根据name获取到该服务的  
  1606.     ServiceManager.addService(name, service, allowIsolated);  
  1607. }  


下面看下AlarmManagerService类的构造方法中初始化的Handler的实现：

[java] view plain copy
  1. final Object mLock = new Object();  
  2.   
  3. private class AlarmHandler extends Handler {  
  4.     public static final int ALARM_EVENT = 1;  
  5.     public static final int MINUTE_CHANGE_EVENT = 2;  
  6.     public static final int DATE_CHANGE_EVENT = 3;  
  7.     public static final int SEND_NEXT_ALARM_CLOCK_CHANGED = 4;  
  8.       
  9.     public AlarmHandler() {  
  10.     }  
  11.       
  12.     public void handleMessage(Message msg) {  
  13.         if (msg.what == ALARM_EVENT) {  
  14.             ArrayList triggerList = new ArrayList();  
  15.             synchronized (mLock) {  
  16.                 final long nowRTC = System.currentTimeMillis();  
  17.                 final long nowELAPSED = SystemClock.elapsedRealtime();  
  18.                 // 触发开始执行alarm  
  19.                 triggerAlarmsLocked(triggerList, nowELAPSED, nowRTC);  
  20.                 // 更新下一个alarm的alarmClock  
  21.                 updateNextAlarmClockLocked();  
  22.             }  
  23.   
  24.             // now trigger the alarms without the lock held  
  25.             for (int i=0; i
  26.                 Alarm alarm = triggerList.get(i);  
  27.                 try {  
  28.                     // 执行和PendingIntent关联的操作  
  29.                     alarm.operation.send();  
  30.                 } catch (PendingIntent.CanceledException e) {  
  31.                     if (alarm.repeatInterval > 0) {  
  32.                         // 移除掉alarm的PendingIntent  
  33.                         removeImpl(alarm.operation);  
  34.                     }  
  35.                 }  
  36.             }  
  37.         } else if (msg.what == SEND_NEXT_ALARM_CLOCK_CHANGED) {  
  38.             // 处理下一个alarm的开始执行时间改变的逻辑  
  39.             sendNextAlarmClockChanged();  
  40.         }  
  41.     }  
  42. }  
  43.   
  44. private final SparseArray mHandlerSparseAlarmClockArray =  
  45.         new SparseArray<>();  
  46. private static final Intent NEXT_ALARM_CLOCK_CHANGED_INTENT = new Intent(  
  47.         AlarmManager.ACTION_NEXT_ALARM_CLOCK_CHANGED);  
  48.   
  49. // 处理下一个alarm的开始执行时间改变的逻辑  
  50. private void sendNextAlarmClockChanged() {  
  51.     SparseArray pendingUsers = mHandlerSparseAlarmClockArray;  
  52.     pendingUsers.clear();  
  53.   
  54.     synchronized (mLock) {  
  55.         final int N  = mPendingSendNextAlarmClockChangedForUser.size();  
  56.         // 循环把mPendingSendNextAlarmClockChangedForUser中的值添加到pendingUsers中  
  57.         for (int i = 0; i < N; i++) {  
  58.             int userId = mPendingSendNextAlarmClockChangedForUser.keyAt(i);  
  59.             pendingUsers.append(userId, mNextAlarmClockForUser.get(userId));  
  60.         }  
  61.         mPendingSendNextAlarmClockChangedForUser.clear();  
  62.     }  
  63.   
  64.     final int N = pendingUsers.size();  
  65.     for (int i = 0; i < N; i++) {  
  66.         int userId = pendingUsers.keyAt(i);  
  67.         AlarmManager.AlarmClockInfo alarmClock = pendingUsers.valueAt(i);  
  68.         Settings.System.putStringForUser(getContext().getContentResolver(),  
  69.                 Settings.System.NEXT_ALARM_FORMATTED,  
  70.                 // 格式化时间  
  71.                 formatNextAlarm(getContext(), alarmClock, userId),  
  72.                 userId);  
  73.   
  74.         // 发送广播，接收广播的是状态栏  
  75.         getContext().sendBroadcastAsUser(NEXT_ALARM_CLOCK_CHANGED_INTENT,  
  76.                 new UserHandle(userId));  
  77.     }  
  78. }  
  79.   
  80. /** 
  81.  * Formats an alarm like platform/packages/apps/DeskClock used to. 
  82.  */  
  83. private static String formatNextAlarm(final Context context, AlarmManager.AlarmClockInfo info,  
  84.         int userId) {  
  85.     String skeleton = DateFormat.is24HourFormat(context, userId) ? "EHm" : "Ehma";  
  86.     String pattern = DateFormat.getBestDateTimePattern(Locale.getDefault(), skeleton);  
  87.     return (info == null) ? "" :  
  88.             DateFormat.format(pattern, info.getTriggerTime()).toString();  
  89. }  


下面分析下使用AlarmManagerService的流程：

应用通过getSystemService方法获取系统服务时，会调用到ContextImpl类的getSystemService方法：

[java] view plain copy
  1. @Override  
  2. public Object getSystemService(String name) {  
  3.     return SystemServiceRegistry.getSystemService(this, name);  
  4. }  


SystemServiceRegistry类中的getSystemService方法：

[java] view plain copy
  1. /** 
  2.  * Gets a system service from a given context. 
  3.  */  
  4. public static Object getSystemService(ContextImpl ctx, String name) {  
  5.     // 根据服务名从map中取出ServiceFetcher  
  6.     ServiceFetcher fetcher = SYSTEM_SERVICE_FETCHERS.get(name);  
  7.     // 如果fetcher不为null，则从fetcher中根据ctx取出对应的服务并返回  
  8.     return fetcher != null ? fetcher.getService(ctx) : null;  
  9. }  


但是在SystemServiceRegistry类的静态代码块中注册服务时，就是把上面发布到ServiceManager中的Binder代理对象返回给createService方法：

[java] view plain copy
  1. static {  
  2.     . . .  
  3.     registerService(Context.ALARM_SERVICE, AlarmManager.class,  
  4.         new CachedServiceFetcher() {  
  5.         @Override  
  6.         public AlarmManager createService(ContextImpl ctx) {  
  7.             IBinder b = ServiceManager.getService(Context.ALARM_SERVICE);  
  8.             IAlarmManager service = IAlarmManager.Stub.asInterface(b);  
  9.             return new AlarmManager(service, ctx);  
  10.         }});  
  11. }  
  12.   
  13. private static  void registerService(String serviceName, Class serviceClass,  
  14.         ServiceFetcher serviceFetcher) {  
  15.     SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);  
  16.     SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);  
  17. }  
  18.   
  19. static abstract interface ServiceFetcher {  
  20.     T getService(ContextImpl ctx);  
  21. }  
  22.   
  23. static abstract class StaticServiceFetcher implements ServiceFetcher {  
  24.     private T mCachedInstance;  
  25.   
  26.     @Override  
  27.     public final T getService(ContextImpl unused) {  
  28.         // 单例懒加载模式，具体的创建由子类实现  
  29.         synchronized (StaticServiceFetcher.this) {  
  30.             if (mCachedInstance == null) {  
  31.                 mCachedInstance = createService();  
  32.             }  
  33.             return mCachedInstance;  
  34.         }  
  35.     }  
  36.   
  37.     public abstract T createService();  
  38. }  


看下AlarmManager类：

[java] view plain copy
  1. private final boolean mAlwaysExact;  
  2. private final int mTargetSdkVersion;  
  3.   
  4. AlarmManager(IAlarmManager service, Context ctx) {  
  5.     mService = service;  
  6.   
  7.     mTargetSdkVersion = ctx.getApplicationInfo().targetSdkVersion;  
  8.     // API=19之前的alarm都是精确执行的  
  9.     mAlwaysExact = (mTargetSdkVersion < Build.VERSION_CODES.KITKAT);  
  10. }  


也就是说，其他应用通过getSystemService(Context.ALARM_SERVICE)方法获取到的AlarmManager对象中的Binder对象其实是AlarmManagerService类中的IAlarmManager代理对象。

下面看下其他应用调用AlarmManager类的setExact方法的流程：

[java] view plain copy
  1. public void setExact(int type, long triggerAtMillis, PendingIntent operation) {  
  2.     setImpl(type, triggerAtMillis, WINDOW_EXACT, 0, 0, operation, null, null);  
  3. }  
  4.   
  5. private void setImpl(int type, long triggerAtMillis, long windowMillis, long intervalMillis,  
  6.         int flags, PendingIntent operation, WorkSource workSource, AlarmClockInfo alarmClock) {  
  7.     if (triggerAtMillis < 0) {  
  8.         /* NOTYET 
  9.         if (mAlwaysExact) { 
  10.             // Fatal error for KLP+ apps to use negative trigger times 
  11.             throw new IllegalArgumentException("Invalid alarm trigger time " 
  12.                     + triggerAtMillis); 
  13.         } 
  14.         */  
  15.         triggerAtMillis = 0;  
  16.     }  
  17.   
  18.     try {  
  19.         // 调用Binder代理对象的set方法  
  20.         mService.set(type, triggerAtMillis, windowMillis, intervalMillis, flags, operation,  
  21.                 workSource, alarmClock);  
  22.     } catch (RemoteException ex) {  
  23.     }  
  24. }  


由上面的分析知，Binder代理对象调用的是AlarmManagerService类的setImpl方法设置alarm的。

你可能感兴趣的:(Android,基础业务分析)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事ndkandroidstudiojni
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
  • Android jni中数组参数的传递方式 lokeyme Andriodandroid开发JNINDKjavac语言
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员androidjetpack架构sqlite
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
  • Android干净架构MVI模板使用指南 井美婵Toby
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件 惊鸿醉 Unityunityandroidxml
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
  • 《Android进阶之光》读书笔记 soleil雪寂 读书笔记#Android进阶之光
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • android进阶之光！Android面试必备的集合源码详解，系列篇 程序员Sunbu 程序员Android
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员androidjava开发语言
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
  • Visual Studio中的Android模拟器使用详解 wurui8 androidandroidstudioandroidandroid应用
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示 仙魁XAN Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • Android Dialog圆角设置无效的问题 ly969434341 android
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活 技术无疆 Androidandroiduiandroidstudioandroid-studiojavaandroidx
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
  • Android界面特效全汇总 小飞鹤 Android开发详解android
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
  • Algorithm 香水浓 javaAlgorithm
    冒泡排序 public static void sort(Integer[] param) { for (int i = param.length - 1; i > 0; i--) { for (int j = 0; j < i; j++) { int current = param[j]; int next = param[j + 1];
  • mongoDB 复杂查询表达式 开窍的石头 mongodb
    1:count    Pg: db.user.find().count();    统计多少条数据 2:不等于$ne    Pg: db.user.find({_id:{$ne:3}},{name:1,sex:1,_id:0});    查询id不等于3的数据。 3：大于$gt $gte(大于等于) &n
  • Jboss Java heap space异常解决方法, jboss OutOfMemoryError : PermGen space 0624chenhong jvmjboss
    转自 http://blog.csdn.net/zou274/article/details/5552630 解决办法： window->preferences->java->installed jres->edit jre 把default vm arguments 的参数设为-Xms64m -Xmx512m ----------------
  • 文件上传 下载 解析 相对路径 不懂事的小屁孩 文件上传
    有点坑吧，弄这么一个简单的东西弄了一天多，身边还有大神指导着，网上各种百度着。 下面总结一下遇到的问题： 文件上传，在页面上传的时候，不要想着去操作绝对路径，浏览器会对客户端的信息进行保护，避免用户信息收到攻击。 在上传图片，或者文件时，使用form表单来操作。 前台通过form表单传输一个流到后台，而不是ajax传递参数到后台，代码如下: <form action=&
  • 怎么实现qq空间批量点赞 换个号韩国红果果 qq
    纯粹为了好玩！！ 逻辑很简单 1 打开浏览器console；输入以下代码。 先上添加赞的代码 var tools={}; //添加所有赞 function init(){ document.body.scrollTop=10000; setTimeout(function(){document.body.scrollTop=0;},2000);//加
  • 判断是否为中文 灵静志远 中文
    方法一： public class Zhidao { public static void main(String args[]) { String s = "sdf灭礌 kjl d{';\fdsjlk是"; int n=0; for(int i=0; i<s.length(); i++) { n = (int)s.charAt(i); if((
  • 一个电话面试后总结 a-john 面试
    今天，接了一个电话面试，对于还是初学者的我来说，紧张了半天。 面试的问题分了层次，对于一类问题，由简到难。自己觉得回答不好的地方作了一下总结：   在谈到集合类的时候，举几个常用的集合类，想都没想，直接说了list,map。   然后对list和map分别举几个类型：   list方面：ArrayList,LinkedList。在谈到他们的区别时，愣住了
  • MSSQL中Escape转义的使用 aijuans MSSQL
    IF OBJECT_ID('tempdb..#ABC') is not null drop table tempdb..#ABC create table #ABC ( PATHNAME NVARCHAR(50) ) insert into #ABC SELECT N'/ABCDEFGHI' UNION ALL SELECT N'/ABCDGAFGASASSDFA' UNION ALL
  • 一个简单的存储过程 asialee mysql存储过程构造数据批量插入
               今天要批量的生成一批测试数据，其中中间有部分数据是变化的，本来想写个程序来生成的，后来想到存储过程就可以搞定，所以随手写了一个，记录在此：            DELIMITER $$ DROP PROCEDURE IF EXISTS inse
  • annot convert from HomeFragment_1 to Fragment 百合不是茶 android导包错误
    创建了几个类继承Fragment, 需要将创建的类存储在ArrayList<Fragment>中; 出现不能将new 出来的对象放到队列中,原因很简单;     创建类时引入包是:import android.app.Fragment;      创建队列和对象时使用的包是:import android.support.v4.ap
  • Weblogic10两种修改端口的方法 bijian1013 weblogic端口号配置管理config.xml
    一.进入控制台进行修改    1.进入控制台:  http://127.0.0.1:7001/console     2.展开左边树菜单         域结构->环境->服务器-->点击AdminServer(管理) &
  • mysql 操作指令 征客丶 mysql
    一、连接mysql 进入 mysql 的安装目录； $ bin/mysql -p [host IP 如果是登录本地的mysql 可以不写 -p 直接 -u] -u [userName] -p 输入密码，回车，接连； 二、权限操作［如果你很了解mysql数据库后，你可以直接去修改系统表，然后用 mysql> flush privileges; 指令让权限生效］ 1、赋权 mys
  • 【Hive一】Hive入门 bit1129 hive
    Hive安装与配置 Hive的运行需要依赖于Hadoop，因此需要首先安装Hadoop2.5.2，并且Hive的启动前需要首先启动Hadoop。   Hive安装和配置的步骤   1. 从如下地址下载Hive0.14.0   http://mirror.bit.edu.cn/apache/hive/    2.解压hive，在系统变
  • ajax 三种提交请求的方法 BlueSkator Ajaxjqery
    1、ajax 提交请求 $.ajax({ type:"post", url : "${ctx}/front/Hotel/getAllHotelByAjax.do", dataType : "json", success : function(result) { try { for(v
  • mongodb开发环境下的搭建入门 braveCS 运维
      linux下安装mongodb 1）官网下载mongodb-linux-x86_64-rhel62-3.0.4.gz 2）linux 解压  gzip -d mongodb-linux-x86_64-rhel62-3.0.4.gz; mv mongodb-linux-x86_64-rhel62-3.0.4 mongodb-linux-x86_64-rhel62-
  • 编程之美-最短摘要的生成 bylijinnan java数据结构算法编程之美
    import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; public class ShortestAbstract { /** * 编程之美 最短摘要的生成 * 扫描过程始终保持一个[pBegin,pEnd]的range,初始化确保[pBegin,pEnd]的ran
  • json数据解析及typeof chengxuyuancsdn jstypeofjson解析
    // json格式 var people='{"authors": [{"firstName": "AAA","lastName": "BBB"},' +' {"firstName": "CCC&
  • 流程系统设计的层次和目标 comsci 设计模式数据结构sql框架脚本
                                  流程系统设计的层次和目标  
  • RMAN List和report 命令 daizj oraclelistreportrman
    LIST 命令 使用RMAN LIST 命令显示有关资料档案库中记录的备份集、代理副本和映像副本的 信息。使用此命令可列出： • RMAN 资料档案库中状态不是AVAILABLE 的备份和副本 • 可用的且可以用于还原操作的数据文件备份和副本 • 备份集和副本，其中包含指定数据文件列表或指定表空间的备份 • 包含指定名称或范围的所有归档日志备份的备份集和副本 • 由标记、完成时间、可
  • 二叉树:红黑树 dieslrae 二叉树
        红黑树是一种自平衡的二叉树,它的查找,插入,删除操作时间复杂度皆为O(logN),不会出现普通二叉搜索树在最差情况时时间复杂度会变为O(N)的问题.     红黑树必须遵循红黑规则,规则如下     1、每个节点不是红就是黑。     2、根总是黑的  &
  • C语言homework3，7个小题目的代码 dcj3sjt126com c
    1、打印100以内的所有奇数。 # include <stdio.h> int main(void) { int i; for (i=1; i<=100; i++) { if (i%2 != 0) printf("%d ", i); } return 0; }  2、从键盘上输入10个整数，
  • 自定义按钮, 图片在上, 文字在下, 居中显示 dcj3sjt126com 自定义
    #import <UIKit/UIKit.h> @interface MyButton : UIButton -(void)setFrame:(CGRect)frame ImageName:(NSString*)imageName Target:(id)target Action:(SEL)action Title:(NSString*)title Font:(CGFloa
  • MySQL查询语句练习题，测试足够用了 flyvszhb sqlmysql
    http://blog.sina.com.cn/s/blog_767d65530101861c.html 1.创建student和score表 CREATE  TABLE  student ( id  INT(10)  NOT NULL  UNIQUE  PRIMARY KEY  , name  VARCHAR
  • 转：MyBatis Generator 详解 happyqing mybatis
      MyBatis Generator 详解 http://blog.csdn.net/isea533/article/details/42102297   MyBatis Generator详解 http://git.oschina.net/free/Mybatis_Utils/blob/master/MybatisGeneator/MybatisGeneator.
  • 让程序员少走弯路的14个忠告 jingjing0907 工作计划学习
      无论是谁，在刚进入某个领域之时，有再大的雄心壮志也敌不过眼前的迷茫：不知道应该怎么做，不知道应该做什么。下面是一名软件开发人员所学到的经验，希望能对大家有所帮助   1.不要害怕在工作中学习。 只要有电脑，就可以通过电子阅读器阅读报纸和大多数书籍。如果你只是做好自己的本职工作以及分配的任务，那是学不到很多东西的。如果你盲目地要求更多的工作，也是不可能提升自己的。放
  • nginx和NetScaler区别 流浪鱼 nginx
    NetScaler是一个完整的包含操作系统和应用交付功能的产品，Nginx并不包含操作系统，在处理连接方面，需要依赖于操作系统，所以在并发连接数方面和防DoS攻击方面，Nginx不具备优势。 2.易用性方面差别也比较大。Nginx对管理员的水平要求比较高，参数比较多，不确定性给运营带来隐患。在NetScaler常见的配置如健康检查，HA等，在Nginx上的配置的实现相对复杂。 3.策略灵活度方
  • 第11章 动画效果（下） onestopweb 动画
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • FAQ - SAP BW BO roadmap blueoxygen BOBW
    http://www.sdn.sap.com/irj/boc/business-objects-for-sap-faq   Besides, I care that how to integrate tightly.   By the way, for BW consultants, please just focus on Query Designer which i
  • 关于java堆内存溢出的几种情况 tomcat_oracle javajvmjdkthread
    【情况一】： 　　 java.lang.OutOfMemoryError: Java heap space：这种是java堆内存不够，一个原因是真不够，另一个原因是程序中有死循环； 　　如果是java堆内存不够的话，可以通过调整JVM下面的配置来解决： 　　<jvm-arg>-Xms3062m</jvm-arg> 　　<jvm-arg>-Xmx
  • Manifest.permission_group权限组 阿尔萨斯 Permission
    结构 继承关系 public static final class Manifest.permission_group extends Object java.lang.Object android. Manifest.permission_group 常量 ACCOUNTS 直接通过统计管理器访问管理的统计 COST_MONEY可以用来让用户花钱但不需要通过与他们直接牵涉的权限 D
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他