Coverage / app/src/main/java/io/oxygenhub/android/alerts/PushAlerts.kt 0.0%

package io.oxygenhub.android.alerts

import android.app.Notification

import android.app.NotificationChannel

import android.app.NotificationManager

import android.app.PendingIntent

import android.content.Context

import android.content.Intent

import android.net.Uri

import android.util.Base64

import android.util.Log

import com.google.firebase.FirebaseApp

import com.google.firebase.FirebaseOptions

import com.google.firebase.messaging.FirebaseMessaging

import io.oxygenhub.android.BuildConfig

import io.oxygenhub.android.R

import io.oxygenhub.android.api.HubApi

import kotlinx.coroutines.suspendCancellableCoroutine

import kotlinx.serialization.Serializable

import kotlinx.serialization.json.Json

import uniffi.rust_core.alertOpen

import kotlin.coroutines.resume

import kotlin.coroutines.resumeWithException

/**

 * Alerts from the hub (#16): each notification the account is told reaches

 * the phone through Firebase Cloud Messaging, sealed to the phone's

 * [AlertKey], so Google carries only ciphertext; the app opens it and shows

 * it. Firebase is started by hand from the build's settings (BuildConfig,

 * from google-services.json), so a build without them takes no alerts.

 */

object PushAlerts {

    private const val TAG = "PushAlerts"

    private const val CHANNEL = "hub-alerts"

    /** What the hub seals: the notification's kind, its title and its link. */

    @Serializable

    data class Alert(val kind: String = "", val title: String = "", val url: String = "")

    private val json = Json { ignoreUnknownKeys = true }

    /** Whether this build can take alerts. */

    val available: Boolean get() = BuildConfig.FIREBASE_APP_ID.isNotEmpty()

    /** Start Firebase, once, when this build has its settings. */

    fun start(context: Context) {

        if (!available || FirebaseApp.getApps(context).isNotEmpty()) return

        val options = FirebaseOptions.Builder()

            .setApplicationId(BuildConfig.FIREBASE_APP_ID)

            .setProjectId(BuildConfig.FIREBASE_PROJECT_ID)

            .setGcmSenderId(BuildConfig.FIREBASE_SENDER_ID)

            .setApiKey(BuildConfig.FIREBASE_API_KEY)

            .build()

        FirebaseApp.initializeApp(context, options)

    }

    /** Register this phone with the hub: its Cloud Messaging token and its alert key. */

    suspend fun register(context: Context, api: HubApi, token: String? = null): Boolean {

        if (!available) return false

        start(context)

        val fcm = token ?: suspendCancellableCoroutine { k ->

            FirebaseMessaging.getInstance().token

                .addOnSuccessListener { k.resume(it) }

                .addOnFailureListener { k.resumeWithException(it) }

        }

        return api.registerPush(fcm, AlertKey.publicKeyHex(context))

    }

    /** Open a sealed alert (base64url) with this phone's key; null when it is not for it. */

    fun open(context: Context, sealed: String): Alert? {

        val bytes = try {

            Base64.decode(sealed, Base64.URL_SAFE or Base64.NO_PADDING or Base64.NO_WRAP)

        } catch (_: IllegalArgumentException) {

            return null

        }

        val plain = alertOpen(AlertKey.secret(context), bytes) ?: return null

        return try {

            json.decodeFromString(Alert.serializer(), plain.decodeToString())

        } catch (e: IllegalArgumentException) {

            Log.w(TAG, "an alert that does not read: ${e.message}")

            null

        }

    }

    /** Show [alert]; a tap opens its link. */

    fun show(context: Context, alert: Alert) {

        val manager = context.getSystemService(NotificationManager::class.java) ?: return

        manager.createNotificationChannel(

            NotificationChannel(CHANNEL, "Alerts from the hub", NotificationManager.IMPORTANCE_DEFAULT).apply {

                description = "What your inbox on the hub is told: builds, reviews, mentions"

            },

        )

        val id = (alert.kind + alert.url).hashCode()

        val open = Intent(Intent.ACTION_VIEW, Uri.parse(alert.url)).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)

        val tap = PendingIntent.getActivity(context, id, open, PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)

        val notification = Notification.Builder(context, CHANNEL)

            .setSmallIcon(R.drawable.ic_launcher_monochrome)

            .setContentTitle(alert.title.substringBefore(": ", alert.title))

            .setContentText(alert.title.substringAfter(": ", alert.title))

            .setStyle(Notification.BigTextStyle().bigText(alert.title.substringAfter(": ", alert.title)))

            .setContentIntent(tap)

            .setAutoCancel(true)

            .build()

        manager.notify(id, notification)

    }

}