Petsa at Oras sa Mobile Development: Ano Ito, Anong mga Format at Paano Gumawa

May-akda: IT Sectr Nai-publish: 2026-07-22 Oras ng pagbabasa: 11 min

Petsa at oras sa mobile development — isa sa mga pangunahing paksa sa mobile engineering. Gumagamit ang iOS ng DateFormatter at ISO8601DateFormatter, gumagamit ang Android ng DateTimeFormatter at LocalDate mula sa java.time. Ayon sa Android Developer Docs, ang tamang pagpili ng mobile API para sa pag-format ng petsa at oras ay direktang nakakaapekto sa pagganap at tamang pagpapakita sa iba't ibang time zone.

Mga Pangunahing Punto

  • DateFormatter sa iOS — makapangyarihan, ngunit mabagal kapag madalas ginagawa. I-cache ang mga instance o gumamit ng ISO8601DateFormatter para sa ISO 8601 na format.
  • DateTimeFormatter sa Android — thread-safe na tagapag-format mula sa java.time. Pumalit sa hindi na ginagamit na SimpleDateFormat simula API 26.
  • ThreeTenABP — backport ng java.time para sa Android API na mas mababa sa 26. Nagdaragdag ng LocalDate, ZonedDateTime at DateTimeFormatter sa mga lumang device.
  • TimeZone — kritikal para sa conversion ng UTC sa lokal na oras. Itago ang oras sa UTC, ipakita sa time zone ng user.
  • Unix Timestamp — karaniwang format ng pag-iimbak ng oras. Ang pag-sync sa pamamagitan ng NTP ay ginagarantiyahan ang katumpakan hanggang millisecond.

Petsa at Oras sa iOS: DateFormatter at ISO8601DateFormatter

Sa iOS, ang petsa at oras ay tradisyonal na nai-format sa pamamagitan ng DateFormatter mula sa Foundation. Ang klaseng ito ay nagko-convert ng Date sa string at pabalik gamit ang isang tinukoy na pattern, locale at time zone. Ang pangunahing problema ng DateFormatter — hindi ito thread-safe at mabagal na ginagawa, kaya sa mobile code, ang mga instance ay dapat i-cache. Ang petsa sa mobile development sa iOS ay nangangailangan ng tamang tagapag-format.

DateFormatter at Pagganap

Ang paggawa ng DateFormatter ay tumatagal ng halos 1 millisecond dahil sa pag-parse ng dateFormat pattern, pag-load ng locale at pagtukoy ng time zone. Kapag nag-format ng listahan ng daan-daang petsa, ang paulit-ulit na paggawa ay humahantong sa kapansin-pansing lag sa UI. Ang solusyon — gawin ang tagapag-format nang isang beses para sa buong screen at gamitin muli. Para sa multi-threaded na access, gumamit ng pag-sync sa pamamagitan ng DispatchQueue.

swift
import Foundation

// Naka-cache na DateFormatter — ginagawa nang isang beses
private let dateFormatter: DateFormatter = {
    let formatter = DateFormatter()
    formatter.dateFormat = "dd.MM.yyyy HH:mm"
    formatter.locale = Locale(identifier: "ru_RU")
    formatter.timeZone = TimeZone(identifier: "Europe/Moscow")
    return formatter
}()

// ISO8601DateFormatter — magaan na alternatibo
private let isoFormatter: ISO8601DateFormatter = {
    let formatter = ISO8601DateFormatter()
    formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
    return formatter
}()

let now = Date()
let formattedDate = dateFormatter.string(from: now)
// "01.07.2026 14:30"
let isoDate = isoFormatter.string(from: now)
// "2026-07-01T14:30:00.000Z"

Para sa ISO 8601 na format, gumamit ng ISO8601DateFormatter — hindi ito nangangailangan ng pagtukoy ng pattern at mas mabilis gumana kaysa DateFormatter. Sa iOS 10+, ang klaseng ito ay mas kanais-nais para sa pagtatrabaho sa mga petsa ng server. Para sa mga lumang format, panatilihin ang DateFormatter ngunit i-cache ang instance bilang static na property o singleton.

Petsa at Oras sa Android: java.time at DateTimeFormatter

Sa Android, ang petsa at oras ay pinoproseso sa pamamagitan ng java.time package, magagamit mula API 26. Mga pangunahing klase: LocalDate (petsa lamang), LocalTime (oras lamang), LocalDateTime (petsa at oras walang time zone) at ZonedDateTime (may time zone). DateTimeFormatter — isang thread-safe na tagapag-format para sa mobile platform na Android. Ang petsa sa mga mobile application ay nai-format sa pamamagitan ng DateTimeFormatter at LocalDate nang walang pagkawala ng pagganap.

LocalDate, ZonedDateTime at Pag-format

LocalDate ay nag-iimbak ng petsa nang walang oras — perpekto para sa mga kaarawan. Ang ZonedDateTime ay nag-iimbak ng kumpletong impormasyon na may time zone. Ang DateTimeFormatter ay sumusuporta sa mga paunang natukoy na pattern (ISO_LOCAL_DATE, ISO_DATE_TIME) at custom na pattern sa pamamagitan ng ofPattern. Lahat ng java.time na klase ay hindi nababago at thread-safe, na nag-aalis ng race conditions kapag nagtatrabaho sa maraming thread.

kotlin
import java.time.LocalDate
import java.time.LocalDateTime
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter
import java.time.ZoneId

// Paglikha at pag-format ng kasalukuyang petsa
val today = LocalDate.now()
val formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy")
val formatted = today.format(formatter)

// Paggawa gamit ang mga time zone
val utcTime = ZonedDateTime.now(ZoneId.of("UTC"))
val moscowTime = utcTime.withZoneSameInstant(ZoneId.of("Europe/Moscow"))

DateTimeFormatter ay makabuluhang mas mahusay kaysa SimpleDateFormat dahil hindi nito ina-parse ang pattern sa bawat tawag. Inirerekomenda na gumawa ng mga constant ng tagapag-format sa antas ng klase o companion object. Para i-convert ang Unix Timestamp, gumamit ng Instant.ofEpochSecond, pagkatapos i-convert sa LocalDateTime o ZonedDateTime sa pamamagitan ng time zone.

Mga Time Zone: Petsa at Oras sa mga Mobile Application at TimeZone

Ang tamang petsa at oras sa screen ng user ay nakasalalay sa tamang pagproseso ng mga time zone. Ang petsa at oras sa mobile development para sa Android ay nangangailangan ng pagsasaalang-alang ng time zone ng device. Ang gintong panuntunan: itago ang oras sa UTC, i-convert sa lokal na time zone lamang para sa pagpapakita. Ang iOS ay nagbibigay ng TimeZone mula sa Foundation, ang Android ay nagbibigay ng ZoneId mula sa java.time. Parehong API para sa mga mobile platform ay sumusuporta sa awtomatikong pagtuklas ng kasalukuyang time zone ng device. Ang petsa sa isang mobile application ay nakadepende sa ZoneId at TimeZone.

Daylight Saving Time at IANA Identifier

Daylight Saving Time ay lumilikha ng kalabuan: isang sandali sa oras ay maaaring katawanin ng dalawang magkaibang lokal na oras. Ang java.time at Foundation ay awtomatikong humahawak ng DST. Gumamit ng IANA identifier (Europe/Moscow, America/New_York), hindi mga pagdadaglat (MSK, EST) — ang mga pagdadaglat ay hindi malinaw at hindi pinapansin ang paglipat sa daylight saving time.

swift
import Foundation

// Pag-convert ng UTC sa lokal na oras sa iOS
func formatToLocalTime(utcDate: Date, timeZoneId: String) -> String {
    let formatter = DateFormatter()
    formatter.dateFormat = "dd.MM.yyyy HH:mm"
    formatter.timeZone = TimeZone(identifier: timeZoneId)
    return formatter.string(from: utcDate)
}

// Pagtukoy ng time zone ng device
let localTimeZone = TimeZone.current
let isDST = localTimeZone.isDaylightSavingTime()
let secondsFromGMT = localTimeZone.secondsFromGMT()

Sa Android, gumamit ng ZoneId.systemDefault() para makuha ang time zone ng device. Kapag nagko-convert ng UTC sa lokal na oras, gumawa ng ZonedDateTime na may ZoneOffset.UTC at ilapat ang withZoneSameInstant. Para sa mga lumang API na walang java.time, gumamit ng TimeZone.getDefault() at Calendar — ngunit mas mainam na direktang magdagdag ng ThreeTenABP.

kotlin
import java.time.Instant
import java.time.ZonedDateTime
import java.time.ZoneId

// I-convert ang Unix Timestamp sa lokal na oras
fun toLocalDisplay(unixSeconds: Long): String {
    val instant = Instant.ofEpochSecond(unixSeconds)
    val local = instant.atZone(ZoneId.systemDefault())
    return local.format(DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm"))
}

ThreeTenABP — Petsa at Oras para sa mga Lumang Bersyon ng Android

ThreeTenABP — isang library ng adapter na nagpo-port ng java.time sa Android API na mas mababa sa 26. Nagbibigay ito ng parehong mga klase: LocalDate, LocalTime, ZonedDateTime, DateTimeFormatter, Instant. Kung sinusuportahan ng application ang Android 5 o 6 (API 21-25), ang ThreeTenABP ay ang tanging paraan upang gumamit ng modernong mobile API nang hindi lumilipat sa hindi na ginagamit na Calendar. Ang petsa at oras sa mobile development para sa mga lumang device ay ipinatupad sa pamamagitan ng library na ito. Para sa mga lumang device, ang petsa at oras ay ipinatupad sa pamamagitan ng ThreeTenABP.

Pagdaragdag at Pag-configure ng ThreeTenABP

Ang library ay nangangailangan ng pagsisimula sa Application.onCreate() na paraan sa pamamagitan ng pagtawag sa AndroidThreeTen.init(). Ito ay naglo-load ng data ng time zone mula sa assets. Pagkatapos ng pagsisimula, ang API ay ganap na kapareho sa java.time — ang code para sa API 26+ at API 21+ ay magiging pareho. Ang laki ng library ay humigit-kumulang 400 KB, na katanggap-tanggap para sa karamihan ng mga mobile application.

kotlin
import org.threeten.bp.LocalDate
import org.threeten.bp.format.DateTimeFormatter

// Pagsisimula sa Application
class App : Application() {
    override fun onCreate() {
        super.onCreate()
        AndroidThreeTen.init(this)
    }
}

// API ay kapareho ng java.time
val today = LocalDate.now()
val formatted = today.format(DateTimeFormatter.ISO_LOCAL_DATE)

Ang pagganap ng ThreeTenABP ay maihahambing sa orihinal na java.time sa mga modernong device. Sa mga lumang device, maaaring magkaroon ng pagkaantala sa unang tawag dahil sa pag-load ng data ng time zone. Ilipat ang umiiral na code mula sa Calendar patungo sa ThreeTenABP nang paunti-unti: palitan ang Date at Calendar ng Instant at LocalDate sa mga bagong module, iwanan ang lumang code na hindi nababago.

Unix Timestamp at Pag-sync ng Oras sa pamamagitan ng NTP

Unix Timestamp — ang bilang ng mga segundo na lumipas mula noong Enero 1, 1970 00:00 UTC. Ito ay isang unibersal na format para sa pag-iimbak at pagpapalitan ng oras sa pagitan ng server at client. Gayunpaman, ang oras sa device ay maaaring magkaiba sa aktwal na oras dahil sa mga setting ng user. Para sa pag-sync, ginagamit ang NTP — isang tumpak na protocol ng oras sa pamamagitan ng UDP. Unix Timestamp ay ang format kung saan ang petsa at oras ay naka-imbak sa server.

Pagkuha ng Unix Timestamp at NTP Pag-sync

Date().timeIntervalSince1970 sa iOS ay nagbabalik ng mga segundo mula noong 1970. Sa Android, ang System.currentTimeMillis() ay nagbabalik ng millisecond. Para sa katumpakan, gumamit ng NTP: ang TrueTime library para sa iOS at AndroidNtp para sa Android ay nagpapadala ng kahilingan sa isang NTP server at kinakalkula ang offset ng oras. Ang katumpakan ng NTP ay 1-10 ms sa lokal na network at 10-100 ms sa internet.

swift
import Foundation

// Pagkuha ng Unix Timestamp sa iOS
let seconds = Date().timeIntervalSince1970
let milliseconds = Int64(seconds * 1000)

// NTP pag-sync gamit ang TrueTime
TrueTime.shared.start { result in
    switch result {
    case .success:
        let ntpTime = TrueTime.shared.now()
        print("Eksaktong oras: \(ntpTime)")
    case .failure(let error):
        print("Error sa NTP: \(error)")
    }
}

Kung walang pag-sync sa isang mobile application, posible ang mga error: maling timestamp ng kaganapan, pagkawala ng sync sa server. Ang oras sa mobile development ay naka-sync sa pamamagitan ng NTP nang isang beses sa pagsisimula ng application, pagkatapos ay ginagamit ang kinakalkula na offset. Para sa mga mobile application na kritikal sa katumpakan (pananalapi, logistik), ang NTP protocol ay sapilitan bago magpadala ng data sa server.

Mga Madalas Itanong

Bakit mabagal ang DateFormatter sa iOS?

DateFormatter ay nagpa-parse ng pattern ng pag-format, naglo-load ng locale at tumutukoy ng time zone sa bawat paggawa ng instance. I-cache ang tagapag-format bilang isang static na constant o gumamit ng ISO8601DateFormatter para sa ISO 8601 — ito ay mas magaan at mas mabilis.

Ano ang gagamitin sa halip na SimpleDateFormat sa Android?

DateTimeFormatter mula sa java.time package — thread-safe at mahusay. Magagamit mula API 26. Para sa mga lumang bersyon, gumamit ng ThreeTenABP na nagbibigay ng kaparehong API.

Paano magtrabaho sa mga petsa bago ang Java 8 sa Android?

Magdagdag ng ThreeTenABP — backport ng java.time para sa Android API 21+. Pagsisimula sa pamamagitan ng AndroidThreeTen.init() sa Application.onCreate(). Ang API ay ganap na kapareho ng orihinal na java.time.

Kailangan bang itago ang oras sa UTC?

Oo, itago ang oras sa UTC sa server at sa lokal na database. I-convert sa lokal na time zone ng user lamang sa yugto ng pagpapakita. Tinatanggal nito ang mga error kapag nagbabago ng time zone o naglalakbay.

Paano makakuha ng Unix Timestamp sa iOS?

Date().timeIntervalSince1970 ay nagbabalik ng bilang ng mga segundo mula noong Enero 1, 1970. Para sa millisecond, i-multiply sa 1000 at i-convert sa Int64. Para sa tumpak na pag-sync, gamitin ang TrueTime library na may NTP server.

Buod

  • DateFormatter sa iOS — ang pangunahing tool para sa pag-format ng petsa at oras, nangangailangan ng mandatoryong pag-cache ng instance. Ang ISO8601DateFormatter ay isang mas magaan na alternatibo para sa ISO 8601.
  • DateTimeFormatter sa Android — thread-safe na tagapag-format mula sa java.time para sa API 26+. Ang LocalDate at ZonedDateTime ay ang mga pangunahing klase para sa pagtatrabaho sa mga petsa.
  • ThreeTenABP — pinag-isang API para sa lahat ng bersyon ng Android. Idagdag para sa backward compatibility sa API 21-25. Ang code ay hindi naiiba sa java.time.
  • TimeZone at UTC — itago ang oras sa UTC, i-convert sa lokal na time zone lamang para sa pagpapakita. Gumamit ng IANA identifier.
  • Unix Timestamp — unibersal na format para sa pagpapalitan ng oras sa pagitan ng server at client. Kunin sa pamamagitan ng Date().timeIntervalSince1970 sa iOS.
  • NTP Pag-sync — ginagarantiyahan ang katumpakan ng oras hanggang millisecond. Ang TrueTime (iOS) at AndroidNtp (Android) ay ang mga karaniwang library.

Gagawa kami ng mobile application na turnkey

Gumagawa ang IT Sectr ng mga iOS at Android application para sa mga startup at negosyo mula noong 2017. Magpapayo kami sa iyo at magmumungkahi ng pinakamahusay na solusyon.

Pag-usapan ang proyekto