Android应用中动态发送商品库存状态通知的实现求助

Hey there! Let me walk you through a practical, step-by-step implementation plan for sending dynamic inventory status notifications to your Android app users. I’ve broken this down into actionable parts that cover everything from database checks to delivering notifications effectively.

The core flow is straightforward:

1. Monitor or check your database for changes in a product's stock level
2. Identify which users have subscribed to updates for that product
3. Push a targeted notification to those users when stock becomes available

1. Stock Status Detection Mechanism #

You have two reliable ways to track stock changes—pick the one that fits your app's architecture:

Real-Time Database Listening (Recommended for Instant Updates) #

If you're using Room, Firebase Realtime Database, or Firestore, you can set up a live listener to trigger actions the moment stock changes.

Room Example with Flow

Use Room's Flow to observe stock levels reactively:

// In your Room DAO
@Query("SELECT stock_quantity FROM products WHERE product_id = :productId")
fun getProductStockFlow(productId: String): Flow<Int>

// In your ViewModel
viewModelScope.launch {
    productDao.getProductStockFlow(targetProductId).collect { stockQuantity ->
        // Check if stock is now available and user has subscribed
        if (stockQuantity > 0 && userHasActiveSubscription(targetProductId)) {
            sendInventoryNotification()
        }
    }
}

Firebase Firestore Example

Set up a snapshot listener to watch for document changes:

db.collection("products").document(targetProductId)
    .addSnapshotListener { snapshot, error ->
        error?.let {
            Log.w(TAG, "Stock listen failed: ${it.message}")
            return@addSnapshotListener
        }
        snapshot?.let { doc ->
            val stock = doc.getLong("stock_quantity")?.toInt() ?: 0
            if (stock > 0 && userHasActiveSubscription(targetProductId)) {
                sendInventoryNotification()
            }
        }
    }

Triggered Check (For Scheduled or Event-Driven Updates) #

If you don't need real-time updates (e.g., you update stock in batches), trigger a check after stock is modified:

fun updateProductStock(productId: String, newStock: Int) {
    // 1. Update your database with the new stock value
    productDao.updateStock(productId, newStock)
    
    // 2. Check if we need to notify subscribers
    if (newStock > 0) {
        val subscribedUsers = subscriptionDao.getSubscribedUsers(productId)
        subscribedUsers.forEach { user ->
            sendNotificationToUser(user, productId)
        }
    }
}

2. Manage User Subscriptions (Critical to Avoid Spam) #

You need a way to track which users want updates for which products. Create a subscription table in your database:

Room Subscription Entity Example #

@Entity(
    tableName = "product_subscriptions",
    primaryKeys = ["user_id", "product_id"]
)
data class ProductSubscription(
    @ColumnInfo(name = "user_id") val userId: String,
    @ColumnInfo(name = "product_id") val productId: String,
    @ColumnInfo(name = "is_active") val isActive: Boolean = true,
    @ColumnInfo(name = "last_notified_at") val lastNotifiedAt: Long = 0
)

This lets you:

• Fetch only users who opted in for updates
• Avoid sending duplicate notifications (use last_notified_at to throttle alerts)
• Let users unsubscribe easily

3. Implement Push Notifications #

You'll need two types of notifications depending on whether the user is in your app or not:

Local Notifications (For Users Inside the App) #

Use Android's native NotificationManager to show in-app alerts:

private fun sendLocalNotification(productName: String, productId: String) {
    val channelId = "inventory_updates"
    
    // Create notification channel (required for Android 8.0+)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val channel = NotificationChannel(
            channelId,
            "Stock Alerts",
            NotificationManager.IMPORTANCE_DEFAULT
        ).apply {
            description = "Get notified when products are back in stock"
        }
        val notificationManager = getSystemService(NotificationManager::class.java)
        notificationManager.createNotificationChannel(channel)
    }

    // Launch product detail screen when notification is tapped
    val intent = Intent(this, ProductDetailActivity::class.java).apply {
        flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
        putExtra("PRODUCT_ID", productId)
    }
    val pendingIntent = PendingIntent.getActivity(
        this,
        productId.hashCode(),
        intent,
        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
    )

    // Build and show the notification
    val notification = NotificationCompat.Builder(this, channelId)
        .setSmallIcon(R.drawable.ic_stock_alert)
        .setContentTitle("$productName is back in stock!")
        .setContentText("Don't wait—grab yours before it sells out again!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setContentIntent(pendingIntent)
        .setAutoCancel(true)
        // Add unsubscribe action
        .addAction(R.drawable.ic_unsubscribe, "Unsubscribe", getUnsubscribePendingIntent(productId))
        .build()

    NotificationManagerCompat.from(this).notify(productId.hashCode(), notification)
}

FCM Remote Notifications (For Users Outside the App) #

Integrate Firebase Cloud Messaging to send alerts to users even when your app is closed:

Backend/Cloud Function Example (Kotlin)

// Use Firebase Admin SDK to send FCM messages
val message = Message.builder()
    .setToken(userFcmToken) // Fetch this from your user database
    .setNotification(Notification.builder()
        .setTitle("$productName is back in stock!")
        .setBody("Your favorite item is available again—tap to view!")
        .build())
    .setData(mapOf("PRODUCT_ID" to productId))
    .build()

try {
    val response = FirebaseMessaging.getInstance().send(message)
    Log.d(TAG, "Notification sent successfully: $response")
} catch (e: FirebaseMessagingException) {
    Log.w(TAG, "Failed to send notification: ${e.message}")
}

Handle FCM Messages in Your App

Create a FirebaseMessagingService to process incoming notifications:

class MyFcmService : FirebaseMessagingService() {
    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        remoteMessage.notification?.let { notification ->
            showNotification(
                title = notification.title,
                body = notification.body,
                productId = remoteMessage.data["PRODUCT_ID"]
            )
        }
    }

    private fun showNotification(title: String?, body: String?, productId: String?) {
        // Reuse the local notification logic here
    }
}

4. Anti-Spam & User Control #

• Throttle notifications: Use the last_notified_at field to avoid sending multiple alerts for the same stock update
• Unsubscribe option: Add an action to notifications that lets users opt out instantly (update the is_active flag in your subscription table)
• Respect user preferences: Let users manage their subscriptions in a settings screen within your app

5. Test Edge Cases #

• Verify notifications trigger when stock goes from 0 to positive
• Ensure unsubscribed users don't receive alerts
• Test FCM delivery when the app is closed/killed
• Handle database errors and FCM failures with retry logic

内容的提问来源于stack exchange，提问作者Mohana Priya