Android 通过NTP服务器自动获取时间的方法

但如果手机没有SIM卡，此时如果有Wifi链接，手机依然可以通过网络自动获取时间（时区此时需要手动设置）。 查看Android源码，在android.net 中有 SntpClient类，可以通过访问NTP服务器来取得当前的GMT时间。pool.ntp.org为最常用的一个NTF服务器。修改SntpClient代码，你也可以在自己的应用（包括非Android应用）中通过NTP服务器来取得当前GMT时间，代码如下：

1. import java.net.DatagramPacket;  
2. import java.net.DatagramSocket;  
3. import java.net.InetAddress;  
4. import java.util.Date;  
5.    
6. public class GetTime {  
7.    
8.     public static void main(String[] args) {  
9.         SntpClient client = new SntpClient();  
10.         if (client.requestTime("pool.ntp.org", 30000)) {  
11.             long now = client.getNtpTime() + System.nanoTime() / 1000  
12.                     - client.getNtpTimeReference();  
13.             Date current = new Date(now);  
14.             System.out.println(current.toString());  
15.         }  
16.    
17.     }  
18. }  
19.    
20. class SntpClient {  
21.    
22.     private static final int ORIGINATE_TIME_OFFSET = 24;  
23.     private static final int RECEIVE_TIME_OFFSET = 32;  
24.     private static final int TRANSMIT_TIME_OFFSET = 40;  
25.     private static final int NTP_PACKET_SIZE = 48;  
26.    
27.     private static final int NTP_PORT = 123;  
28.     private static final int NTP_MODE_CLIENT = 3;  
29.     private static final int NTP_VERSION = 3;  
30.    
31.     // Number of seconds between Jan 1, 1900 and Jan 1, 1970   
32.     // 70 years plus 17 leap days   
33.     private static final long OFFSET_1900_TO_1970 = ((365L * 70L) + 17L) * 24L * 60L * 60L;  
34.    
35.     // system time computed from NTP server response   
36.     private long mNtpTime;  
37.    
38.     // value of SystemClock.elapsedRealtime() corresponding to mNtpTime   
39.     private long mNtpTimeReference;  
40.    
41.     // round trip time in milliseconds   
42.     private long mRoundTripTime;  
43.    
44.       
45.     public boolean requestTime(String host, int timeout) {  
46.         try {  
47.             DatagramSocket socket = new DatagramSocket();  
48.             socket.setSoTimeout(timeout);  
49.             InetAddress address = InetAddress.getByName(host);  
50.             byte[] buffer = new byte[NTP_PACKET_SIZE];  
51.             DatagramPacket request = new DatagramPacket(buffer, buffer.length,  
52.                     address, NTP_PORT);  
53.    
54.             // set mode = 3 (client) and version = 3   
55.             // mode is in low 3 bits of first byte   
56.             // version is in bits 3-5 of first byte   
57.             buffer[0] = NTP_MODE_CLIENT | (NTP_VERSION << 3);  
58.    
59.             // get current time and write it to the request packet   
60.             long requestTime = System.currentTimeMillis();  
61.             long requestTicks = System.nanoTime() / 1000;  
62.             writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET, requestTime);  
63.    
64.             socket.send(request);  
65.    
66.             // read the response   
67.             DatagramPacket response = new DatagramPacket(buffer, buffer.length);  
68.             socket.receive(response);  
69.             long responseTicks = System.nanoTime() / 1000;  
70.             long responseTime = requestTime + (responseTicks - requestTicks);  
71.             socket.close();  
72.    
73.             // extract the results   
74.             long originateTime = readTimeStamp(buffer, ORIGINATE_TIME_OFFSET);  
75.             long receiveTime = readTimeStamp(buffer, RECEIVE_TIME_OFFSET);  
76.             long transmitTime = readTimeStamp(buffer, TRANSMIT_TIME_OFFSET);  
77.             long roundTripTime = responseTicks - requestTicks  
78.                     - (transmitTime - receiveTime);  
79.             // receiveTime = originateTime + transit + skew   
80.             // responseTime = transmitTime + transit - skew   
81.             // clockOffset = ((receiveTime - originateTime) + (transmitTime -   
82.             // responseTime))/2   
83.             // = ((originateTime + transit + skew - originateTime) +   
84.             // (transmitTime - (transmitTime + transit - skew)))/2   
85.             // = ((transit + skew) + (transmitTime - transmitTime - transit +   
86.             // skew))/2   
87.             // = (transit + skew - transit + skew)/2   
88.             // = (2 * skew)/2 = skew   
89.             long clockOffset = ((receiveTime - originateTime) + (transmitTime - responseTime)) / 2;  
90.             // if (Config.LOGD) Log.d(TAG, "round trip: " + roundTripTime +   
91.             // " ms");   
92.             // if (Config.LOGD) Log.d(TAG, "clock offset: " + clockOffset +   
93.             // " ms");   
94.    
95.             // save our results - use the times on this side of the network   
96.             // latency   
97.             // (response rather than request time)   
98.             mNtpTime = responseTime + clockOffset;  
99.             mNtpTimeReference = responseTicks;  
100.             mRoundTripTime = roundTripTime;  
101.         } catch (Exception e) {  
102.    
103.             return false;  
104.         }  
105.    
106.         return true;  
107.     }  
108.    
109.       
110.     public long getNtpTime() {  
111.         return mNtpTime;  
112.     }  
113.    
114.       
115.     public long getNtpTimeReference() {  
116.         return mNtpTimeReference;  
117.     }  
118.    
119.       
120.     public long getRoundTripTime() {  
121.         return mRoundTripTime;  
122.     }  
123.    
124.       
125.     private long read32(byte[] buffer, int offset) {  
126.         byte b0 = buffer[offset];  
127.         byte b1 = buffer[offset + 1];  
128.         byte b2 = buffer[offset + 2];  
129.         byte b3 = buffer[offset + 3];  
130.    
131.         // convert signed bytes to unsigned values   
132.         int i0 = ((b0 & 0x80) == 0x80 ? (b0 & 0x7F) + 0x80 : b0);  
133.         int i1 = ((b1 & 0x80) == 0x80 ? (b1 & 0x7F) + 0x80 : b1);  
134.         int i2 = ((b2 & 0x80) == 0x80 ? (b2 & 0x7F) + 0x80 : b2);  
135.         int i3 = ((b3 & 0x80) == 0x80 ? (b3 & 0x7F) + 0x80 : b3);  
136.    
137.         return ((long) i0 << 24) + ((long) i1 << 16) + ((long) i2 << class="wp-smiley" alt="8)" src="http://www.imobilebbs.com/wordpress/wp-includes/images/smilies/icon_cool.gif">  
138.                 + (long) i3;  
139.     }  
140.    
141.       
142.     private long readTimeStamp(byte[] buffer, int offset) {  
143.         long seconds = read32(buffer, offset);  
144.         long fraction = read32(buffer, offset + 4);  
145.         return ((seconds - OFFSET_1900_TO_1970) * 1000)  
146.                 + ((fraction * 1000L) / 0x100000000L);  
147.     }  
148.    
149.       
150.     private void writeTimeStamp(byte[] buffer, int offset, long time) {  
151.         long seconds = time / 1000L;  
152.         long milliseconds = time - seconds * 1000L;  
153.         seconds += OFFSET_1900_TO_1970;  
154.    
155.         // write seconds in big endian format   
156.         buffer[offset++] = (byte) (seconds >> 24);  
157.         buffer[offset++] = (byte) (seconds >> 16);  
158.         buffer[offset++] = (byte) (seconds >> 8);  
159.         buffer[offset++] = (byte) (seconds >> 0);  
160.    
161.         long fraction = milliseconds * 0x100000000L / 1000L;  
162.         // write fraction in big endian format   
163.         buffer[offset++] = (byte) (fraction >> 24);  
164.         buffer[offset++] = (byte) (fraction >> 16);  
165.         buffer[offset++] = (byte) (fraction >> 8);  
166.         // low order bits should be random data   
167.         buffer[offset++] = (byte) (Math.random() * 255.0);  
168.     }  
169. }  

运行这个Java应用，可以得到当前GMT时间，如：Sat Jun 16 10:52:19 BST 2012