如何通过Firebase实现APP实时日期展示及实时Unix时间获取？

Absolutely! Firebase is perfect for this—you can ditch external APIs and messy JSON parsing entirely. Let’s break down two straightforward approaches that fit your needs:

This is great if you just need to grab the current time occasionally (not real-time updates every few seconds). Firebase provides a native way to get the server's Unix timestamp without any external calls, and the SDK handles all the heavy lifting—no JSON parsing required.

For Firebase Realtime Database:

• When you write a value using ServerValue.TIMESTAMP, Firebase replaces this placeholder with the actual Unix timestamp (in milliseconds) from its servers. You can write this to a temporary node, then read it back to get the time:

// Kotlin example for Android
val db = FirebaseDatabase.getInstance().reference

// Write server timestamp to a temporary node
db.child("temp/currentTime").setValue(ServerValue.TIMESTAMP)
    .addOnSuccessListener {
        // Read the timestamp once it's written
        db.child("temp/currentTime").addListenerForSingleValueEvent(object : ValueEventListener {
            override fun onDataChange(snapshot: DataSnapshot) {
                val unixTimestamp = snapshot.getValue(Long::class.java) ?: 0
                // Convert to readable date
                val date = Date(unixTimestamp)
                val dateFormatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
                val formattedDate = dateFormatter.format(date)
                
                // Update your app's UI with formattedDate here
            }

            override fun onCancelled(error: DatabaseError) {
                // Handle errors (e.g., network issues)
            }
        })
    }

For Firestore:
Similar logic applies, but you'll use FieldValue.serverTimestamp(), which returns a Timestamp object. You can easily convert this to a Unix timestamp:

val db = FirebaseFirestore.getInstance()
val timeDoc = db.collection("system").document("currentTime")

// Write server timestamp to Firestore
timeDoc.set(mapOf("timestamp" to FieldValue.serverTimestamp()))
    .addOnSuccessListener {
        timeDoc.get().addOnSuccessListener { document ->
            val firestoreTimestamp = document.getTimestamp("timestamp")
            val unixTimestamp = firestoreTimestamp?.seconds ?: 0 // Seconds since epoch
            val date = Date(unixTimestamp * 1000) // Convert to milliseconds for Date
            // Format and display the date as needed
        }
    }

If you need your app to display a constantly updating clock (e.g., refreshes every minute), use Cloud Functions to periodically update a time node in your database. Your app just listens to this node—no parsing, no external APIs.

Step 1: Deploy the Cloud Function #

Write a Node.js function that runs every minute (adjust the schedule as needed) to update a currentUnixTime node with the latest timestamp:

const functions = require("firebase-functions");
const admin = require("firebase-admin");
admin.initializeApp();

// Runs every minute (cron schedule: * * * * *)
exports.updateCurrentTime = functions.pubsub.schedule("* * * * *").onRun((context) => {
    const currentUnixTime = Date.now(); // Milliseconds since epoch
    return admin.database().ref("/currentUnixTime").set(currentUnixTime);
});

Step 2: Listen for Updates in Your App #

Add a real-time listener to the currentUnixTime node—every time the function updates it, your app gets the new timestamp instantly:

val db = FirebaseDatabase.getInstance().reference

db.child("currentUnixTime").addValueEventListener(object : ValueEventListener {
    override fun onDataChange(snapshot: DataSnapshot) {
        val unixTimestamp = snapshot.getValue(Long::class.java) ?: 0
        val date = Date(unixTimestamp)
        val dateFormatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
        val formattedDate = dateFormatter.format(date)
        
        // Update your UI with the latest date here
    }

    override fun onCancelled(error: DatabaseError) {
        // Handle errors
    }
})

Why This Works for You #

• No external APIs: All time data comes directly from Firebase's servers.
• No JSON parsing: The Firebase SDK returns the timestamp as a native Long (or Timestamp for Firestore)—you don't need to parse any JSON manually.
• Real-time ready: The Cloud Functions approach keeps your app's date display in sync without polling.

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