Hoe synchroniseer je de lokale tijd van de gebruiker…

Voor nauwkeurige tijdsynchronisatie met de server op Android is het aan te raden het NTP-protocol (Network Time Protocol) te gebruiken. Android heeft ingebouwde mechanismen hiervoor, maar soms is het nodig om handmatig de tijd op te vragen of alternatieve benaderingen te gebruiken.

Ingebouwde synchronisatie van Android:

Het Android-systeem synchroniseert automatisch de tijd via NTP via netwerkdiensten, meestal met standaard NTP-servers. De gebruiker kan de optie "Gebruik netwerk tijd" kiezen in de instellingen. Deze methode is het meest betrouwbaar voor gewone scenario's.

Handmatige synchronisatie (voor speciale gevallen):

In sommige apps of op apparaten zonder netwerkverbinding kan het nodig zijn om handmatig de tijd op te vragen van een specifieke NTP-server. Hiervoor kunnen Apache Commons Net of andere bibliotheken voor NTP worden gebruikt.

Voorbeeld van gebruik van Apache Commons Net:

import org.apache.commons.net.ntp.NTPUDPClient;
import org.apache.commons.net.ntp.TimeInfo;
import java.io.IOException;
import java.net.InetAddress;

public class TimeSynchronizer {

    private static final String NTP_SERVER = "pool.ntp.org"; // Voorbeeld NTP-server

    public long getSynchronizedTime() {
        NTPUDPClient client = new NTPUDPClient();
        // Standaard socket timeout is 0, dus instellen
        client.setDefaultTimeout(10000); // 10 seconden

        try {
            // Vraag het adres van de NTP-server op
            InetAddress inetAddress = InetAddress.getByName(NTP_SERVER);
            // Vraag de tijdinformatie op
            TimeInfo timeInfo = client.getTime(inetAddress);

            // Verwerk de tijdinformatie
            long returnTime = timeInfo.getMessage().getTransmitTimeStamp().getTime();

            // Bereken het verschil tussen lokale en servertijd
            long localTime = System.currentTimeMillis();
            long networkTime = timeInfo.getReturnTime();
            long roundTripDelay = networkTime - timeInfo.getOriginateTimeStamp().getTime();
            long offset = timeInfo.getOffset();

            // Gecorrigeerde tijd is lokale tijd + offset
            long synchronizedTime = localTime + offset;

            return synchronizedTime;

        } catch (IOException e) {
            e.printStackTrace();
            // Bij fout, -1 teruggeven of uitzondering gooien
            return -1;
        } finally {
            client.close();
        }
    }
}

Synchronisatie via HTTP-verzoek (minder nauwkeurig):

Je kunt de tijd van de server krijgen door een HTTP-verzoek te sturen en de Date header in het antwoord te analyseren. Deze methode is minder nauwkeurig dan NTP, omdat het afhankelijk is van netwerkvertraging en de klok op de webserver.

Voorbeeld:

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Date;

public class HttpTimeSynchronizer {

    private static final String HTTP_URL = "https://www.google.com"; // Voorbeeld URL

    public long getSynchronizedTime() {
        try {
            URL url = new URL(HTTP_URL);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("HEAD"); // Alleen headers opvragen
            connection.connect();

            // Haal de Date header op
            String dateHeader = connection.getHeaderField("Date");
            if (dateHeader != null) {
                // Parse de datum uit de header. Dit formaat kan verschillen.
                Date date = new Date(dateHeader);
                return date.getTime();
            } else {
                return -1; // "Date" header ontbreekt
            }

        } catch (IOException e) {
            e.printStackTrace();
            return -1; // Fout bij verzoek
        }
    }
}

Aanbevelingen:

Vertrouw voor de meeste gevallen op de ingebouwde synchronisatie van Android.
Gebruik Apache Commons Net of vergelijkbare bibliotheken als hogere precisie of controle over de NTP-server nodig is.
Synchronisatie via HTTP is minder nauwkeurig en wordt niet aanbevolen voor kritische operaties die afhankelijk zijn van exacte tijd.
Bij handmatige synchronisatie, handel netwerkfouten en onjuiste serverantwoorden af.
Voer synchronisatie uit in een achtergrondthread om de UI niet te blokkeren.

Hoe synchroniseer je de lokale tijd van de gebruiker met de servertijd?