Óra szinkronizáció alkalmazásokban — lényeg, protokollok és megvalósítás

Mi az óra szinkronizáció?

Óra szinkronizáció (Clock Sync) — az eszköz belső órájának etalon UTC (Universal Coordinated Time) időhöz igazításának mechanizmusa. Szinkronizáció nélkül a mobil eszköz kvarc oszcillátora fokozatosan eltér — a drift napi 1–10 másodperc a hőmérséklettől és az alkatrészek minőségétől függően. A szinkronizáció kompenzálja ezt a driftet azáltal, hogy pontos időt szerez külső forrásokból: NTP szerverekről az interneten, GPS műholdakról vagy mobil bázisállomásokról. Ideális esetben az eszköznek 4–6 óránként kellene szinkronizálnia az 1 másodpercen belüli pontosság fenntartásához.

Hardveres és szoftveres óra

A mobil eszközben kétféle óra létezik: hardveres (RTC, Real-Time Clock) külön elemellátással — még kikapcsolt állapotban is működik, és szoftveres (system time), amelyet az operációs rendszer kezel. Az eszköz indulásakor a rendszeridő az RTC-ből inicializálódik, majd az órajel-generátor megszakításain keresztül tartódik fenn. Az NTP szinkronizáció korrigálja a rendszeridőt, és bizonyos esetekben a korrekciót az RTC-be is beírja. Androidon a hardveres RTC-hez való hozzáférés korlátozott — az alkalmazások root jogosultság nélkül nem módosíthatják.

Miért van szükség idő szinkronizációra a mobil alkalmazásokban

A mobil alkalmazás működésének számos aspektusa kritikusan függ a pontos rendszeridőtől. Az SSL tanúsítványok érvényességi idővel rendelkeznek: ha az eszközön az idő a tanúsítvány kiállításának dátuma előtt vagy a lejárati dátum után van beállítva, a HTTPS kapcsolat blokkolva lesz. Az OAuth tokenek és a JWT hitelesítés időbélyegeket használ az érvényesség ellenőrzéséhez — az eltérés hamis engedélyezési elutasításokhoz vezet. A push értesítések idő alapján vannak ütemezve, és ha az óra eltér, a felhasználó rossz időpontban kap értesítéseket vagy egyáltalán nem kap.

Az eltérés következményei

Az alkalmazások biztonsága is szenved a helytelen idő miatt: időalapú titkosítás (time-based OTP), helytelen időbélyegzővel ellátott eseménynaplók, a rate-limiting hibás működése a szerver oldalán (a szerver blokkolja a „jövőbeli” kéréseket). Az OWASP Mobile Top 10 (2024) szerint a rendszeridőbe vetett bizalom hiánya a platform elégtelen biztonságának kategóriájába tartozik. A fejlesztőknek ajánlott mindig a szerveren ellenőrizni az időt, nem kizárólag az ügyfél órájára hagyatkozni. Ha az eltérés meghaladja a küszöbértéket (ajánlott 5 másodperc), az alkalmazásnak blokkolnia kell a kritikus műveleteket a szinkronizációig.

Szinkronizációs protokollok: NTP és SNTP

Az óra szinkronizáció fő protokolljai — NTP és annak egyszerűsített változata, az SNTP. Az NTP (RFC 5905) — teljes protokoll szerver szűréssel, drift elemzéssel és PLL korrekcióval. Szervereken és hálózati berendezéseken használják. Az SNTP (RFC 4330) — könnyű verzió kliens eszközökhöz, nem igényel folyamatos szinkronizációt. Az SNTP kliens elküld egy kérést, megkapja a választ, és beállítja az időt az előzmények elemzése nélkül. Mobil eszközökön pontosan SNTP-t használnak — a beépített Android Google Time Service (GTS) SNTP-n keresztül szinkronizál a time.google.com szerverekkel.

További szinkronizációs módszerek

Az NTP/SNTP mellett az idő szinkronizáció mobil eszközökön lehetséges GPS vevőn (akár 10 ns pontosság ideális körülmények között) és mobilhálózaton (NITZ — Network Identity and Time Zone) keresztül. A GPS maximális pontosságot biztosít, de csak szabad téren működik és sok energiát fogyaszt. Az NITZ-t a mobilszolgáltató automatikusan biztosítja a hálózatba való regisztrációkor, de nem minden szolgáltató támogatja. Az Android az összes módszer kombinációját használja: GTS (SNTP) elsőbbséggel, NITZ tartalékként, és GPS a nagy pontosságot igénylő alkalmazások számára.

Szinkronizációs problémák elosztott rendszerekben

Az elosztott rendszerekben — amikor a szerver és a kliens különböző eszközökön található — az óra szinkronizáció alapvető korlátokba ütközik. A hálózati késleltetés (latency) lehetetlenné teszi a pontos idő egyértelmű meghatározását a kliensen: ha a csomag 200 ms-ig tartott, a szerver ideje a kérés elküldésének és a válasz fogadásának pillanatában már eltérő. Az NTP ezt a problémát RTT méréssel és statisztikai feldolgozással oldja meg, de elosztott tranzakciókhoz (pl. banki átutalások) ez nem elegendő — logikai órákat (Lamport időbélyegek) vagy vektorórákat használnak.

Fizikai vs. logikai órák

Fizikai órák (wall clock) — a valós UTC idő, amely NTP-n keresztül szinkronizálódik. Logikai órák — az események sorszáma a rendszerben, nem kapcsolódnak a fizikai időhöz. Az elosztott rendszerekben az események sorrendezéséhez gyakran használnak vektorórákat: minden csomópont tárol egy számlálóvektort a klaszter összes csomópontjához. Mobil alkalmazásokhoz elegendő a fizikai szinkronizáció 1–5 másodperces pontossággal — ez biztosítja az OAuth, SSL és push értesítések helyes működését. Ha az események szigorú sorrendezése szükséges (pl. valós idejű csevegésben), logikai szinkronizáció kerül hozzáadásra a szerver szintjén.

Óra szinkronizáció megvalósítása Androidban

Az óra szinkronizáció megvalósítása Android alkalmazásban többféleképpen történhet. A legegyszerűbb — a szerveridő lekérése REST API-n keresztül: a szerver Unix Timestamp-ot ad vissza a válasz törzsében vagy a HTTP Date fejlécben. Ez a megközelítés nem igényel további könyvtárakat, és garantálja, hogy az idő megegyezik a szerverével. A második módszer — SNTP kliens használata közvetlen NTP szerver lekérdezéshez. A harmadik — az Android Google Time Service-re hagyatkozni, amely automatikusan szinkronizálja a rendszeridőt, ha az eszköz csatlakozik az internethez.

Megközelítések összehasonlítása Androidra

Az autorizációval és pénzügyi műveletekkel rendelkező Android alkalmazásokban kombinált megközelítés ajánlott: minden API kérésnél elmentésre kerül a szerveridő és a System.currentTimeMillis() közötti különbség. Ez a különbség az összes időszámításra vonatkozik a kliens oldalon, függetlenül attól, hogy a rendszeróra szinkronizálva van-e. Ezt a megközelítést clock skew correction-nek nevezik, és egy olyan osztály segítségével valósítják meg, amely tárolja a szerverrel való utolsó ismert különbséget. Ezenkívül háttér NTP szinkronizáció is indítható 4–6 óránként a WorkManager segítségével.

// Az óraeltérés korrekciója
class ClockSyncManager {
    private var serverTimeDiff: Long = 0 // serverTime - deviceTime (ms)

    fun updateServerTime(serverTimestampMs: Long) {
        serverTimeDiff = serverTimestampMs - System.currentTimeMillis()
    }

    fun getCorrectedTime(): Long {
        return System.currentTimeMillis() + serverTimeDiff
    }

    fun isSyncValid(maxDiffMs: Long = 5000): Boolean {
        return Math.abs(serverTimeDiff) < maxDiffMs
    }
}

Háttér szinkronizáció WorkManager segítségével

Az idő periodikus háttér szinkronizációjához Androidon használja a WorkManager-t PeriodicWorkRequest segítségével. A szinkronizációs feladat végrehajt egy SNTP lekérdezést vagy REST API hívást, megkapja a szerveridőt és frissíti a ClockSyncManager-t. A PeriodicWorkRequest minimális időköze 15 perc, de az idő szinkronizációhoz 4–6 óra elegendő. A szinkronizáció során vegye figyelembe a hálózati állapotot — használja a NetworkType.CONNECTED-et a felesleges kérések elkerüléséhez roaming esetén. Ha a szinkronizáció sikertelen, őrizze meg az előző korrekciót — az érvényes marad, fokozatosan csökkenő pontossággal.

Automatikus idő szinkronizáció eszközökön

A modern mobil eszközök automatikusan szinkronizálják az időt beépített szolgáltatásokon keresztül. Androidon — Google Time Service (GTS), a Google Play Services része. iOS-en — az operációs rendszerbe épített NTP kliens. Ezek a szolgáltatások az alkalmazásoktól függetlenül működnek, és nem igényelnek további konfigurációt. A felhasználó kikapcsolhatja az automatikus szinkronizációt a beállításokban, ami kockázatot jelent az alkalmazások számára — ebben az esetben a fejlesztőnek kell saját szinkronizációt megvalósítania. Javasolt az autoszinkronizáció állapotának ellenőrzése a Settings.Global.getInt(AUTO_TIME) segítségével, és a felhasználó figyelmeztetése, ha az ki van kapcsolva.

Ajánlások fejlesztőknek

Kizárólag az automatikus szinkronizációra hagyatkozni kockázatos — a felhasználó kikapcsolhatja vagy internet nélküli területen tartózkodhat. Legjobb gyakorlat — minden API kérésnél szerezze be az időt a szerverről, és tárolja az eltérést SharedPreferences vagy DataStore segítségével. Kritikus műveletekhez (fizetés, hitelesítés, dokumentum aláírás) mindig ellenőrizze az isSyncValid()-t a végrehajtás előtt. Ha az eltérés meghaladja a küszöbértéket — jelenítsen meg a felhasználónak egy képernyőt az autoszinkronizáció bekapcsolásának vagy a szinkronizáció megvárásának javaslatával. Játékok és szórakoztató alkalmazások esetén elegendő az időt a szerverről az indításkor beszerezni és óránként frissíteni.