Notifications when a proposal can be landed; the runner comes back after an update or restart (closes #20, refs #8) ff65ea456ff1

package io.oxygenhub.android.alerts

import android.app.Notification

import android.app.NotificationChannel

import android.app.NotificationManager

import android.app.PendingIntent

import android.app.job.JobInfo

import android.app.job.JobScheduler

import android.content.ComponentName

import android.content.Context

import android.content.Intent

import androidx.core.content.edit

import io.oxygenhub.android.MainActivity

import io.oxygenhub.android.R

import io.oxygenhub.android.api.ProposalBrief

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

/**

 * Notifications when a proposal can be landed (#20): every 15 minutes the

 * phone asks the hub what the account can land now (oxygenhub#311) and

 * says which proposals have become landable since it last asked. Polling

 * until FCM (#16) can push the same.

 */

object LandAlerts {

    private const val PREFS = "alerts"

    private const val ON = "land.on"

    private const val SEEN = "land.seen"

    private const val JOB = 20

    private const val CHANNEL = "landable"

    private const val EVERY_MS = 15 * 60 * 1000L

    /** Extras on the intent a notification opens: the proposal to show. */

    const val EXTRA_REPOSITORY = "io.oxygenhub.android.proposal.repository"

    const val EXTRA_NUMBER = "io.oxygenhub.android.proposal.number"

    private val _on = MutableStateFlow<Boolean?>(null)

    /** Whether the alerts are on, once [refresh] has read it. */

    val on: StateFlow<Boolean?> = _on.asStateFlow()

    fun refresh(context: Context) {

        _on.value = prefs(context).getBoolean(ON, false)

    }

    /**

     * Turn the alerts on: the check runs every 15 minutes on any network,

     * across reboots. What is landable already is said at the first check.

     */

    fun enable(context: Context) {

        prefs(context).edit {

            putBoolean(ON, true)

            remove(SEEN)

        }

        val job = JobInfo.Builder(JOB, ComponentName(context, LandCheckJob::class.java))

            .setPeriodic(EVERY_MS)

            .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)

            .setPersisted(true)

            .build()

        context.getSystemService(JobScheduler::class.java)?.schedule(job)

        _on.value = true

    }

    fun disable(context: Context) {

        context.getSystemService(JobScheduler::class.java)?.cancel(JOB)

        prefs(context).edit {

            putBoolean(ON, false)

            remove(SEEN)

        }

        _on.value = false

    }

    /** The proposals to say now, and what to remember for the next check. */

    fun fresh(seen: Set<String>, landable: List<ProposalBrief>): Pair<List<ProposalBrief>, Set<String>> {

        val now = landable.associateBy(::key)

        // Only what is landable now is remembered, so one that stops being

        // landable and becomes so again is said again.

        return now.filterKeys { it !in seen }.values.toList() to now.keys

    }

    /** Say what has become landable since the last check, and remember what is landable now. */

    fun check(context: Context, landable: List<ProposalBrief>) {

        val prefs = prefs(context)

        if (!prefs.getBoolean(ON, false)) return

        val (say, keep) = fresh(prefs.getStringSet(SEEN, emptySet()).orEmpty(), landable)

        say.forEach { notify(context, it) }

        prefs.edit { putStringSet(SEEN, keep) }

    }

    private fun key(p: ProposalBrief) = "${p.repository}#${p.number}"

    private fun notify(context: Context, p: ProposalBrief) {

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

        manager.createNotificationChannel(

            NotificationChannel(CHANNEL, "Ready to land", NotificationManager.IMPORTANCE_DEFAULT).apply {

                description = "A proposal you can land: its checks and reviews are settled"

            },

        )

        val open = Intent(context, MainActivity::class.java)

            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)

            .putExtra(EXTRA_REPOSITORY, p.repository)

            .putExtra(EXTRA_NUMBER, p.number)

        val id = key(p).hashCode()

        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("Ready to land: ${p.repository}#${p.number}")

            .setContentText(p.title)

            .setStyle(Notification.BigTextStyle().bigText("${p.title}\nby ${p.author}"))

            .setContentIntent(tap)

            .setAutoCancel(true)

            .build()

        manager.notify(id, notification)

    }

    private fun prefs(context: Context) = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)

}

package io.oxygenhub.android.alerts

import android.Manifest

import android.content.pm.PackageManager

import android.os.Build

import androidx.activity.compose.rememberLauncherForActivityResult

import androidx.activity.result.contract.ActivityResultContracts

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.Row

import androidx.compose.foundation.layout.fillMaxWidth

import androidx.compose.foundation.layout.padding

import androidx.compose.material3.ElevatedCard

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.Switch

import androidx.compose.material3.Text

import androidx.compose.runtime.Composable

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.getValue

import androidx.compose.ui.Alignment

import androidx.compose.ui.Modifier

import androidx.compose.ui.platform.LocalContext

import androidx.compose.ui.unit.dp

import androidx.core.content.ContextCompat

import androidx.lifecycle.compose.collectAsStateWithLifecycle

/** On the Account screen: notifications when a proposal can be landed (#20), on or off. */

@Composable

fun LandAlertsCard() {

    val context = LocalContext.current

    val on by LandAlerts.on.collectAsStateWithLifecycle()

    LaunchedEffect(Unit) { LandAlerts.refresh(context) }

    // Without the permission there is nothing to show, so it stays off.

    val ask = rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->

        if (granted) LandAlerts.enable(context)

    }

    val turnOn = {

        val granted = Build.VERSION.SDK_INT < 33 ||

            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED

        if (granted) LandAlerts.enable(context) else ask.launch(Manifest.permission.POST_NOTIFICATIONS)

    }

    ElevatedCard(Modifier.fillMaxWidth()) {

        Row(Modifier.padding(16.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(16.dp)) {

            Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(4.dp)) {

                Text("Ready to land", style = MaterialTheme.typography.titleMedium)

                Text(

                    "Tell me when a proposal I can land has its checks and reviews settled. Checked every 15 minutes.",

                    style = MaterialTheme.typography.bodyMedium,

                    color = MaterialTheme.colorScheme.onSurfaceVariant,

                )

            }

            Switch(

                checked = on == true,

                enabled = on != null,

                onCheckedChange = { if (it) turnOn() else LandAlerts.disable(context) },

            )

        }

    }

}

package io.oxygenhub.android.alerts

import android.app.job.JobParameters

import android.app.job.JobService

import io.oxygenhub.android.OxygenHubApp

import io.oxygenhub.android.api.HubException

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.Dispatchers

import kotlinx.coroutines.SupervisorJob

import kotlinx.coroutines.cancel

import kotlinx.coroutines.launch

/** The periodic check behind [LandAlerts]: what the account can land now. */

class LandCheckJob : JobService() {

    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)

    override fun onStartJob(params: JobParameters): Boolean {

        // Signed out: nothing to ask, and the next sign-in finds the alerts as they were.

        val api = (application as OxygenHubApp).container.sessions.api() ?: return false

        scope.launch {

            try {

                LandAlerts.check(this@LandCheckJob, api.userProposals(landable = true).landable)

            } catch (_: HubException) {

                // Unreachable or refused: the next period asks again.

            }

            jobFinished(params, false)

        }

        return true

    }

    override fun onStopJob(params: JobParameters): Boolean = false

    override fun onDestroy() {

        scope.cancel()

        super.onDestroy()

    }

}

package io.oxygenhub.android.runner

import android.content.BroadcastReceiver

import android.content.Context

import android.content.Intent

/**

 * Offers the phone as a runner again after it restarts or the app is

 * updated, if its owner had it offered: an update stops the app, and with

 * it the runner.

 */

class RunnerResume : BroadcastReceiver() {

    override fun onReceive(context: Context, intent: Intent) {

        if (intent.action == Intent.ACTION_BOOT_COMPLETED || intent.action == Intent.ACTION_MY_PACKAGE_REPLACED) {

            PhoneRunner.resume(context)

        }

    }

}

package io.oxygenhub.android.alerts

import io.oxygenhub.android.api.ProposalBrief

import org.junit.Assert.assertEquals

import org.junit.Test

class LandAlertsTest {

    private fun p(repository: String, number: Long) = ProposalBrief(repository, number, title = "P$number")

    @Test

    fun a_proposal_is_said_once_while_it_stays_landable() {

        val (first, seen) = LandAlerts.fresh(emptySet(), listOf(p("andy/demo", 2), p("andy/web", 7)))

        assertEquals(listOf(2L, 7L), first.map { it.number })

        val (second, still) = LandAlerts.fresh(seen, listOf(p("andy/demo", 2), p("andy/web", 7)))

        assertEquals(emptyList<ProposalBrief>(), second)

        assertEquals(seen, still)

    }

    @Test

    fun a_proposal_that_becomes_landable_again_is_said_again() {

        val (_, seen) = LandAlerts.fresh(emptySet(), listOf(p("andy/demo", 2)))

        // A new commit made it wait for its checks again: no longer landable.

        val (none, waiting) = LandAlerts.fresh(seen, emptyList())

        assertEquals(emptyList<ProposalBrief>(), none)

        assertEquals(emptySet<String>(), waiting)

        val (again, _) = LandAlerts.fresh(waiting, listOf(p("andy/demo", 2)))

        assertEquals(listOf("andy/demo#2"), again.map { "${it.repository}#${it.number}" })

    }

    @Test

    fun the_same_number_in_two_repositories_is_two_proposals() {

        val (_, seen) = LandAlerts.fresh(emptySet(), listOf(p("andy/demo", 2)))

        val (said, _) = LandAlerts.fresh(seen, listOf(p("andy/demo", 2), p("andy/web", 2)))

        assertEquals(listOf("andy/web"), said.map { it.repository })

    }

}

    <!-- The check for proposals ready to land (#20) is kept across reboots, and the runner (#8) offered again. -->

    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

        <receiver

            android:name=".runner.RunnerResume"

            android:exported="false">

            <intent-filter>

                <action android:name="android.intent.action.BOOT_COMPLETED" />

                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />

            </intent-filter>

        </receiver>

        <service

            android:name=".alerts.LandCheckJob"

            android:exported="false"

            android:permission="android.permission.BIND_JOB_SERVICE" />

import android.content.Intent

import androidx.compose.runtime.mutableStateOf

import io.oxygenhub.android.alerts.LandAlerts

import io.oxygenhub.android.ui.nav.ProposalRoute

    /** A proposal a notification asked to open (#20), until it is shown. */

    private val opening = mutableStateOf<ProposalRoute?>(null)

        if (savedInstanceState == null) opening.value = proposalIn(intent)

                            open = opening.value,

                            onOpened = { opening.value = null },

    }

    override fun onNewIntent(intent: Intent) {

        super.onNewIntent(intent)

        proposalIn(intent)?.let { opening.value = it }

    }

    private fun proposalIn(intent: Intent?): ProposalRoute? {

        val repository = intent?.getStringExtra(LandAlerts.EXTRA_REPOSITORY) ?: return null

        val number = intent.getLongExtra(LandAlerts.EXTRA_NUMBER, 0)

        if ('/' !in repository || number <= 0) return null

        return ProposalRoute(repository.substringBefore('/'), repository.substringAfter('/'), number)

    /**

     * The proposals the caller should act on, across repositories (the hub's

     * dashboard); with [landable], also those it can land now (#20, oxygenhub#311).

     */

    suspend fun userProposals(landable: Boolean = false): UserProposals

    override suspend fun userProposals(landable: Boolean): UserProposals =

        get(url("user", "proposals") { if (landable) addQueryParameter("landable", "true") }, UserProposals.serializer())

    /** Asked for with `landable=true`: open ones the caller can land now. */

    val landable: List<ProposalBrief> = emptyList(),

import androidx.core.content.edit

    /** Start the runner, and keep it offered across app updates and restarts until the owner stops it. */

        prefs(context).edit { putBoolean(WANTED, true) }

    /** The owner stopped it: drain, and stay stopped after an update or restart. */

    fun stopByOwner(context: Context) {

        prefs(context).edit { putBoolean(WANTED, false) }

        drain("stopped by you")

    }

    /** After a restart or an app update ([RunnerResume]): offer the phone again if it was offered. */

    fun resume(context: Context) {

        if (prefs(context).getBoolean(WANTED, false) && runnerIsRegistered(home(context).path)) start(context)

    }

    private const val WANTED = "runner.wanted"

    private fun prefs(context: Context) = context.getSharedPreferences("runner", Context.MODE_PRIVATE)

                    PhoneRunner.State.Running -> OutlinedButton(onClick = { PhoneRunner.stopByOwner(context) }) { Text("Stop") }

import io.oxygenhub.android.alerts.LandAlertsCard

                LandAlertsCard()

import androidx.compose.runtime.LaunchedEffect

    /** A proposal to open, as a notification asks (#20); [onOpened] once it is. */

    open: ProposalRoute? = null,

    onOpened: () -> Unit = {},

        LaunchedEffect(open) {

            open?.let {

                nav.navigate(it)

                onOpened()

            }

        }

    override suspend fun userProposals(landable: Boolean) =

        userProposals.invoke().also { calls += if (landable) "user proposals, landable" else "user proposals" }