NTP服务器同步android系统时间
做android开发有一段时间了，之前一直做服务类的产品，最近公司接手sip话机的项目，里面涉及到修改系统设置的问题，今天就把我在项目中有关NTP服务器同步android系统时间遇到的种种问题，在这做一个总结，希望给后面的人一些帮助，本人也是首次接触这样的项目，总结的如有不完善的地方，希望大神指点出来。。。。
ntp服务器地址
有很多，网可以搜一下
cn.pool.ntp.org
s1a.time.edu.cn 北京邮电大学
s1b.time.edu.cn 清华大学
s1c.time.edu.cn 北京大学
s1d.time.edu.cn 东南大学
s1e.time.edu.cn 清华大学
s2a.time.edu.cn 清华大学
s2b.time.edu.cn 清华大学
中国[China] cn.ntp.org.cn
美国[America] us.ntp.org.cn
韩国[korea] kr.ntp.org.cn
新加坡[Singapore] sgp.ntp.org.cn
由于项目要求，在项目中同步系统时间是每隔多久同步一次系统时间，通过TimerTask来执行任务。通过handler来发送处理消息。相关代码：
/**
*校准时间
* 从ntp服务器中获取时间
* @param ntpHost
* ntp服务器域名地址
* @return 如果失败返回-1，否则返回当前的毫秒数
*/
public static void startCalibrateTime(final String mhostAddress,
final int cycleTime) {
MyLog.d(tag, "startCalibrateTime()");
if (mCycleTimer != null) {
mCycleTask.cancel();
mCycleTimer.cancel();
mCycleTimer.purge();
mCycleTask = null;
mCycleTimer = null;
}
mCycleTask = new TimerTask() {
@Override
public void run() {
MyLog.d(tag, "run()");
long time = getTimeFromNtpServer(mhostAddress);//从获取ntp服务器上获取时间
if (time == -1) {
MyLog.e(tag, "async time failed.");
} else {
SystemClock.setCurrentTimeMillis(time);//设置系统时间
}
if (isTurnToSuccess) {
isTurnToSuccess = false;
mHandler.sendEmptyMessage(MSG_NTP_SEARCH_OK);
}
}
@Override
public boolean cancel() {
MyLog.d(tag, "cancel()");
return super.cancel();
}
};
mCycleTimer = new NgnTimer();
mCycleTimer.schedule(mCycleTask, 0, cycleTime);
MyLog.d(tag, "start ntp timer time:" + cycleTime / 1000);
}
handler处理消息，在不同的消息出处理不同的操作，针对项目要求，我在项目中保存了ntp服务器地址和每次隔多久同步一次的时间，可以自行定义。
涉及到的变量：
private static String mNtpServer = “pool.ntp.org”;
/**
* NTP获取时间失败时,每隔30s周期性重新获取，直至成功，成功后恢复正常计时
*/
private final static int CYCLE_TIME_ERROR = 30000;
private static Handler mHandler = new Handler() {
@Override
public void handleMessage(android.os.Message msg) {
if (msg.what == MSG_NTP_SEARCH_FAILED) {
String mhostAddress = GlobalConfigUtils
.get(ConfTag.DATETIME_SNTP_SERVER);
if (TextUtils.isEmpty(mhostAddress)) {
mhostAddress = mNtpServer;
}
startCalibrateTime(mhostAddress, CYCLE_TIME_ERROR);
} else if (msg.what == MSG_NTP_SEARCH_OK) {
String mhostAddress = GlobalConfigUtils
.get(ConfTag.DATETIME_SNTP_SERVER);//项目中保存的ntp服务器地址
if (TextUtils.isEmpty(mhostAddress)) {
mhostAddress = mNtpServer;
}
String timeStr = GlobalConfigUtils .get(ConfTag.DATETIME_NTP_RESYNC_TIME);//项目中设置的系统默认隔多久同步时间
int time = 168 * 60 * 60 * 1000;
if (!TextUtils.isEmpty(timeStr)
&& TextUtils.isDigitsOnly(timeStr)) {
time = Integer.parseInt(timeStr)*3600*1000;
}
startCalibrateTime(mhostAddress, time);
}
};
};
停止校准时间
public static void stopCalibrateTimer() {
if (mCycleTimer != null) {
mCycleTask.cancel();
mCycleTimer.cancel();
mCycleTimer.purge();
mCycleTask = null;
mCycleTimer = null;
}
}
最重要的部分就是从ntp服务器上获取时间，这块很重要。。重要原因就是NTP工作原理简单分析一下：
下面是NTP工作原理图，图片是从我看的资料上截取过来勿喷。
Device A 与 Device B 通过网络相连，都有自己独立的系统时钟，需要通过ntp实现两个系统时钟的时间同步
1.Device B作为服务器，Device A作为客户端，需要网络使本地时钟与服务器时钟同步，假设同步之前，Device A的时间是10:00:00am,Device B的时间是11:00:00am
2.NTP报文的Device A 和Device B 之间单向传输时间是1秒，
3.Device处理报文时间是1秒
Device A 与Devide B 工作流程如下
- Device A发送一个NTP请求报文给Devide B ，该报文带有Device A 离开时的时间戳，该时间戳为10:00:00am（T1）
- 当NTP报文到达Devide B 时，Devide B 加上自己的时间戳11:00:01am（T2）
- 当NTP报文离开Devide B 时，Devide B 再加上自己的时间戳11:00:02am（T3）
- 当Device A接受到NTP响应报文 时，Devide A本地时间11:00:02am（T4）
ntp工作原理介绍完了，现在应该很清楚原理了吧，现在回过头来继续。。
获取ntp时间：
public static long getTimeFromNtpServer(String hostAddress) {
MyLog.d(tag, "getTimeFromNtpServer()");
if (TextUtils.isEmpty(hostAddress)) {
MyLog.e(tag, "Ntp host is null.");
return -1;
}
if (mNtpClient == null) {
mNtpClient = new SntpClient();
}
boolean isSuccessful = mNtpClient.requestTime(hostAddress, 20000);
MyLog.d(tag, "requestTime:" + isSuccessful);
if (isSuccessful) {
long now = mNtpClient.getNtpTime();//now就是获取的时间
if (isInErrorCycle) {
if(!isTurnToSuccess){
isTurnToSuccess = true;
}
isInErrorCycle = false;
}
return now;
} else {
if (!isInErrorCycle) {
isInErrorCycle = true;
isTurnToSuccess = false;
mHandler.sendEmptyMessage(MSG_NTP_SEARCH_FAILED);
}
}
return -1;
}
接下来就是封装好的获取时间方法，获取原理如上，接下来就是原理的代码，可以配合原理来理解
public static class SntpClient {
private static final String TAG = "SntpClient";
private static final int REFERENCE_TIME_OFFSET = 16;
private static final int ORIGINATE_TIME_OFFSET = 24;
private static final int RECEIVE_TIME_OFFSET = 32;
private static final int TRANSMIT_TIME_OFFSET = 40;
private static final int NTP_PACKET_SIZE = 48;
private static final int NTP_PORT = 123;
private static final int NTP_MODE_CLIENT = 3;
private static final int NTP_VERSION = 3;
// Number of seconds between Jan 1, 1900 and Jan 1, 1970
// 70 years plus 17 leap days
private static final long OFFSET_1900_TO_1970 = ((365L * 70L) + 17L) * 24L * 60L * 60L;
// system time computed from NTP server response
private long mNtpTime;
// value of SystemClock.elapsedRealtime() corresponding to mNtpTime
private long mNtpTimeReference;
// round trip time in milliseconds
private long mRoundTripTime;
/**
* Sends an SNTP request to the given host and processes the response.
*
* @param host
* host name of the server.
* @param timeout
* network timeout in milliseconds.
* @return true if the transaction was successful.
*/
public boolean requestTime(String host, int timeout) {
DatagramSocket socket = null;
try {
socket = new DatagramSocket();
socket.setSoTimeout(timeout);
InetAddress address = InetAddress.getByName(host);
byte[] buffer = new byte[NTP_PACKET_SIZE];
DatagramPacket request = new DatagramPacket(buffer,
buffer.length, address, NTP_PORT);
// set mode = 3 (client) and version = 3
// mode is in low 3 bits of first byte
// version is in bits 3-5 of first byte
buffer[0] = NTP_MODE_CLIENT | (NTP_VERSION << 3);
// get current time and write it to the request packet
long requestTime = System.currentTimeMillis();
MyLog.d(TAG, "RequestTime:"+new Date(requestTime));
long requestTicks = SystemClock.elapsedRealtime();
writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET, requestTime);
socket.send(request);
// read the response
DatagramPacket response = new DatagramPacket(buffer,
buffer.length);
socket.receive(response);
long responseTicks = SystemClock.elapsedRealtime();
long responseTime = requestTime
+ (responseTicks - requestTicks);
// extract the results
long originateTime = readTimeStamp(buffer,
ORIGINATE_TIME_OFFSET);
long receiveTime = readTimeStamp(buffer, RECEIVE_TIME_OFFSET);
long transmitTime = readTimeStamp(buffer, TRANSMIT_TIME_OFFSET);
long roundTripTime = responseTicks - requestTicks
- (transmitTime - receiveTime);
// receiveTime = originateTime + transit + skew
// responseTime = transmitTime + transit - skew
// clockOffset = ((receiveTime - originateTime) + (transmitTime
// - responseTime))/2
// = ((originateTime + transit + skew - originateTime) +
// (transmitTime - (transmitTime + transit - skew)))/2
// = ((transit + skew) + (transmitTime - transmitTime - transit
// + skew))/2
// = (transit + skew - transit + skew)/2
// = (2 * skew)/2 = skew
long clockOffset = ((receiveTime - requestTime) + (transmitTime - System.currentTimeMillis())) / 2;
// if (false) Log.d(TAG, "round trip: " + roundTripTime +
// " ms");
// if (false) Log.d(TAG, "clock offset: " + clockOffset +
// " ms");
// save our results - use the times on this side of the network
// latency
// (response rather than request time)
mNtpTime = System.currentTimeMillis() + clockOffset;
// mNtpTime = transmitTime;
mNtpTimeReference = responseTicks;
mRoundTripTime = roundTripTime;
} catch (Exception e) {
if (false)
Log.d(TAG, "request time failed:" + e);
e.printStackTrace();
return false;
} finally {
if (socket != null) {
socket.close();
}
}
return true;
}
/**
* Returns the time computed from the NTP transaction.
*
* @return time value computed from NTP server response.
*/
public long getNtpTime() {
return mNtpTime;
}
/**
* Returns the reference clock value (value of
* SystemClock.elapsedRealtime()) corresponding to the NTP time.
*
* @return reference clock corresponding to the NTP time.
*/
public long getNtpTimeReference() {
return mNtpTimeReference;
}
/**
* Returns the round trip time of the NTP transaction
*
* @return round trip time in milliseconds.
*/
public long getRoundTripTime() {
return mRoundTripTime;
}
/**
* Reads an unsigned 32 bit big endian number from the given offset in
* the buffer.
*/
private long read32(byte[] buffer, int offset) {
byte b0 = buffer[offset];
byte b1 = buffer[offset + 1];
byte b2 = buffer[offset + 2];
byte b3 = buffer[offset + 3];
// convert signed bytes to unsigned values
int i0 = ((b0 & 0x80) == 0x80 ? (b0 & 0x7F) + 0x80 : b0);
int i1 = ((b1 & 0x80) == 0x80 ? (b1 & 0x7F) + 0x80 : b1);
int i2 = ((b2 & 0x80) == 0x80 ? (b2 & 0x7F) + 0x80 : b2);
int i3 = ((b3 & 0x80) == 0x80 ? (b3 & 0x7F) + 0x80 : b3);
return ((long) i0 << 24) + ((long) i1 << 16) + ((long) i2 << 8)
+ (long) i3;
}
/**
* Reads the NTP time stamp at the given offset in the buffer and
* returns it as a system time (milliseconds since January 1, 1970).
*/
private long readTimeStamp(byte[] buffer, int offset) {
long seconds = read32(buffer, offset);
long fraction = read32(buffer, offset + 4);
return ((seconds - OFFSET_1900_TO_1970) * 1000)
+ ((fraction * 1000L) / 0x100000000L);
}
/**
* Writes system time (milliseconds since January 1, 1970) as an NTP
* time stamp at the given offset in the buffer.
*/
private void writeTimeStamp(byte[] buffer, int offset, long time) {
long seconds = time / 1000L;
long milliseconds = time - seconds * 1000L;
seconds += OFFSET_1900_TO_1970;
// write seconds in big endian format
buffer[offset++] = (byte) (seconds >> 24);
buffer[offset++] = (byte) (seconds >> 16);
buffer[offset++] = (byte) (seconds >> 8);
buffer[offset++] = (byte) (seconds >> 0);
long fraction = milliseconds * 0x100000000L / 1000L;
// write fraction in big endian format
buffer[offset++] = (byte) (fraction >> 24);
buffer[offset++] = (byte) (fraction >> 16);
buffer[offset++] = (byte) (fraction >> 8);
// low order bits should be random data
buffer[offset++] = (byte) (Math.random() * 255.0);
}
}
以上就是从ntp服务器上同步系统时间，项目比较完整，有疑问大家提出来，互相学习，到此结束。