android: add notification methods to MainActivity

Implement the 8 methods that the Rust JNI bridge (android.rs) calls
on the activity context for notification management:

- getNotificationMode / setNotificationMode: persist mode index
  (0=FCM, 1=Native, 2=Disabled) in SharedPreferences
- enableFcmNotifications: read cached FCM token and register with
  notepush server via NotepushClient on a background coroutine
- disableFcmNotifications: unregister from notepush and clear token
- enableNativeNotifications / disableNativeNotifications: store or
  clear relay config for a future native WebSocket service
- isNotificationPermissionGranted: check POST_NOTIFICATIONS on API 33+
- requestNotificationPermission: launch runtime permission dialog,
  forward result to Rust via nativeOnNotificationPermissionResult

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: alltheseas

crates/notedeck_chrome/android/app/src/main/java/com/damus/notedeck/MainActivity.kt

@@ -1,6 +1,10 @@
 package com.damus.notedeck
 
+import android.Manifest
+import android.content.Context
 import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
 import android.database.Cursor
 import android.net.Uri
 import android.os.Bundle
@@ -9,31 +13,47 @@ import android.util.Log
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
 import androidx.core.graphics.Insets
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.damus.notedeck.service.NotepushClient
 import com.google.androidgamesdk.GameActivity
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
 import java.io.ByteArrayOutputStream
 import java.io.IOException
 
 /**
  * Main activity for Notedeck Android, extending GameActivity for NDK/OpenGL rendering.
  *
  * Hosts the native Rust application via JNI and handles Android-specific concerns
- * like file picking, window insets, and touch event offset correction.
+ * like file picking, window insets, touch event offset correction, and notification
+ * management (FCM registration, permission requests, mode persistence).
  */
 class MainActivity : GameActivity() {
 
     companion object {
         const val REQUEST_CODE_PICK_FILE = 420
+        const val REQUEST_CODE_NOTIFICATION_PERMISSION = 1001
+        private const val PREFS_NAME = "notedeck_notifications"
+        private const val KEY_MODE = "notification_mode"
         private const val TAG = "MainActivity"
     }
 
+    private val notificationScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private val notepushClient = NotepushClient()
+
     // Native method declarations (implemented in Rust via JNI)
     private external fun nativeOnFilePickedFailed(uri: String, e: String)
     private external fun nativeOnFilePickedWithContent(uriInfo: Array<Any?>, content: ByteArray)
+    private external fun nativeOnNotificationPermissionResult(granted: Boolean)
 
     /**
      * Launch the system document picker for selecting one or more files.
@@ -188,6 +208,7 @@ class MainActivity : GameActivity() {
 
     override fun onDestroy() {
         super.onDestroy()
+        notificationScope.cancel()
     }
 
     /**
@@ -221,4 +242,164 @@ class MainActivity : GameActivity() {
     private fun getContent(): View {
         return window.decorView.findViewById(android.R.id.content)
     }
+
+    // =========================================================================
+    // Notification methods (called from Rust via JNI)
+    // =========================================================================
+
+    /**
+     * Read the persisted notification mode from SharedPreferences.
+     *
+     * @return Mode index: 0 = FCM, 1 = Native, 2 = Disabled (default).
+     */
+    fun getNotificationMode(): Int {
+        return getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .getInt(KEY_MODE, 2)
+    }
+
+    /**
+     * Persist the notification mode to SharedPreferences.
+     *
+     * @param mode 0 = FCM, 1 = Native, 2 = Disabled.
+     */
+    fun setNotificationMode(mode: Int) {
+        getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .putInt(KEY_MODE, mode)
+            .apply()
+    }
+
+    /**
+     * Enable FCM push notifications for the given pubkey.
+     *
+     * Reads the locally cached FCM token (written by
+     * [NotedeckFirebaseMessagingService.onNewToken]) and registers the
+     * device with the notepush server on a background coroutine.
+     *
+     * @param pubkeyHex The user's Nostr public key in hex format.
+     */
+    fun enableFcmNotifications(pubkeyHex: String) {
+        val fcmToken = getSharedPreferences("notedeck_fcm", Context.MODE_PRIVATE)
+            .getString("fcm_token", null)
+
+        if (fcmToken == null) {
+            Log.e(TAG, "enableFcmNotifications: no FCM token available")
+            return
+        }
+
+        // Store pubkey so disableFcmNotifications can unregister later
+        getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .putString("registered_pubkey", pubkeyHex)
+            .apply()
+
+        notificationScope.launch {
+            val success = notepushClient.registerDevice(pubkeyHex, fcmToken)
+            if (success) {
+                Log.d(TAG, "FCM registration succeeded for ${pubkeyHex.take(8)}")
+            } else {
+                Log.e(TAG, "FCM registration failed for ${pubkeyHex.take(8)}")
+            }
+        }
+    }
+
+    /**
+     * Disable FCM push notifications.
+     *
+     * Unregisters from the notepush server (if a token and pubkey are
+     * available). The FCM token itself is retained so re-enabling
+     * doesn't require a new token from Firebase.
+     */
+    fun disableFcmNotifications() {
+        val prefs = getSharedPreferences("notedeck_fcm", Context.MODE_PRIVATE)
+        val fcmToken = prefs.getString("fcm_token", null)
+        val pubkeyHex = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .getString("registered_pubkey", null)
+
+        if (fcmToken != null && pubkeyHex != null) {
+            notificationScope.launch {
+                val success = notepushClient.unregisterDevice(pubkeyHex, fcmToken)
+                if (success) {
+                    Log.d(TAG, "FCM unregistration succeeded")
+                } else {
+                    Log.e(TAG, "FCM unregistration failed")
+                }
+            }
+        }
+    }
+
+    /**
+     * Store configuration for a future native (WebSocket) notification service.
+     *
+     * @param pubkeyHex The user's Nostr public key in hex format.
+     * @param relaysJson JSON-serialized array of relay URLs.
+     */
+    fun enableNativeNotifications(pubkeyHex: String, relaysJson: String) {
+        getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .putString("native_pubkey", pubkeyHex)
+            .putString("native_relays", relaysJson)
+            .apply()
+        Log.d(TAG, "Native notification config stored for ${pubkeyHex.take(8)}")
+    }
+
+    /**
+     * Clear stored native notification configuration.
+     */
+    fun disableNativeNotifications() {
+        getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .remove("native_pubkey")
+            .remove("native_relays")
+            .apply()
+        Log.d(TAG, "Native notification config cleared")
+    }
+
+    /**
+     * Check whether the POST_NOTIFICATIONS permission is granted.
+     * On API < 33 (pre-Tiramisu), notifications are always permitted.
+     */
+    fun isNotificationPermissionGranted(): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return true
+
+        return ContextCompat.checkSelfPermission(
+            this,
+            Manifest.permission.POST_NOTIFICATIONS
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    /**
+     * Request the POST_NOTIFICATIONS runtime permission (API 33+).
+     *
+     * The result is delivered to [onRequestPermissionsResult], which
+     * forwards it to Rust via [nativeOnNotificationPermissionResult].
+     * On pre-33 devices the permission is implicit, so we report granted
+     * immediately.
+     */
+    fun requestNotificationPermission() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            nativeOnNotificationPermissionResult(true)
+            return
+        }
+
+        ActivityCompat.requestPermissions(
+            this,
+            arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+            REQUEST_CODE_NOTIFICATION_PERMISSION
+        )
+    }
+
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+
+        if (requestCode != REQUEST_CODE_NOTIFICATION_PERMISSION) return
+
+        val granted = grantResults.isNotEmpty() &&
+            grantResults[0] == PackageManager.PERMISSION_GRANTED
+        nativeOnNotificationPermissionResult(granted)
+    }
 }