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
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.
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.
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.
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 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.
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.
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 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.
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.
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 — 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.
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.
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 — 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.
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.
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
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.
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.
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.
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.
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
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.