Android 通過NTP服務器自動獲取時間的方法

對於手機，如果有SIM卡支持的話，在設置時間時可以通過選擇自動從網絡獲取時間來取得當地的時間和時區：

但如果手機沒有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.      * Sends an SNTP request to the given host and processes the response. 
46.      * 
47.      * @param host 
48.      *            host name of the server. 
49.      * @param timeout 
50.      *            network timeout in milliseconds. 
51.      * @return true if the transaction was successful. 
52.      */  
53.     public boolean requestTime(String host, int timeout) {  
54.         try {  
55.             DatagramSocket socket = new DatagramSocket();  
56.             socket.setSoTimeout(timeout);  
57.             InetAddress address = InetAddress.getByName(host);  
58.             byte[] buffer = new byte[NTP_PACKET_SIZE];  
59.             DatagramPacket request = new DatagramPacket(buffer, buffer.length,  
60.                     address, NTP_PORT);  
61.    
62.             // set mode = 3 (client) and version = 3   
63.             // mode is in low 3 bits of first byte   
64.             // version is in bits 3-5 of first byte   
65.             buffer[0] = NTP_MODE_CLIENT | (NTP_VERSION << 3);  
66.    
67.             // get current time and write it to the request packet   
68.             long requestTime = System.currentTimeMillis();  
69.             long requestTicks = System.nanoTime() / 1000;  
70.             writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET, requestTime);  
71.    
72.             socket.send(request);  
73.    
74.             // read the response   
75.             DatagramPacket response = new DatagramPacket(buffer, buffer.length);  
76.             socket.receive(response);  
77.             long responseTicks = System.nanoTime() / 1000;  
78.             long responseTime = requestTime + (responseTicks - requestTicks);  
79.             socket.close();  
80.    
81.             // extract the results   
82.             long originateTime = readTimeStamp(buffer, ORIGINATE_TIME_OFFSET);  
83.             long receiveTime = readTimeStamp(buffer, RECEIVE_TIME_OFFSET);  
84.             long transmitTime = readTimeStamp(buffer, TRANSMIT_TIME_OFFSET);  
85.             long roundTripTime = responseTicks - requestTicks  
86.                     - (transmitTime - receiveTime);  
87.             // receiveTime = originateTime + transit + skew   
88.             // responseTime = transmitTime + transit - skew   
89.             // clockOffset = ((receiveTime - originateTime) + (transmitTime -   
90.             // responseTime))/2   
91.             // = ((originateTime + transit + skew - originateTime) +   
92.             // (transmitTime - (transmitTime + transit - skew)))/2   
93.             // = ((transit + skew) + (transmitTime - transmitTime - transit +   
94.             // skew))/2   
95.             // = (transit + skew - transit + skew)/2   
96.             // = (2 * skew)/2 = skew   
97.             long clockOffset = ((receiveTime - originateTime) + (transmitTime - responseTime)) / 2;  
98.             // if (Config.LOGD) Log.d(TAG, "round trip: " + roundTripTime +   
99.             // " ms");   
100.             // if (Config.LOGD) Log.d(TAG, "clock offset: " + clockOffset +   
101.             // " ms");   
102.    
103.             // save our results - use the times on this side of the network   
104.             // latency   
105.             // (response rather than request time)   
106.             mNtpTime = responseTime + clockOffset;  
107.             mNtpTimeReference = responseTicks;  
108.             mRoundTripTime = roundTripTime;  
109.         } catch (Exception e) {  
110.    
111.             return false;  
112.         }  
113.    
114.         return true;  
115.     }  
116.    
117.     /** 
118.      * Returns the time computed from the NTP transaction. 
119.      * 
120.      * @return time value computed from NTP server response. 
121.      */  
122.     public long getNtpTime() {  
123.         return mNtpTime;  
124.     }  
125.    
126.     /** 
127.      * Returns the reference clock value (value of 
128.      * SystemClock.elapsedRealtime()) corresponding to the NTP time. 
129.      * 
130.      * @return reference clock corresponding to the NTP time. 
131.      */  
132.     public long getNtpTimeReference() {  
133.         return mNtpTimeReference;  
134.     }  
135.    
136.     /** 
137.      * Returns the round trip time of the NTP transaction 
138.      * 
139.      * @return round trip time in milliseconds. 
140.      */  
141.     public long getRoundTripTime() {  
142.         return mRoundTripTime;  
143.     }  
144.    
145.     /** 
146.      * Reads an unsigned 32 bit big endian number from the given offset in the 
147.      * buffer. 
148.      */  
149.     private long read32(byte[] buffer, int offset) {  
150.         byte b0 = buffer[offset];  
151.         byte b1 = buffer[offset + 1];  
152.         byte b2 = buffer[offset + 2];  
153.         byte b3 = buffer[offset + 3];  
154.    
155.         // convert signed bytes to unsigned values   
156.         int i0 = ((b0 & 0x80) == 0x80 ? (b0 & 0x7F) + 0x80 : b0);  
157.         int i1 = ((b1 & 0x80) == 0x80 ? (b1 & 0x7F) + 0x80 : b1);  
158.         int i2 = ((b2 & 0x80) == 0x80 ? (b2 & 0x7F) + 0x80 : b2);  
159.         int i3 = ((b3 & 0x80) == 0x80 ? (b3 & 0x7F) + 0x80 : b3);  
160.    
161.         return ((long) i0 << 24) + ((long) i1 << 16) + ((long) i2 << <img class="wp-smiley" alt="8)" src="http://www.imobilebbs.com/wordpress/wp-includes/images/smilies/icon_cool.gif">  
162.                 + (long) i3;  
163.     }  
164.    
165.     /** 
166.      * Reads the NTP time stamp at the given offset in the buffer and returns it 
167.      * as a system time (milliseconds since January 1, 1970). 
168.      */  
169.     private long readTimeStamp(byte[] buffer, int offset) {  
170.         long seconds = read32(buffer, offset);  
171.         long fraction = read32(buffer, offset + 4);  
172.         return ((seconds - OFFSET_1900_TO_1970) * 1000)  
173.                 + ((fraction * 1000L) / 0x100000000L);  
174.     }  
175.    
176.     /** 
177.      * Writes system time (milliseconds since January 1, 1970) as an NTP time 
178.      * stamp at the given offset in the buffer. 
179.      */  
180.     private void writeTimeStamp(byte[] buffer, int offset, long time) {  
181.         long seconds = time / 1000L;  
182.         long milliseconds = time - seconds * 1000L;  
183.         seconds += OFFSET_1900_TO_1970;  
184.    
185.         // write seconds in big endian format   
186.         buffer[offset++] = (byte) (seconds >> 24);  
187.         buffer[offset++] = (byte) (seconds >> 16);  
188.         buffer[offset++] = (byte) (seconds >> 8);  
189.         buffer[offset++] = (byte) (seconds >> 0);  
190.    
191.         long fraction = milliseconds * 0x100000000L / 1000L;  
192.         // write fraction in big endian format   
193.         buffer[offset++] = (byte) (fraction >> 24);  
194.         buffer[offset++] = (byte) (fraction >> 16);  
195.         buffer[offset++] = (byte) (fraction >> 8);  
196.         // low order bits should be random data   
197.         buffer[offset++] = (byte) (Math.random() * 255.0);  
198.     }  
199. }  

運行這個Java應用，可以得到當前GMT時間，如：Sat Jun 16 10:52:19 BST 2012

更多Android相關信息見Android 專題頁面 http://www.linuxidc.com/topicnews.aspx?tid=11