为什么Android系统闹钟会出现延迟的现象？ about androidbox HOT 4 OPEN

AlarmMananger.java (6.0以上)

/** Like {@link #set(int, long, PendingIntent)}, but this alarm will be allowed to
  * execute even when the system is in low-power idle modes.*/
void setAndAllowWhileIdle(int type, long triggerAtMillis, PendingIntent operation)

/** Like {@link #setExact(int, long, PendingIntent)}, but this alarm will be allowed to
 * execute even when the system is in low-power idle modes.*/
void setExactAndAllowWhileIdle(int type, long triggerAtMillis, PendingIntent operation)

void SmartHeartbeat::JudgeMIUIStyle() {
    static int test_total_count = 0;
    static uint64_t last_alarm_tick = 0;

    if (test_total_count >= MAX_JUDGE_TIMES) {
        return;
    }

    if (last_alarm_tick == 0) {
        last_alarm_tick = gettickcount();
        return;
    }

    uint64_t span = gettickspan(last_alarm_tick);
    last_alarm_tick = ::gettickcount();

    if (span < 10000)    // for case the same alarm
        return;

    if ((span % 300000) <= 10000 || (300000 - (span % 300000)) <= 10000) {  // judge if curTime is times of five minutes, 10 seconds as the max offset
        xiaomi_style_count_++;
        xinfo2(TSF"m_xiaomiStyleCount++ %0", xiaomi_style_count_);

        if (!current_net_heart_info_.is_stable_ && xiaomi_style_count_ >= 3) {
            xinfo2(TSF"judgeMIUIStyle: is MIUIStyle. xiaomiCount = %0 ", xiaomi_style_count_);
            current_net_heart_info_.is_stable_ = true;
            __SaveINI();
        }
    } else {
        xiaomi_style_count_ = 0;
    }

    test_total_count++;
}

void setImpl(int type, long triggerAtTime, long windowLength, long interval,
            PendingIntent operation, IAlarmListener directReceiver, String listenerTag,
            int flags, WorkSource workSource, AlarmManager.AlarmClockInfo alarmClock,
            int callingUid, String callingPackage) {

        final long maxElapsed;
        if (windowLength == AlarmManager.WINDOW_EXACT) {
            maxElapsed = triggerElapsed;
        } else if (windowLength < 0) {
            maxElapsed = maxTriggerTime(nowElapsed, triggerElapsed, interval);
            // Fix this window in place, so that as time approaches we don't collapse it.
            windowLength = maxElapsed - triggerElapsed;
        } else {
            maxElapsed = triggerElapsed + windowLength;
        }

}

    // Apply a heuristic to { recurrence interval, futurity of the trigger time } to
    // calculate the end of our nominal delivery window for the alarm.
    static long maxTriggerTime(long now, long triggerAtTime, long interval) {
        // Current heuristic: batchable window is 75% of either the recurrence interval
        // [for a periodic alarm] or of the time from now to the desired delivery time,
        // with a minimum delay/interval of 10 seconds, under which we will simply not
        // defer the alarm.
        long futurity = (interval == 0)
                ? (triggerAtTime - now)
                : interval;
        if (futurity < MIN_FUZZABLE_INTERVAL) {
            futurity = 0;
        }
        return triggerAtTime + (long)(.75 * futurity);
    }

    private void setImplLocked(int type, long when, long whenElapsed, long windowLength,
            long maxWhen, long interval, PendingIntent operation, IAlarmListener directReceiver,
            String listenerTag, int flags, boolean doValidate, WorkSource workSource,
            AlarmManager.AlarmClockInfo alarmClock, int callingUid, String callingPackage) {
        // New一个Alarm实体对象
        Alarm a = new Alarm(type, when, whenElapsed, windowLength, maxWhen, interval,
                operation, directReceiver, listenerTag, workSource, flags, alarmClock,
                callingUid, callingPackage);
       // 省略代码
        removeLocked(operation, directReceiver);
      // 设置闹钟时间
        setImplLocked(a, false, doValidate);
    }

private void setImplLocked(Alarm a, boolean rebatching, boolean doValidate) {
        // 找有没有存在的batch可以存入本次的 alarm
         int whichBatch = ((a.flags&AlarmManager.FLAG_STANDALONE) != 0)
                ? -1 : attemptCoalesceLocked(a.whenElapsed, a.maxWhenElapsed);
        if (whichBatch < 0) {
          // 没有则new一个新的batch，并保存到mAlarmBatches里面去
            Batch batch = new Batch(a);
            addBatchLocked(mAlarmBatches, batch);
        } else {
            // 找到一个已存在的batch，并存入刷新mAlarmBatches
            Batch batch = mAlarmBatches.get(whichBatch);
            if (batch.add(a)) {
                // The start time of this batch advanced, so batch ordering may
                // have just been broken.  Move it to where it now belongs.
                mAlarmBatches.remove(whichBatch);
                addBatchLocked(mAlarmBatches, batch);
            }
        }
      // 省略代码
      rescheduleKernelAlarmsLocked();
      updateNextAlarmClockLocked();
}

// Batch 的构造方法
Batch(Alarm seed) {
            start = seed.whenElapsed;// Batch的起始点
            end = seed.maxWhenElapsed;//Batch的结束点
            flags = seed.flags;
            alarms.add(seed);// 本Batch的alarms列表
}

// 根据Batch的边界条件判断该batch是否可以hold住传入的alarm
boolean canHold(long whenElapsed, long maxWhen) {
        // 新的alarm 必须要在旧的alarm的范围内，才能加入
        return (end >= whenElapsed) && (start <= maxWhen);
}

// 给一个batch添加一个新的alarm，并且该batch根据新的alarm的边界取交集，作为batch新的边界
        boolean add(Alarm alarm) {
            boolean newStart = false;
            // narrows the batch if necessary; presumes that canHold(alarm) is true
            int index = Collections.binarySearch(alarms, alarm, sIncreasingTimeOrder);
            if (index < 0) {
                index = 0 - index - 1;
            }
            alarms.add(index, alarm);
            if (DEBUG_BATCH) {
                Slog.v(TAG, "Adding " + alarm + " to " + this);
            }
           // 其实点取大的
            if (alarm.whenElapsed > start) {
                start = alarm.whenElapsed;
                newStart = true;
            }
           //结束点取小的
            if (alarm.maxWhenElapsed < end) {
                end = alarm.maxWhenElapsed;
            }
            flags |= alarm.flags;

            if (DEBUG_BATCH) {
                Slog.v(TAG, "    => now " + this);
            }
            return newStart;
        }

    void rescheduleKernelAlarmsLocked() {
        // Schedule the next upcoming wakeup alarm.  If there is a deliverable batch
        // prior to that which contains no wakeups, we schedule that as well.
        long nextNonWakeup = 0;
        if (mAlarmBatches.size() > 0) {
           // 拿到第一个存在wakeup的batch,
            final Batch firstWakeup = findFirstWakeupBatchLocked();
          // 拿到第一个batch
            final Batch firstBatch = mAlarmBatches.get(0);
          // 如果存在wakeup的batch，则设置系统闹钟为第一个batch的时间
            if (firstWakeup != null && mNextWakeup != firstWakeup.start) {
                mNextWakeup = firstWakeup.start;
                mLastWakeupSet = SystemClock.elapsedRealtime();
               // 设置到系统，并这个type会唤醒系统
                setLocked(ELAPSED_REALTIME_WAKEUP, firstWakeup.start);
            }
            if (firstBatch != firstWakeup) {
                nextNonWakeup = firstBatch.start;
            }
        }
      // 对于不是wakeup的闹钟处理
        if (mPendingNonWakeupAlarms.size() > 0) {
            if (nextNonWakeup == 0 || mNextNonWakeupDeliveryTime < nextNonWakeup) {
                nextNonWakeup = mNextNonWakeupDeliveryTime;
            }
        }
        if (nextNonWakeup != 0 && mNextNonWakeup != nextNonWakeup) {
            mNextNonWakeup = nextNonWakeup;
            setLocked(ELAPSED_REALTIME, nextNonWakeup);
        }
    }

// jni到系统底层的闹钟服务
private native void set(long nativeData, int type, long seconds, long nanoseconds);

 //
  // duration： alarm设置的时间间隔，比如是10分钟后醒来的闹钟
    static int fuzzForDuration(long duration) {
        if (duration < 15*60*1000) {
            // If the duration until the time is less than 15 minutes, the maximum fuzz
            // is the duration.
            return (int)duration;
        } else if (duration < 90*60*1000) {
            // If duration is less than 1 1/2 hours, the maximum fuzz is 15 minutes,
            return 15*60*1000;
        } else {
            // Otherwise, we will fuzz by at most half an hour.
            return 30*60*1000;
        }
    }
 // 针对非wakeup的alarm的延时处理
   long currentNonWakeupFuzzLocked(long nowELAPSED) {
        long timeSinceOn = nowELAPSED - mNonInteractiveStartTime;
        if (timeSinceOn < 5*60*1000) {
            // If the screen has been off for 5 minutes, only delay by at most two minutes.
            return 2*60*1000;
        } else if (timeSinceOn < 30*60*1000) {
            // If the screen has been off for 30 minutes, only delay by at most 15 minutes.
            return 15*60*1000;
        } else {
            // Otherwise, we will delay by at most an hour.
            return 60*60*1000;
        }
    }

 private class AlarmThread extends Thread
    {
        public AlarmThread()
        {
            super("AlarmManager");
        }
        
        public void run()
        {
            ArrayList<Alarm> triggerList = new ArrayList<Alarm>();
            //  死循环，一直监听系统的闹钟
            while (true)
            {
                // 系统层阻塞方法，等着闹钟醒来
                int result = waitForAlarm(mNativeData);
                mLastWakeup = SystemClock.elapsedRealtime();
               // 省略代码
                if (result != TIME_CHANGED_MASK) {
                        boolean hasWakeup = triggerAlarmsLocked(triggerList, nowELAPSED, nowRTC);
                        if (!hasWakeup && checkAllowNonWakeupDelayLocked(nowELAPSED)) {
                              // 省略代码
                        } else {
                            // now deliver the alarm intents; if there are pending non-wakeup
                            // alarms, we need to merge them in to the list.  note we don't
                            // just deliver them first because we generally want non-wakeup
                            // alarms delivered after wakeup alarms.
                            rescheduleKernelAlarmsLocked();
                            updateNextAlarmClockLocked();
                           // 省略代码
                          //  终于确定要分发这个batch所有的alarm了
                            deliverAlarmsLocked(triggerList, nowELAPSED);
                        }
                    }

                } else {
                    // Just in case -- even though no wakeup flag was set, make sure
                    // we have updated the kernel to the next alarm time.
                    synchronized (mLock) {
                        rescheduleKernelAlarmsLocked();
                    }
                }
            }
        }
    }

void deliverAlarmsLocked(ArrayList<Alarm> triggerList, long nowELAPSED) {
        mLastAlarmDeliveryTime = nowELAPSED;
        for (int i=0; i<triggerList.size(); i++) {
            Alarm alarm = triggerList.get(i);
            // 分发alarm
           mDeliveryTracker.deliverLocked(alarm, nowELAPSED, allowWhileIdle);
           
        }
    }

public void deliverLocked(Alarm alarm, long nowELAPSED, boolean allowWhileIdle) {
     // 发送alarm的PendingIntent
    alarm.operation.send(getContext(), 0,
    mBackgroundIntent.putExtra(
    Intent.EXTRA_ALARM_COUNT, alarm.count),
     mDeliveryTracker, mHandler, null,
     allowWhileIdle ? mIdleOptions : null);
    } 
   // 最后要通知到ams
   if (alarm.type == ELAPSED_REALTIME_WAKEUP
                    || alarm.type == RTC_WAKEUP) {
                bs.numWakeup++;
                fs.numWakeup++;
                if (alarm.workSource != null && alarm.workSource.size() > 0) {
                    for (int wi=0; wi<alarm.workSource.size(); wi++) {
                        final String wsName = alarm.workSource.getName(wi);
                        ActivityManager.noteWakeupAlarm(
                                alarm.operation, alarm.workSource.get(wi),
                                (wsName != null) ? wsName : alarm.packageName,
                                alarm.statsTag);
                    }
                } else {
                    ActivityManager.noteWakeupAlarm(
                            alarm.operation, alarm.uid, alarm.packageName, alarm.statsTag);
                }
       }              
}