安卓怎么同步服务器时间？

在安卓中同步服务器时间有多种方法，我来为你详细介绍几种常见的方案：

1. 使用 HTTP 请求获取服务器时间

public class TimeSyncUtils {
    
    public static long getServerTime(String url) {
        try {
            URL serverUrl = new URL(url);
            HttpURLConnection connection = (HttpURLConnection) serverUrl.openConnection();
            connection.setRequestMethod("HEAD");
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(5000);
            
            long serverTime = connection.getDate();
            connection.disconnect();
            
            return serverTime;
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }
    
    // 使用示例
    public static void syncTime() {
        long serverTime = getServerTime("https://your-server.com/api");
        if (serverTime > 0) {
            long deviceTime = System.currentTimeMillis();
            long timeDiff = serverTime - deviceTime;
            
            // 保存时间差，在应用中使用
            SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
            prefs.edit().putLong("time_offset", timeDiff).apply();
        }
    }
    
    // 获取校准后的时间
    public static long getAdjustedTime() {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
        long offset = prefs.getLong("time_offset", 0);
        return System.currentTimeMillis() + offset;
    }
}

2. 使用 NTP 协议同步时间（推荐）

添加依赖：

implementation 'commons-net:commons-net:3.8.0'

import org.apache.commons.net.ntp.NTPUDPClient;
import org.apache.commons.net.ntp.TimeInfo;
public class NTPTimeSync {
    
    public static long getNTPTime() {
        NTPUDPClient client = new NTPUDPClient();
        client.setDefaultTimeout(10000);
        
        try {
            client.open();
            InetAddress hostAddr = InetAddress.getByName("pool.ntp.org");
            TimeInfo info = client.getTime(hostAddr);
            info.computeDetails();
            
            Long offset = info.getOffset();
            Long delay = info.getDelay();
            
            if (offset != null) {
                return System.currentTimeMillis() + offset;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.close();
        }
        return -1;
    }
}

3. 使用 SNTP 客户端

import android.os.SystemClock;
public class SntpClient {
    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;
    
    public boolean requestTime(String host, int timeout) {
        try {
            DatagramSocket 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);
            
            buffer[0] = (NTP_MODE_CLIENT | (NTP_VERSION << 3));
            
            long requestTime = System.currentTimeMillis();
            long requestTicks = SystemClock.elapsedRealtime();
            writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET, requestTime);
            
            socket.send(request);
            
            DatagramPacket response = new DatagramPacket(buffer, buffer.length);
            socket.receive(response);
            long responseTicks = SystemClock.elapsedRealtime();
            long responseTime = requestTime + (responseTicks - requestTicks);
            
            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);
            long clockOffset = ((receiveTime - originateTime) + (transmitTime - responseTime)) / 2;
            
            // 保存时间偏移量
            saveTimeOffset(clockOffset);
            socket.close();
            return true;
            
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    
    private long readTimeStamp(byte[] buffer, int offset) {
        long seconds = read32(buffer, offset);
        long fraction = read32(buffer, offset + 4);
        return ((seconds - 2208988800L) * 1000) + ((fraction * 1000L) / 0x100000000L);
    }
    
    private void writeTimeStamp(byte[] buffer, int offset, long time) {
        long seconds = time / 1000L + 2208988800L;
        long fraction = ((time % 1000L) * 0x100000000L) / 1000L;
        write32(buffer, offset, (int) seconds);
        write32(buffer, offset + 4, (int) fraction);
    }
    
    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];
        
        return ((b0 & 0xFF) << 24) | ((b1 & 0xFF) << 16) | 
               ((b2 & 0xFF) << 8) | (b3 & 0xFF);
    }
    
    private void write32(byte[] buffer, int offset, int value) {
        buffer[offset] = (byte) ((value >> 24) & 0xff);
        buffer[offset + 1] = (byte) ((value >> 16) & 0xff);
        buffer[offset + 2] = (byte) ((value >> 8) & 0xff);
        buffer[offset + 3] = (byte) (value & 0xff);
    }
    
    private void saveTimeOffset(long offset) {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
        prefs.edit().putLong("ntp_time_offset", offset).apply();
    }
}

4. 定期同步的 Service

public class TimeSyncService extends Service {
    private static final long SYNC_INTERVAL = 30 * 60 * 1000; // 30分钟
    
    private Handler handler = new Handler();
    private Runnable syncRunnable = new Runnable() {
        @Override
        public void run() {
            syncTimeWithServer();
            handler.postDelayed(this, SYNC_INTERVAL);
        }
    };
    
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        handler.post(syncRunnable);
        return START_STICKY;
    }
    
    private void syncTimeWithServer() {
        // 使用上述任意方法同步时间
        long serverTime = NTPTimeSync.getNTPTime();
        if (serverTime > 0) {
            // 保存时间偏移或直接使用
            SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
            prefs.edit().putLong("last_sync_time", System.currentTimeMillis())
                       .putLong("time_offset", serverTime - System.currentTimeMillis())
                       .apply();
        }
    }
    
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

5. 常用 NTP 服务器地址

public class NtpServers {
    public static final String[] SERVERS = {
        "pool.ntp.org",
        "time.google.com",
        "time.apple.com",
        "time.windows.com",
        "cn.pool.ntp.org",  // 中国地区
        "ntp.aliyun.com"    // 阿里云
    };
}

注意事项：

1、权限要求：需要网络权限

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

2、时间校准：普通应用无法修改系统时间，只能记录偏移量在应用内使用

3、网络延迟：需要考虑网络延迟对时间同步精度的影响

4、定期同步：建议定期同步以保持时间准确性

选择哪种方法取决于你的具体需求：如果只需要相对时间，HTTP 方法足够；如果需要高精度时间，推荐使用 NTP 协议。

文章摘自：https://idc.huochengrm.cn/fwq/16753.html