如何用AsyncTask修改代码从Google NTP服务器获取GMT时间及空值排查

Hey there! Let's tackle your NTP time questions and fix that AsyncTask code properly. I’ve worked with NTP implementations on Android before, so let’s break this down step by step.

First, don’t forget to add the INTERNET permission to your AndroidManifest.xml—this is non-negotiable for network requests:

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

Complete AsyncTask Code #

This task will fetch GMT time from Google’s NTP server (time.google.com) and let you convert it to local time easily:

import android.os.AsyncTask;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Date;
import java.util.TimeZone;

public class NtpTimeFetcher extends AsyncTask<Void, Void, Date> {
    // Google's public NTP server and default NTP port
    private static final String NTP_SERVER = "time.google.com";
    private static final int NTP_PORT = 123;
    private static final int NTP_PACKET_SIZE = 48;
    private static final long NTP_EPOCH_OFFSET = 2208988800L; // Seconds between 1900 (NTP epoch) and 1970 (Java epoch)

    // Callback to send results/errors to the UI thread
    private final NtpResultListener resultListener;

    public interface NtpResultListener {
        void onGmtTimeReceived(Date gmtTime);
        void onFetchFailed(Exception error);
    }

    public NtpTimeFetcher(NtpResultListener listener) {
        this.resultListener = listener;
    }

    @Override
    protected Date doInBackground(Void... params) {
        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket();
            socket.setSoTimeout(5000); // 5-second timeout to avoid hanging
            InetAddress serverAddress = InetAddress.getByName(NTP_SERVER);

            // Build NTP request packet (client mode)
            byte[] requestBuffer = new byte[NTP_PACKET_SIZE];
            requestBuffer[0] = (byte) 0b11100011; // Set LI, Version, and Mode fields

            // Send request
            DatagramPacket requestPacket = new DatagramPacket(requestBuffer, requestBuffer.length, serverAddress, NTP_PORT);
            socket.send(requestPacket);

            // Receive response
            DatagramPacket responsePacket = new DatagramPacket(requestBuffer, requestBuffer.length);
            socket.receive(responsePacket);

            // Parse the transmit timestamp from the response (starts at byte 40)
            long rawNtpTime = parseTransmitTimestamp(requestBuffer);
            if (rawNtpTime == 0) {
                return null;
            }

            // Convert NTP timestamp to Java Date (convert seconds to milliseconds)
            return new Date((rawNtpTime - NTP_EPOCH_OFFSET) * 1000);

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            if (socket != null && !socket.isClosed()) {
                socket.close();
            }
        }
    }

    @Override
    protected void onPostExecute(Date gmtTime) {
        super.onPostExecute(gmtTime);
        if (resultListener != null) {
            if (gmtTime != null) {
                resultListener.onGmtTimeReceived(gmtTime);
            } else {
                resultListener.onFetchFailed(new Exception("Failed to retrieve or parse NTP time"));
            }
        }
    }

    private long parseTransmitTimestamp(byte[] responseBuffer) {
        // Extract high and low 32-bit values from the timestamp bytes
        long highWord = ((responseBuffer[40] & 0xFF) << 24) |
                        ((responseBuffer[41] & 0xFF) << 16) |
                        ((responseBuffer[42] & 0xFF) << 8) |
                        (responseBuffer[43] & 0xFF);
        long lowWord = ((responseBuffer[44] & 0xFF) << 24) |
                       ((responseBuffer[45] & 0xFF) << 16) |
                       ((responseBuffer[46] & 0xFF) << 8) |
                       (responseBuffer[47] & 0xFF);
        return (highWord << 32) | lowWord;
    }
}

How to Use This in Your UI Code #

Call the AsyncTask from your Activity/Fragment to get both GMT and local time:

// In your Activity or Fragment
new NtpTimeFetcher(new NtpResultListener() {
    @Override
    public void onGmtTimeReceived(Date gmtTime) {
        // Get local time by adjusting GMT with your device's time zone offset
        Date localTime = new Date(gmtTime.getTime() + TimeZone.getDefault().getOffset(gmtTime.getTime()));

        // Format and display the times (use SimpleDateFormat for custom formatting)
        String formattedGmt = java.text.DateFormat.getDateTimeInstance().format(gmtTime);
        String formattedLocal = java.text.DateFormat.getDateTimeInstance().format(localTime);

        // Example: Update UI elements
        // textViewGmt.setText("GMT Time: " + formattedGmt);
        // textViewLocal.setText("Local Time: " + formattedLocal);
    }

    @Override
    public void onFetchFailed(Exception error) {
        // Handle errors (no network, server timeout, etc.)
        // Toast.makeText(getApplicationContext(), "Failed to get time: " + error.getMessage(), Toast.LENGTH_SHORT).show();
    }
}).execute();

The NTP server itself won’t "return null"—but your code may end up with a null result in these scenarios:

• No internet connection: The request can’t reach the server.
• Server timeout: If the server doesn’t respond within your set timeout (we used 5 seconds here).
• Network errors: DNS failures, firewall blocks, or server unavailability (rare for Google’s NTP servers, but possible).
• Malformed response: If the server sends an invalid NTP packet (extremely unlikely for trusted servers like Google’s).

That’s why we added the onFetchFailed callback—always handle these edge cases!

If your original code had problems, these are the most likely culprits:

• Missing INTERNET permission: Android blocks network requests without this.
• Running network code on the UI thread: Causes ANRs (Application Not Responding) crashes.
• Incorrect NTP timestamp parsing: Forgetting the 1900-1970 epoch offset, or reading the wrong bytes from the response.
• No timeout: The thread could hang indefinitely if the server doesn’t respond.
• Uncaught exceptions: Not handling IOExceptions or UnknownHostExceptions.

内容的提问来源于stack exchange，提问作者user9271543