Android Studio跨设备/双账号实时通知及共享数据库实现咨询

1. Can I implement notification push between Android Emulator and USB-connected physical device in Android Studio with a database (for demo purposes)? #

Absolutely! This is totally doable, and here are two practical approaches tailored for demo scenarios:

Option 1: Local Network + Socket + Shared Database #

Perfect for LAN-only/offline demos:

• Set up a lightweight socket server (you can build one quickly with Java or Python) on your development machine.
• Ensure both the emulator and physical device connect to the same local network (note: the emulator uses 10.0.2.2 to access your machine's localhost).
• When sending a notification:
  1. Write the notification content (title, body, target device ID) to a shared database—this could be a simple SQLite file on your server or a lightweight MySQL instance.
  2. The server polls the database for new notification requests, then sends the payload to the target device via socket.
  3. On the Android side, once the socket client receives the payload, trigger a system notification using NotificationManagerCompat, and optionally save the notification to the device's local Room database for history.

Option 2: Firebase Realtime Database + Firebase Cloud Messaging (FCM) #

Easier for quick, no-custom-server demos:

• Link your Android project to a Firebase project in Android Studio, then enable Realtime Database and FCM in the Firebase console.
• When one device wants to push a notification:
  1. Write the notification data (target device token, title, body) to the Realtime Database.
  2. Use a Firebase Cloud Function (or even a simple in-app trigger) to detect the new database entry, then call the FCM API to send the notification to the target device.
  3. Both emulator and physical device will receive the push as long as they're registered with the same Firebase project and have valid device tokens.

Simplified code snippet for sending an FCM notification in your app:

// Retrieve target device token from your database first
val targetToken = "STORED_DEVICE_TOKEN"
val notification = com.google.firebase.messaging.Notification(
    title = "Demo Alert",
    body = "Sent from emulator/physical device!"
)
val message = Message.builder()
    .setToken(targetToken)
    .setNotification(notification)
    .build()

FirebaseMessaging.getInstance().send(message)

2. Can I implement real-time notification push between two accounts in an app with dual accounts and a shared database? #

Definitely! This is a common use case, and here's how to pull it off smoothly:

Core Approach: Shared Real-Time Database + Live Listeners #

• Use a real-time database like Firebase Firestore or Realtime Database (both support live, instant listeners). Store user accounts and notification data in this shared database.
• When Account A triggers a notification for Account B (e.g., sending a shared item or message):
  1. Write a notification record to the database, tagged with Account B's unique user ID.
  2. On Account B's device, set up a real-time listener on the database path reserved for their notifications.
  3. As soon as the listener detects a new entry, trigger a local Android notification using NotificationManagerCompat.

Enhance with FCM for Background Notifications #

To ensure notifications reach Account B even when the app is in the background:

• When writing the notification to the database, trigger a Firebase Cloud Function that sends an FCM push to all devices linked to Account B.
• This way, even if the app isn't actively listening, the FCM service will wake up the app (or show a system notification directly) when the push arrives.

Example of a Firestore real-time listener in Kotlin:

// Listen for new notifications targeted at Account B
FirebaseFirestore.getInstance()
    .collection("notifications")
    .whereEqualTo("targetUserId", "ACCOUNT_B_USER_ID")
    .addSnapshotListener { snapshot, e ->
        if (e != null) {
            Log.w(TAG, "Listen failed.", e)
            return@addSnapshotListener
        }

        for (dc in snapshot!!.documentChanges) {
            if (dc.type == DocumentChange.Type.ADDED) {
                val notification = dc.document.toObject(Notification::class.java)
                // Trigger system notification
                showNotification(notification.title, notification.body)
            }
        }
    }

Just make sure to handle user authentication properly (e.g., Firebase Auth) so each account only accesses their own notification data.

内容的提问来源于stack exchange，提问作者M.P.