两种时间更新机制
NITZ
NITZ(Network Identity and Time Zone，网络标识和时区），是一种用于自动配置本地的时间和日期的机制，同时也通过无线网向移动设备提供运营商信息。NITZ是自从PHASE 2+ RELEASE 96 的GSM中的可选功能，经常被用来自动更新移动电话的系统时钟。NITZ需要运营商网络支持（通过CS网络），目前国内电信、移动都支持NITZ方式更新时间日期，而联通目前不支持
NTP
NTP：NTP(Network Time Protocol)提供准确时间，首先要有准确的时间来源，这一时间应该是国际标准时间UTC。 NTP获得UTC的时间来源可以是原子钟、天文台、卫星，也可以从Internet上获取。这样就有了准确而可靠的时间源。时间按NTP服务器的等级传播。与NITZ不同的是，NTP需要从专门的NTP服务器来获取时间，只要手机连接上网络，都可以实现时间的更新。
一、Android网络时间更新
Android网络时间更新，大体分两类。1、moderm相关更新，2、网络更新。本次主要介绍网路更新时间，主要涉及到NetworkTimeUpdateService，该类运行在SystemServer（ActivityManagerService）进程中。它有点特殊，从名字来看，其实Service，其实它和WifiService、ConnectivityManagerService等系统Service不同。
ZygoteInit.java的startSystemServer函数中启动了SyetemServer进程,代码路径如下所示：\frameworks\base\services\java\com\android\server\SystemServer.java
/**
* The main entry point from zygote.
*/
public static void main(String[] args) {
new SystemServer().run();
}startOtherServices方法中，会初始化该类实例：
if (!disableNetwork && !disableNetworkTime) {
traceBeginAndSlog("StartNetworkTimeUpdateService");
try {
networkTimeUpdater = new NetworkTimeUpdateService(context);
ServiceManager.addService("network_time_update_service", networkTimeUpdater);
} catch (Throwable e) {
reportWtf("starting NetworkTimeUpdate service", e);
}
traceEnd();
}网络更新的相关代码：
frameworks/base/services/core/java/com/android/server/NetworkTimeUpdateService.java
frameworks/base/core/java/android/util/NtpTrustedTime.java
frameworks/base/core/java/android/net/SntpClient.javaNetworkTimeUpdateService构造函数初始化
public NetworkTimeUpdateService(Context context) {
Log.d(TAG, "NetworkTimeUpdateService()");
mContext = context;
mTime = NtpTrustedTime.getInstance(context);
mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
mCM = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
//时间同步有可能超时，使用该PendingIntent进行（间隔再次发起）时间同步。
Intent pollIntent = new Intent(ACTION_POLL, null);
mPendingPollIntent = PendingIntent.getBroadcast(mContext, POLL_REQUEST, pollIntent, 0);
//正常轮询频率 24小时
mPollingIntervalMs = mContext.getResources().getInteger(
com.android.internal.R.integer.config_ntpPollingInterval);
//再次尝试轮询间隔，以防网络请求失败 60秒
mPollingIntervalShorterMs = mContext.getResources().getInteger(
com.android.internal.R.integer.config_ntpPollingIntervalShorter);
//重试次数 3次
mTryAgainTimesMax = mContext.getResources().getInteger(
com.android.internal.R.integer.config_ntpRetry);
//如果时间差大于此阈值，则更新时间。 5秒
mTimeErrorThresholdMs = mContext.getResources().getInteger(
com.android.internal.R.integer.config_ntpThreshold);
mWakeLock = ((PowerManager) context.getSystemService(Context.POWER_SERVICE)).newWakeLock(
PowerManager.PARTIAL_WAKE_LOCK, TAG);
Log.d(TAG, "mPollingIntervalMs "+mPollingIntervalMs);
Log.d(TAG, "mPollingIntervalShorterMs "+mPollingIntervalShorterMs);
Log.d(TAG, "mTryAgainTimesMax "+mTryAgainTimesMax);
Log.d(TAG, "mTimeErrorThresholdMs "+mTimeErrorThresholdMs);
}在SystemServer.java中调用systemRunning(),初始化接收方并启动第一个NTP请求
//在SystemServer.java中调用systemRunning()
traceBeginAndSlog("MakeCountryDetectionServiceReady");
try {
if (countryDetectorF != null) countryDetectorF.systemRunning();
} catch (Throwable e) {
reportWtf("Notifying CountryDetectorService running", e);
}
traceEnd();
traceBeginAndSlog("MakeNetworkTimeUpdateReady");NetworkTimeUpdateService初始化时间同步环境开机后，会调用该类的systemRunning方法，在该方法中中实现systemRunning();
public void systemRunning() {
registerForTelephonyIntents();
registerForAlarms();
HandlerThread thread = new HandlerThread(TAG);
thread.start();
mHandler = new MyHandler(thread.getLooper());
mNetworkTimeUpdateCallback = new NetworkTimeUpdateCallback();
mCM.registerDefaultNetworkCallback(mNetworkTimeUpdateCallback, mHandler);
mSettingsObserver = new SettingsObserver(mHandler, EVENT_AUTO_TIME_CHANGED);
mSettingsObserver.observe(mContext);
}registerForTelephonyIntents该方法，注册监听来自Telephony Ril相关的广播。此部分会在moderm相关同步时间中介绍
private void registerForTelephonyIntents() {
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(TelephonyIntents.ACTION_NETWORK_SET_TIME);
intentFilter.addAction(TelephonyIntents.ACTION_NETWORK_SET_TIMEZONE);
mContext.registerReceiver(mNitzReceiver, intentFilter);
}系统启动后，会收到一个Telephony的广播android.intent.action.NETWORK_SET_TIMEZONE，获取系统深度睡眠时间
//尼兹时间事件的接收者
private BroadcastReceiver mNitzReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (DBG) Log.d(TAG, "Received " + action);
if (TelephonyIntents.ACTION_NETWORK_SET_TIME.equals(action)) {
mNitzTimeSetTime = SystemClock.elapsedRealtime();//从设备开机到现在的时间，单位毫秒，含系统深度睡眠时间
} else if (TelephonyIntents.ACTION_NETWORK_SET_TIMEZONE.equals(action)) {
mNitzZoneSetTime = SystemClock.elapsedRealtime();
}
}
};当我们点击设置中的自动确定日期和时间时，然后通过观察者模式会执行如下代码，构建监听数据库的Observer，监听来自设置等发起的时间同步请求。在SettingsObserver中构建handler Message请求，发起时间同步。
源码路径：packages/apps/Settings/src/com/android/settings/DateTimeSettings.javamSettingsObserver = new SettingsObserver(mHandler, EVENT_AUTO_TIME_CHANGED);
mSettingsObserver.observe(mContext);
private static class SettingsObserver extends ContentObserver {
private int mMsg;
private Handler mHandler;
SettingsObserver(Handler handler, int msg) {
super(handler);
mHandler = handler;
mMsg = msg;
}
void observe(Context context) {
ContentResolver resolver = context.getContentResolver();
resolver.registerContentObserver(Settings.Global.getUriFor(Settings.Global.AUTO_TIME),
false, this);
}
@Override
public void onChange(boolean selfChange) {
Log.d(TAG, "onChange() selfChange "+selfChange);
mHandler.obtainMessage(mMsg).sendToTarget();
}
}接收的来自Telephony相关的广播，或者数据库变化，我们都会发送Message给Handler，我们的handler是如下处理这些请求的：
/** Handler to do the network accesses on */
private class MyHandler extends Handler {
public MyHandler(Looper l) {
super(l);
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case EVENT_AUTO_TIME_CHANGED:
case EVENT_POLL_NETWORK_TIME:
case EVENT_NETWORK_CHANGED:
onPollNetworkTime(msg.what);
break;
}
}
}当我们打开移动数据或者wifi打开连接网络后是就会执行如下代码
private class NetworkTimeUpdateCallback extends NetworkCallback {
@Override
public void onAvailable(Network network) {
Log.d(TAG, String.format("New default network %s; checking time.", network));
mDefaultNetwork = network;
// Running on mHandler so invoke directly.
onPollNetworkTime(EVENT_NETWORK_CHANGED);
}
@Override
public void onLost(Network network) {
if (network.equals(mDefaultNetwork)) mDefaultNetwork = null;
}
}下面是时间同步请求处理逻辑
接收请求类型：EVENT_AUTO_TIME_CHANGED、EVENT_POLL_NETWORK_TIME、
EVENT_NETWORK_CONNECTED，这些请求逻辑，我们都会发起onPollNetworkTime来进行相关逻辑处理。也就是说，onPollNetworkTime方法就是我们时间同步的主要关注对象。
private void onPollNetworkTime(int event) {
// If Automatic time is not set, don't bother. Similarly, if we don't
// have any default network, don't bother.
Log.d(TAG, "isAutomaticTimeRequested() "+isAutomaticTimeRequested());
Log.d(TAG, "mDefaultNetwork() "+mDefaultNetwork);
//自动使用网络提供时间sAutomaticTimeRequested() 就是true
if (!isAutomaticTimeRequested() || mDefaultNetwork == null) return;
mWakeLock.acquire();
try {
onPollNetworkTimeUnderWakeLock(event);
} finally {
mWakeLock.release();
}
}
private void onPollNetworkTimeUnderWakeLock(int event) {
final long refTime = SystemClock.elapsedRealtime();
// If NITZ time was received less than mPollingIntervalMs time ago,
// no need to sync to NTP.
if (mNitzTimeSetTime != NOT_SET && refTime - mNitzTimeSetTime < mPollingIntervalMs) {
resetAlarm(mPollingIntervalMs);
return;
}
final long currentTime = System.currentTimeMillis();
if (DBG) Log.d(TAG, "System time = " + currentTime);
// Get the NTP time
if (mLastNtpFetchTime == NOT_SET || refTime >= mLastNtpFetchTime + mPollingIntervalMs
|| event == EVENT_AUTO_TIME_CHANGED) {
if (DBG) Log.d(TAG, "Before Ntp fetch");
// force refresh NTP cache when outdated
if (mTime.getCacheAge() >= mPollingIntervalMs) {
mTime.forceRefresh();
}
// only update when NTP time is fresh
if (mTime.getCacheAge() < mPollingIntervalMs) {
final long ntp = mTime.currentTimeMillis();
mTryAgainCounter = 0;
// If the clock is more than N seconds off or this is the first time it's been
// fetched since boot, set the current time.
if (Math.abs(ntp - currentTime) > mTimeErrorThresholdMs
|| mLastNtpFetchTime == NOT_SET) {
// Set the system time
if (DBG && mLastNtpFetchTime == NOT_SET
&& Math.abs(ntp - currentTime) <= mTimeErrorThresholdMs) {
Log.d(TAG, "For initial setup, rtc = " + currentTime);
}
if (DBG) Log.d(TAG, "Ntp time to be set = " + ntp);
// Make sure we don't overflow, since it's going to be converted to an int
if (ntp / 1000 < Integer.MAX_VALUE) {
SystemClock.setCurrentTimeMillis(ntp);
}
} else {
if (DBG) Log.d(TAG, "Ntp time is close enough = " + ntp);
}
mLastNtpFetchTime = SystemClock.elapsedRealtime();
} else {
// Try again shortly
mTryAgainCounter++;
if (mTryAgainTimesMax < 0 || mTryAgainCounter <= mTryAgainTimesMax) {
resetAlarm(mPollingIntervalShorterMs);
} else {
// Try much later
mTryAgainCounter = 0;
resetAlarm(mPollingIntervalMs);
}
return;
}
}
resetAlarm(mPollingIntervalMs);
}NTPServer服务器配置
修改配置位置：frameworks\base\core\res\res\values\config.xml
<string translatable="false" name="config_ntpServer">2.android.pool.ntp.org</string>NTP从服务器获取时间分析
首先定义一个接口类TrustedTime，里面有如下方法：
public interface TrustedTime {
/**
* Force update with an external trusted time source, returning {@code true}
* when successful.
*/
public boolean forceRefresh();
/**
* Check if this instance has cached a response from a trusted time source.
*/
public boolean hasCache();
/**
* Return time since last trusted time source contact, or
* {@link Long#MAX_VALUE} if never contacted.
*/
public long getCacheAge();
/**
* Return certainty of cached trusted time in milliseconds, or
* {@link Long#MAX_VALUE} if never contacted. Smaller values are more
* precise.
*/
public long getCacheCertainty();
/**
* Return current time similar to {@link System#currentTimeMillis()},
* possibly using a cached authoritative time source.
*/
public long currentTimeMillis();
}NtpTrustedTime类实现TrustedTime的方法，在forceRefresh（）中获取服务器的时间。
@Override
public boolean forceRefresh() {
if (TextUtils.isEmpty(mServer)) {
// missing server, so no trusted time available
return false;
}
// We can't do this at initialization time: ConnectivityService might not be running yet.
synchronized (this) {
if (mCM == null) {
mCM = (ConnectivityManager) sContext.getSystemService(Context.CONNECTIVITY_SERVICE);
}
}
final NetworkInfo ni = mCM == null ? null : mCM.getActiveNetworkInfo();
if (ni == null || !ni.isConnected()) {
if (LOGD) Log.d(TAG, "forceRefresh: no connectivity");
return false;
}
if (LOGD) Log.d(TAG, "forceRefresh() from cache miss");
//final SntpClient client = new SntpClient();
final SprdSntpClient client = new SprdSntpClient();
if (client.requestTime(mServer, (int) mTimeout)) {
mHasCache = true;
mCachedNtpTime = client.getNtpTime();
mCachedNtpElapsedRealtime = client.getNtpTimeReference();
mCachedNtpCertainty = client.getRoundTripTime() / 2;
return true;
} else {
return false;
}
}日志流程
05-29 11:14:38.284 901 901 D NetworkTimeUpdateService: NetworkTimeUpdateService()
05-29 11:14:38.285 901 901 D NetworkTimeUpdateService: mPollingIntervalMs 86400000
05-29 11:14:38.285 901 901 D NetworkTimeUpdateService: mPollingIntervalShorterMs 60000
05-29 11:14:38.285 901 901 D NetworkTimeUpdateService: mTryAgainTimesMax 3
05-29 11:14:38.285 901 901 D NetworkTimeUpdateService: mTimeErrorThresholdMs 5000
05-29 11:14:44.805 901 901 D NetworkTimeUpdateService: Received android.intent.action.NETWORK_SET_TIMEZONE
05-29 11:20:12.155 901 1303 D NetworkTimeUpdateService: New default network 100; checking time.
05-29 11:20:12.158 901 1303 D NetworkTimeUpdateService: System time = 1590722412158
05-29 11:20:12.158 901 1303 D NetworkTimeUpdateService: Before Ntp fetch
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
