Merge notif: post real system-tray notifications when a run needs the operator
This commit is contained in:
@@ -3,6 +3,14 @@
|
|||||||
|
|
||||||
<uses-permission android:name="android.permission.INTERNET" />
|
<uses-permission android:name="android.permission.INTERNET" />
|
||||||
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
|
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
|
||||||
|
<!--
|
||||||
|
POST_NOTIFICATIONS is requested at runtime on Android 13+ (API 33), the
|
||||||
|
first time a run actually needs the operator or the attention surface is
|
||||||
|
opened, and asked at most once: a refusal degrades to the in-app Needs you
|
||||||
|
surface rather than nagging. Runs that need the operator post into the one
|
||||||
|
"Runs that need you" channel from the app's own process.
|
||||||
|
-->
|
||||||
|
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
|
||||||
|
|
||||||
<application
|
<application
|
||||||
android:allowBackup="true"
|
android:allowBackup="true"
|
||||||
|
|||||||
@@ -11,18 +11,21 @@ import androidx.compose.runtime.setValue
|
|||||||
import androidx.lifecycle.viewmodel.compose.viewModel
|
import androidx.lifecycle.viewmodel.compose.viewModel
|
||||||
import net.awan.pipelines.ui.AppViewModel
|
import net.awan.pipelines.ui.AppViewModel
|
||||||
import net.awan.pipelines.ui.PipelinesApp
|
import net.awan.pipelines.ui.PipelinesApp
|
||||||
import net.awan.pipelines.ui.runIdFromDeepLink
|
import net.awan.pipelines.ui.runLinkFromDeepLink
|
||||||
import net.awan.pipelines.ui.theme.PipelinesTheme
|
import net.awan.pipelines.ui.theme.PipelinesTheme
|
||||||
|
|
||||||
class MainActivity : ComponentActivity() {
|
class MainActivity : ComponentActivity() {
|
||||||
// The run a deep link asks to open — the notification's `pipelines://run/<id>`
|
// The run a deep link asks to open — the notification's `pipelines://run/<id>`
|
||||||
// click action. It is read from the launch or update intent and cleared once
|
// click action — and what inside it to open (a waiting run's `decide` action
|
||||||
// PipelinesApp has opened it, so a recomposition never re-navigates.
|
// opens its decision sheet). Both are read from the launch or update intent
|
||||||
|
// and cleared once PipelinesApp has opened them, so a recomposition never
|
||||||
|
// re-navigates.
|
||||||
private var deepLinkedRunId by mutableStateOf<Long?>(null)
|
private var deepLinkedRunId by mutableStateOf<Long?>(null)
|
||||||
|
private var deepLinkedAction by mutableStateOf<String?>(null)
|
||||||
|
|
||||||
override fun onCreate(savedInstanceState: Bundle?) {
|
override fun onCreate(savedInstanceState: Bundle?) {
|
||||||
super.onCreate(savedInstanceState)
|
super.onCreate(savedInstanceState)
|
||||||
deepLinkedRunId = runIdFromDeepLink(intent?.data?.toString())
|
applyDeepLink(intent)
|
||||||
enableEdgeToEdge()
|
enableEdgeToEdge()
|
||||||
val app = application as PipelinesApplication
|
val app = application as PipelinesApplication
|
||||||
setContent {
|
setContent {
|
||||||
@@ -31,7 +34,11 @@ class MainActivity : ComponentActivity() {
|
|||||||
PipelinesApp(
|
PipelinesApp(
|
||||||
vm = vm,
|
vm = vm,
|
||||||
initialRunId = deepLinkedRunId,
|
initialRunId = deepLinkedRunId,
|
||||||
onInitialRunHandled = { deepLinkedRunId = null },
|
initialRunAction = deepLinkedAction,
|
||||||
|
onInitialRunHandled = {
|
||||||
|
deepLinkedRunId = null
|
||||||
|
deepLinkedAction = null
|
||||||
|
},
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -41,6 +48,12 @@ class MainActivity : ComponentActivity() {
|
|||||||
override fun onNewIntent(intent: Intent) {
|
override fun onNewIntent(intent: Intent) {
|
||||||
super.onNewIntent(intent)
|
super.onNewIntent(intent)
|
||||||
setIntent(intent)
|
setIntent(intent)
|
||||||
deepLinkedRunId = runIdFromDeepLink(intent.data?.toString())
|
applyDeepLink(intent)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun applyDeepLink(intent: Intent?) {
|
||||||
|
val link = runLinkFromDeepLink(intent?.data?.toString())
|
||||||
|
deepLinkedRunId = link?.runId
|
||||||
|
deepLinkedAction = link?.action
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -7,6 +7,7 @@ import kotlinx.coroutines.SupervisorJob
|
|||||||
import net.awan.pipelines.data.PipelinesRepository
|
import net.awan.pipelines.data.PipelinesRepository
|
||||||
import net.awan.pipelines.data.SettingsRepository
|
import net.awan.pipelines.data.SettingsRepository
|
||||||
import net.awan.pipelines.data.transport.PipelinesClient
|
import net.awan.pipelines.data.transport.PipelinesClient
|
||||||
|
import net.awan.pipelines.notify.RunNotifier
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Holds the single long-lived repository, WebSocket client and application
|
* Holds the single long-lived repository, WebSocket client and application
|
||||||
@@ -21,4 +22,16 @@ class PipelinesApplication : Application() {
|
|||||||
val client: PipelinesClient by lazy { PipelinesClient(scope = applicationScope) }
|
val client: PipelinesClient by lazy { PipelinesClient(scope = applicationScope) }
|
||||||
|
|
||||||
val repository: PipelinesRepository by lazy { PipelinesRepository(client, settings) }
|
val repository: PipelinesRepository by lazy { PipelinesRepository(client, settings) }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Posts the app's own Android notifications for runs that need the operator.
|
||||||
|
* Its channel is created once, before anything can post, so a notification is
|
||||||
|
* never dropped for a missing channel.
|
||||||
|
*/
|
||||||
|
val runNotifier: RunNotifier by lazy { RunNotifier(this) }
|
||||||
|
|
||||||
|
override fun onCreate() {
|
||||||
|
super.onCreate()
|
||||||
|
runNotifier.ensureChannel()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -71,6 +71,13 @@ class SettingsRepository(context: Context) {
|
|||||||
private val _attention = MutableStateFlow(prefs.getString(KEY_ATTENTION, "").orEmpty())
|
private val _attention = MutableStateFlow(prefs.getString(KEY_ATTENTION, "").orEmpty())
|
||||||
val attention: StateFlow<String> = _attention.asStateFlow()
|
val attention: StateFlow<String> = _attention.asStateFlow()
|
||||||
|
|
||||||
|
// Whether the operator has already been asked for POST_NOTIFICATIONS. Asked
|
||||||
|
// once and remembered, so the rationale and the system dialog never nag: the
|
||||||
|
// app degrades to its in-app attention surface instead.
|
||||||
|
private val _notificationPermissionAsked =
|
||||||
|
MutableStateFlow(prefs.getBoolean(KEY_NOTIFICATION_PERMISSION_ASKED, false))
|
||||||
|
val notificationPermissionAsked: StateFlow<Boolean> = _notificationPermissionAsked.asStateFlow()
|
||||||
|
|
||||||
fun setServerUrl(value: String) {
|
fun setServerUrl(value: String) {
|
||||||
val trimmed = value.trim()
|
val trimmed = value.trim()
|
||||||
_serverUrl.value = trimmed
|
_serverUrl.value = trimmed
|
||||||
@@ -141,6 +148,13 @@ class SettingsRepository(context: Context) {
|
|||||||
prefs.edit().putString(KEY_ATTENTION, value).apply()
|
prefs.edit().putString(KEY_ATTENTION, value).apply()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** Records that the runtime notification permission has been asked for (or declined). */
|
||||||
|
fun setNotificationPermissionAsked(asked: Boolean) {
|
||||||
|
if (asked == _notificationPermissionAsked.value) return
|
||||||
|
_notificationPermissionAsked.value = asked
|
||||||
|
prefs.edit().putBoolean(KEY_NOTIFICATION_PERMISSION_ASKED, asked).apply()
|
||||||
|
}
|
||||||
|
|
||||||
/** True only when the user has explicitly supplied both required values. */
|
/** True only when the user has explicitly supplied both required values. */
|
||||||
fun isConfigured(): Boolean = _serverUrl.value.isNotBlank() && _workspace.value.isNotBlank()
|
fun isConfigured(): Boolean = _serverUrl.value.isNotBlank() && _workspace.value.isNotBlank()
|
||||||
|
|
||||||
@@ -158,5 +172,6 @@ class SettingsRepository(context: Context) {
|
|||||||
const val KEY_CHAT_OVERRIDES = "chat_overrides"
|
const val KEY_CHAT_OVERRIDES = "chat_overrides"
|
||||||
const val KEY_CHAT_SEEN = "chat_seen"
|
const val KEY_CHAT_SEEN = "chat_seen"
|
||||||
const val KEY_ATTENTION = "attention"
|
const val KEY_ATTENTION = "attention"
|
||||||
|
const val KEY_NOTIFICATION_PERMISSION_ASKED = "notification_permission_asked"
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -0,0 +1,249 @@
|
|||||||
|
package net.awan.pipelines.notify
|
||||||
|
|
||||||
|
import net.awan.pipelines.ui.AttentionEntry
|
||||||
|
import net.awan.pipelines.ui.AttentionKind
|
||||||
|
import net.awan.pipelines.ui.RUN_DEEP_LINK_ACTION_DECIDE
|
||||||
|
import net.awan.pipelines.ui.RUN_DEEP_LINK_ACTION_PARAM
|
||||||
|
import net.awan.pipelines.ui.RUN_DEEP_LINK_PREFIX
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The one place the app decides what becomes an Android notification.
|
||||||
|
*
|
||||||
|
* The operator's rule is the same on every surface: only a run waiting for a
|
||||||
|
* decision and a run that failed ask for a person. A successful run, a running
|
||||||
|
* run or a cancelled one raises nothing, so the system tray can never fill with
|
||||||
|
* work that is not actionable. The mapping reads the attention model's kinds
|
||||||
|
* (see `ui/Attention.kt`), so the tray and the in-app surface can never disagree
|
||||||
|
* about what needs the operator.
|
||||||
|
*
|
||||||
|
* Everything here is pure — no Android types, no `Context`, no clock — so the
|
||||||
|
* mapping, the coalescing and clearing rules, the permission paths and the tap
|
||||||
|
* destination are all unit-tested on the JVM without a device.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/** The two run events that raise a notification. */
|
||||||
|
enum class RunAlertKind { Decision, Failed }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Where the app's notifications actually go. The ViewModel depends on this, not
|
||||||
|
* on Android, so the run-watch logic stays free of `Context` and the concrete
|
||||||
|
* poster ([RunNotifier]) is the only Android part.
|
||||||
|
*/
|
||||||
|
interface RunAlertSink {
|
||||||
|
/** Whether a notification can be shown right now (permission granted, not silenced). */
|
||||||
|
fun notificationsAllowed(): Boolean
|
||||||
|
|
||||||
|
/** Moves the tray to exactly the alerts the attention list currently raises. */
|
||||||
|
fun sync(alerts: List<RunAlert>)
|
||||||
|
|
||||||
|
/** Clears one run's notifications because the operator reached it. */
|
||||||
|
fun arrived(runId: Long)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A sink that shows nothing: the default until the Android poster is wired in. */
|
||||||
|
object NoRunAlerts : RunAlertSink {
|
||||||
|
override fun notificationsAllowed(): Boolean = false
|
||||||
|
override fun sync(alerts: List<RunAlert>) = Unit
|
||||||
|
override fun arrived(runId: Long) = Unit
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Where a notification's tap lands inside the app. */
|
||||||
|
enum class AlertTapTarget { DecisionSheet, Run }
|
||||||
|
|
||||||
|
/** One run that needs the operator, as the tray shows it. */
|
||||||
|
data class RunAlert(
|
||||||
|
val runId: Long,
|
||||||
|
val kind: RunAlertKind,
|
||||||
|
val title: String,
|
||||||
|
val text: String,
|
||||||
|
) {
|
||||||
|
/** The stable identity of one run+event-kind alert; the unit of dedupe. */
|
||||||
|
val key: String get() = alertKey(runId, kind)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The identity of one run+kind alert: exactly one notification, never repeated. */
|
||||||
|
internal fun alertKey(runId: Long, kind: RunAlertKind): String = "$runId:${kind.name}"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The alert kind an attention kind maps to. The attention model already holds
|
||||||
|
* only what needs a person — a waiting run ([AttentionKind.Decision]) and a
|
||||||
|
* failed run ([AttentionKind.Failed]) — so every entry raises exactly one
|
||||||
|
* notification and nothing else can.
|
||||||
|
*/
|
||||||
|
fun alertKindOf(kind: AttentionKind): RunAlertKind = when (kind) {
|
||||||
|
AttentionKind.Decision -> RunAlertKind.Decision
|
||||||
|
AttentionKind.Failed -> RunAlertKind.Failed
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The short headline a notification shows for one kind. */
|
||||||
|
internal fun alertTitle(kind: RunAlertKind): String = when (kind) {
|
||||||
|
RunAlertKind.Decision -> "A run needs your decision"
|
||||||
|
RunAlertKind.Failed -> "A run failed"
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The line naming the run: its label, then the pipeline it belongs to. */
|
||||||
|
internal fun alertText(entry: AttentionEntry): String =
|
||||||
|
if (entry.pipeline.isBlank() || entry.pipeline == entry.label) {
|
||||||
|
entry.label
|
||||||
|
} else {
|
||||||
|
"${entry.label} · ${entry.pipeline}"
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The alerts the current attention list raises, in the surface's own order
|
||||||
|
* (decision, then failure). The attention list already holds only what needs a
|
||||||
|
* person, so nothing that needs nobody can reach the tray.
|
||||||
|
*/
|
||||||
|
fun runAlerts(entries: List<AttentionEntry>): List<RunAlert> = entries.map { entry ->
|
||||||
|
val kind = alertKindOf(entry.kind)
|
||||||
|
RunAlert(runId = entry.runId, kind = kind, title = alertTitle(kind), text = alertText(entry))
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The one summary a coalesced group shows: how many runs need the operator and
|
||||||
|
* what each is. Present only when more than one alert is pending, so a single
|
||||||
|
* run never gets a redundant wrapper and several are one grouped notification
|
||||||
|
* rather than a pile.
|
||||||
|
*/
|
||||||
|
data class AlertSummary(
|
||||||
|
val count: Int,
|
||||||
|
val title: String,
|
||||||
|
val text: String,
|
||||||
|
val lines: List<String>,
|
||||||
|
)
|
||||||
|
|
||||||
|
/** The grouped summary for [alerts], or null when at most one is pending. */
|
||||||
|
fun alertSummary(alerts: List<RunAlert>): AlertSummary? {
|
||||||
|
if (alerts.size < 2) return null
|
||||||
|
val waiting = alerts.count { it.kind == RunAlertKind.Decision }
|
||||||
|
val failed = alerts.count { it.kind == RunAlertKind.Failed }
|
||||||
|
val counts = buildList {
|
||||||
|
if (waiting > 0) add(if (waiting == 1) "1 waiting for you" else "$waiting waiting for you")
|
||||||
|
if (failed > 0) add(if (failed == 1) "1 failed" else "$failed failed")
|
||||||
|
}.joinToString(" · ")
|
||||||
|
return AlertSummary(
|
||||||
|
count = alerts.size,
|
||||||
|
title = "${alerts.size} runs need you",
|
||||||
|
text = counts,
|
||||||
|
lines = alerts.map { "${it.title} — ${it.text}" },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The alerts to post and the keys to cancel after one reconciliation. */
|
||||||
|
data class AlertDelta(val post: List<RunAlert>, val cancel: List<RunAlert>) {
|
||||||
|
val isEmpty: Boolean get() = post.isEmpty() && cancel.isEmpty()
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* What the tray is currently showing, keyed by run+kind. It is what makes the
|
||||||
|
* notifications deduplicated and non-repeating:
|
||||||
|
*
|
||||||
|
* - [reconcile] posts only a run+kind that is not already shown, so a run that
|
||||||
|
* stays failed or waiting is never re-posted (no storm, no duplicate).
|
||||||
|
* - It cancels exactly the keys that left the desired set, so a resolved,
|
||||||
|
* answered or dismissed run's notification is cleared.
|
||||||
|
* - [arrived] cancels one run's notifications when the operator reaches it, but
|
||||||
|
* keeps its keys, so arriving at a still-waiting run does not make the next
|
||||||
|
* reconciliation post it again.
|
||||||
|
*/
|
||||||
|
class AlertLedger {
|
||||||
|
|
||||||
|
private val posted = LinkedHashMap<String, RunAlert>()
|
||||||
|
|
||||||
|
/** Keys the operator already reached, kept for dedupe but no longer visible. */
|
||||||
|
private val hidden = LinkedHashSet<String>()
|
||||||
|
|
||||||
|
/** The alerts currently shown, by key. */
|
||||||
|
val shown: Map<String, RunAlert> get() = posted.toMap()
|
||||||
|
|
||||||
|
/** The alerts still on screen: posted and not cleared by the operator arriving. */
|
||||||
|
fun visible(): List<RunAlert> = posted.values.filter { it.key !in hidden }
|
||||||
|
|
||||||
|
/** The post/cancel delta that moves what is shown to exactly [desired]. */
|
||||||
|
fun reconcile(desired: List<RunAlert>): AlertDelta {
|
||||||
|
val desiredByKey = desired.associateBy { it.key }
|
||||||
|
val toPost = desired.filter { it.key !in posted }
|
||||||
|
val toCancel = posted.values.filter { it.key !in desiredByKey }
|
||||||
|
toPost.forEach {
|
||||||
|
posted[it.key] = it
|
||||||
|
// A new event for a run the operator reached earlier is shown again.
|
||||||
|
hidden.remove(it.key)
|
||||||
|
}
|
||||||
|
toCancel.forEach {
|
||||||
|
posted.remove(it.key)
|
||||||
|
hidden.remove(it.key)
|
||||||
|
}
|
||||||
|
return AlertDelta(post = toPost, cancel = toCancel)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The alerts to cancel because the operator arrived at [runId]. Their keys
|
||||||
|
* are kept, so a run that is still waiting is not re-notified on the next
|
||||||
|
* reconciliation, and they are hidden from the visible set so a grouped
|
||||||
|
* summary stops counting them; when the run leaves the attention list it is
|
||||||
|
* removed here.
|
||||||
|
*/
|
||||||
|
fun arrived(runId: Long): List<RunAlert> {
|
||||||
|
val arrived = posted.values.filter { it.runId == runId }
|
||||||
|
hidden.addAll(arrived.map { it.key })
|
||||||
|
return arrived
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Forgets everything (used when permission is revoked, so a later grant re-posts). */
|
||||||
|
fun clear() {
|
||||||
|
posted.clear()
|
||||||
|
hidden.clear()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Whether the notification permission should be requested now, and why.
|
||||||
|
*
|
||||||
|
* The request happens at most once: [granted] means there is nothing to ask,
|
||||||
|
* [asked] means the operator has already been asked (or refused) and must never
|
||||||
|
* be nagged again, and [trigger] is the sensible moment (the first time a run
|
||||||
|
* needs them, or the operator opening the attention surface). Only "not granted,
|
||||||
|
* never asked, and something actually needs the operator" asks.
|
||||||
|
*/
|
||||||
|
data class AlertPermissionPrompt(val request: Boolean, val rationale: String?)
|
||||||
|
|
||||||
|
/** The rationale shown once before the system permission dialog. */
|
||||||
|
const val NOTIFICATION_RATIONALE: String =
|
||||||
|
"Pipelines can notify you when a run is waiting for your decision or has failed. " +
|
||||||
|
"Without it, those runs still appear in the in-app Needs you surface."
|
||||||
|
|
||||||
|
/** The permission prompt decision for the current state. Pure, so every path is tested. */
|
||||||
|
fun alertPermissionPrompt(granted: Boolean, asked: Boolean, trigger: Boolean): AlertPermissionPrompt =
|
||||||
|
when {
|
||||||
|
granted -> AlertPermissionPrompt(request = false, rationale = null)
|
||||||
|
asked -> AlertPermissionPrompt(request = false, rationale = null)
|
||||||
|
!trigger -> AlertPermissionPrompt(request = false, rationale = null)
|
||||||
|
else -> AlertPermissionPrompt(request = true, rationale = NOTIFICATION_RATIONALE)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The tap destination one kind opens. */
|
||||||
|
fun alertTapTarget(kind: RunAlertKind): AlertTapTarget = when (kind) {
|
||||||
|
RunAlertKind.Decision -> AlertTapTarget.DecisionSheet
|
||||||
|
RunAlertKind.Failed -> AlertTapTarget.Run
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The deep link a notification's tap opens. A waiting run carries the decide
|
||||||
|
* action so it lands on the decision sheet; a failed run opens the run itself.
|
||||||
|
* Both resolve through the app's one `pipelines://run/<id>` deep link, which
|
||||||
|
* only ever opens a run and starts nothing.
|
||||||
|
*/
|
||||||
|
fun alertDeepLink(runId: Long, kind: RunAlertKind): String {
|
||||||
|
val base = "$RUN_DEEP_LINK_PREFIX$runId"
|
||||||
|
return when (alertTapTarget(kind)) {
|
||||||
|
AlertTapTarget.DecisionSheet -> "$base?$RUN_DEEP_LINK_ACTION_PARAM=$RUN_DEEP_LINK_ACTION_DECIDE"
|
||||||
|
AlertTapTarget.Run -> base
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The notification id for one run+kind: stable for the life of the run, so
|
||||||
|
* re-posting the same event updates in place instead of stacking a duplicate.
|
||||||
|
*/
|
||||||
|
fun alertNotificationId(runId: Long, kind: RunAlertKind): Int =
|
||||||
|
((runId * 2L + kind.ordinal) and 0x7FFFFFFFL).toInt()
|
||||||
@@ -0,0 +1,187 @@
|
|||||||
|
package net.awan.pipelines.notify
|
||||||
|
|
||||||
|
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.content.pm.PackageManager
|
||||||
|
import android.net.Uri
|
||||||
|
import android.os.Build
|
||||||
|
import androidx.core.app.NotificationCompat
|
||||||
|
import androidx.core.app.NotificationManagerCompat
|
||||||
|
import androidx.core.content.ContextCompat
|
||||||
|
import net.awan.pipelines.MainActivity
|
||||||
|
import net.awan.pipelines.R
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The app's own Android notifications for runs that need the operator.
|
||||||
|
*
|
||||||
|
* It is deliberately thin: every decision — what becomes an alert, when several
|
||||||
|
* are one grouped summary, when one is cleared, whether the permission should be
|
||||||
|
* asked — is the pure [RunAlerts] model, unit-tested on the JVM. This class only
|
||||||
|
* creates the channel and posts/cancels through [NotificationManagerCompat], so
|
||||||
|
* it holds no rule of its own that a test would have to reach through Android.
|
||||||
|
*
|
||||||
|
* Notifications are posted from the app's own process. While the app is
|
||||||
|
* backgrounded the process (and the run subscription feeding [sync]) is alive, so
|
||||||
|
* the events still arrive and are shown; the server also publishes the same two
|
||||||
|
* events to the operator's ntfy topic, which is the out-of-process backstop when
|
||||||
|
* the app's process is killed.
|
||||||
|
*/
|
||||||
|
class RunNotifier(private val context: Context) : RunAlertSink {
|
||||||
|
|
||||||
|
private val manager = NotificationManagerCompat.from(context)
|
||||||
|
private val ledger = AlertLedger()
|
||||||
|
|
||||||
|
/** Whether the tray last showed a grouped summary, so a threshold change re-groups. */
|
||||||
|
private var grouped = false
|
||||||
|
|
||||||
|
/** Creates the one channel runs that need the operator post into. Idempotent. */
|
||||||
|
fun ensureChannel() {
|
||||||
|
val channel = NotificationChannel(
|
||||||
|
CHANNEL_ID,
|
||||||
|
"Runs that need you",
|
||||||
|
NotificationManager.IMPORTANCE_HIGH,
|
||||||
|
).apply {
|
||||||
|
description = "A run waiting for your decision or a run that failed"
|
||||||
|
}
|
||||||
|
manager.createNotificationChannel(channel)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Whether a notification can actually be shown right now: the POST_NOTIFICATIONS
|
||||||
|
* runtime permission on Android 13+, the app's own notification switch before
|
||||||
|
* that. When false the app degrades to the in-app attention surface and shows
|
||||||
|
* nothing here, rather than pretending a notification was posted.
|
||||||
|
*/
|
||||||
|
override fun notificationsAllowed(): Boolean =
|
||||||
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
|
||||||
|
ContextCompat.checkSelfPermission(context, POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
|
||||||
|
} else {
|
||||||
|
manager.areNotificationsEnabled()
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Moves the tray to exactly the alerts the attention list currently raises:
|
||||||
|
* each run+kind posted once (never repeated while it stays failed or waiting),
|
||||||
|
* a run that no longer needs the operator cleared, and several pending runs
|
||||||
|
* coalesced into one grouped summary. Without the permission nothing is posted
|
||||||
|
* and the ledger is forgotten, so a later grant re-posts rather than assuming.
|
||||||
|
*/
|
||||||
|
override fun sync(alerts: List<RunAlert>) {
|
||||||
|
if (!notificationsAllowed()) {
|
||||||
|
ledger.clear()
|
||||||
|
manager.cancelAll()
|
||||||
|
grouped = false
|
||||||
|
return
|
||||||
|
}
|
||||||
|
val delta = ledger.reconcile(alerts)
|
||||||
|
delta.cancel.forEach { manager.cancel(alertNotificationId(it.runId, it.kind)) }
|
||||||
|
render(visible = ledger.visible(), delta = delta)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Clears one run's notifications because the operator reached it, and refreshes
|
||||||
|
* the grouped summary so it stops counting a run the operator has already
|
||||||
|
* opened. The ledger keeps the run+kind, so a run that stays waiting is not
|
||||||
|
* re-notified.
|
||||||
|
*/
|
||||||
|
override fun arrived(runId: Long) {
|
||||||
|
if (!notificationsAllowed()) return
|
||||||
|
val arrived = ledger.arrived(runId)
|
||||||
|
if (arrived.isEmpty()) return
|
||||||
|
arrived.forEach { manager.cancel(alertNotificationId(it.runId, it.kind)) }
|
||||||
|
render(visible = ledger.visible(), delta = AlertDelta(post = emptyList(), cancel = emptyList()))
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Draws the still-visible alerts at the group/summary shape their count needs.
|
||||||
|
* A move across the one-versus-many boundary re-posts the visible children once
|
||||||
|
* (only-alert-once keeps it silent); otherwise only genuinely new alerts are
|
||||||
|
* posted, so nothing is repeated or re-alerted.
|
||||||
|
*/
|
||||||
|
private fun render(visible: List<RunAlert>, delta: AlertDelta) {
|
||||||
|
val groupedNow = visible.size >= 2
|
||||||
|
val toPost = if (groupedNow != grouped) visible else delta.post
|
||||||
|
toPost.forEach { manager.notify(alertNotificationId(it.runId, it.kind), buildAlert(it, groupedNow)) }
|
||||||
|
val summary = if (groupedNow) alertSummary(visible) else null
|
||||||
|
if (summary != null) manager.notify(SUMMARY_ID, buildSummary(summary)) else manager.cancel(SUMMARY_ID)
|
||||||
|
grouped = groupedNow
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun buildAlert(alert: RunAlert, grouped: Boolean): Notification {
|
||||||
|
val builder = NotificationCompat.Builder(context, CHANNEL_ID)
|
||||||
|
.setSmallIcon(R.drawable.ic_notification)
|
||||||
|
.setContentTitle(alert.title)
|
||||||
|
.setContentText(alert.text)
|
||||||
|
.setContentIntent(tapIntent(alert))
|
||||||
|
.setCategory(NotificationCompat.CATEGORY_STATUS)
|
||||||
|
.setAutoCancel(true)
|
||||||
|
.setOnlyAlertOnce(true)
|
||||||
|
.setPriority(NotificationCompat.PRIORITY_HIGH)
|
||||||
|
if (grouped) {
|
||||||
|
builder.setGroup(GROUP_KEY)
|
||||||
|
// Several arriving together alert once, through the summary, instead of
|
||||||
|
// a burst of per-run sounds.
|
||||||
|
builder.setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_SUMMARY)
|
||||||
|
}
|
||||||
|
return builder.build()
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun buildSummary(summary: AlertSummary): Notification =
|
||||||
|
NotificationCompat.Builder(context, CHANNEL_ID)
|
||||||
|
.setSmallIcon(R.drawable.ic_notification)
|
||||||
|
.setContentTitle(summary.title)
|
||||||
|
.setContentText(summary.text)
|
||||||
|
.setStyle(NotificationCompat.InboxStyle().also { style ->
|
||||||
|
summary.lines.forEach(style::addLine)
|
||||||
|
})
|
||||||
|
// The group's own tap opens the app, where the Needs you chip lists
|
||||||
|
// every run the summary counts; the individual taps open each run.
|
||||||
|
.setContentIntent(openAppIntent())
|
||||||
|
.setGroup(GROUP_KEY)
|
||||||
|
.setGroupSummary(true)
|
||||||
|
.setCategory(NotificationCompat.CATEGORY_STATUS)
|
||||||
|
.setAutoCancel(true)
|
||||||
|
.setOnlyAlertOnce(true)
|
||||||
|
.setPriority(NotificationCompat.PRIORITY_HIGH)
|
||||||
|
.build()
|
||||||
|
|
||||||
|
/** The tap intent: the run's own deep link, which only ever opens a run. */
|
||||||
|
private fun tapIntent(alert: RunAlert): PendingIntent {
|
||||||
|
val intent = Intent(Intent.ACTION_VIEW, Uri.parse(alertDeepLink(alert.runId, alert.kind)), context, MainActivity::class.java)
|
||||||
|
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
|
||||||
|
return PendingIntent.getActivity(
|
||||||
|
context,
|
||||||
|
alertNotificationId(alert.runId, alert.kind),
|
||||||
|
intent,
|
||||||
|
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Opens the app (where the attention surface lives) without naming a run. */
|
||||||
|
private fun openAppIntent(): PendingIntent {
|
||||||
|
val intent = Intent(context, MainActivity::class.java)
|
||||||
|
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
|
||||||
|
return PendingIntent.getActivity(
|
||||||
|
context,
|
||||||
|
SUMMARY_ID,
|
||||||
|
intent,
|
||||||
|
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
private companion object {
|
||||||
|
const val CHANNEL_ID = "runs_need_you"
|
||||||
|
|
||||||
|
/** The single grouped-summary notification id; children derive from run+kind. */
|
||||||
|
const val SUMMARY_ID = 1
|
||||||
|
|
||||||
|
const val GROUP_KEY = "net.awan.pipelines.RUNS"
|
||||||
|
|
||||||
|
/** The POST_NOTIFICATIONS permission name, spelled out to keep the import list lean. */
|
||||||
|
const val POST_NOTIFICATIONS = "android.permission.POST_NOTIFICATIONS"
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -38,6 +38,9 @@ import net.awan.pipelines.data.protocol.SessionEvidence
|
|||||||
import net.awan.pipelines.data.protocol.Template
|
import net.awan.pipelines.data.protocol.Template
|
||||||
import net.awan.pipelines.data.transport.ConnectionState
|
import net.awan.pipelines.data.transport.ConnectionState
|
||||||
import net.awan.pipelines.data.transport.ServerUrl
|
import net.awan.pipelines.data.transport.ServerUrl
|
||||||
|
import net.awan.pipelines.notify.NoRunAlerts
|
||||||
|
import net.awan.pipelines.notify.RunAlertSink
|
||||||
|
import net.awan.pipelines.notify.runAlerts
|
||||||
import net.awan.pipelines.ui.chat.ChatAttachment
|
import net.awan.pipelines.ui.chat.ChatAttachment
|
||||||
import net.awan.pipelines.ui.chat.ChatSessionOverrides
|
import net.awan.pipelines.ui.chat.ChatSessionOverrides
|
||||||
import net.awan.pipelines.ui.chat.ChatSeenState
|
import net.awan.pipelines.ui.chat.ChatSeenState
|
||||||
@@ -61,6 +64,7 @@ data class LoadState<T>(
|
|||||||
class AppViewModel(
|
class AppViewModel(
|
||||||
private val repository: PipelinesRepository,
|
private val repository: PipelinesRepository,
|
||||||
private val settings: SettingsRepository,
|
private val settings: SettingsRepository,
|
||||||
|
private val alertSink: RunAlertSink = NoRunAlerts,
|
||||||
) : ViewModel() {
|
) : ViewModel() {
|
||||||
|
|
||||||
val connectionState: StateFlow<ConnectionState> = repository.connectionState
|
val connectionState: StateFlow<ConnectionState> = repository.connectionState
|
||||||
@@ -135,6 +139,20 @@ class AppViewModel(
|
|||||||
attentionEntries(runs.data?.runs.orEmpty(), state)
|
attentionEntries(runs.data?.runs.orEmpty(), state)
|
||||||
}.stateIn(viewModelScope, SharingStarted.Eagerly, emptyList())
|
}.stateIn(viewModelScope, SharingStarted.Eagerly, emptyList())
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Whether the app's notifications can actually be shown right now (the
|
||||||
|
* POST_NOTIFICATIONS permission on Android 13+, the app's switch before that).
|
||||||
|
* The permission layer reads this to decide whether to ask; the app degrades to
|
||||||
|
* its in-app attention surface when it is false rather than pretending a
|
||||||
|
* notification was posted. Refreshed whenever the app returns to the front, so
|
||||||
|
* a change made in system settings is reflected.
|
||||||
|
*/
|
||||||
|
private val _notificationsAllowed = MutableStateFlow(false)
|
||||||
|
val notificationsAllowed: StateFlow<Boolean> = _notificationsAllowed.asStateFlow()
|
||||||
|
|
||||||
|
/** Whether the runtime notification permission has already been asked for (or refused). */
|
||||||
|
val notificationPermissionAsked: StateFlow<Boolean> = settings.notificationPermissionAsked
|
||||||
|
|
||||||
// Debounces keystrokes and gates replies so an older query can never land on
|
// Debounces keystrokes and gates replies so an older query can never land on
|
||||||
// top of a newer one; the pure ordering lives in SearchSequencer.
|
// top of a newer one; the pure ordering lives in SearchSequencer.
|
||||||
private val searchSequencer = SearchSequencer()
|
private val searchSequencer = SearchSequencer()
|
||||||
@@ -209,6 +227,7 @@ class AppViewModel(
|
|||||||
observeChatOverrides()
|
observeChatOverrides()
|
||||||
observeChatSeen()
|
observeChatSeen()
|
||||||
observeAttention()
|
observeAttention()
|
||||||
|
observeRunAlerts()
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -543,20 +562,54 @@ class AppViewModel(
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Deliberately dismisses one attention entry for good, so a still-waiting or
|
* Feeds the app's Android notifications from the same attention list the
|
||||||
* still-failed run the operator has chosen to ignore stops asking.
|
* in-app surface shows: a run waiting for a decision and a failed run each
|
||||||
|
* become one notification (or, when several need the operator, one grouped
|
||||||
|
* summary), and a run that leaves the list — resolved, answered or dismissed —
|
||||||
|
* has its notification cleared. Nothing here decides what matters; it is the
|
||||||
|
* pure alert model applied.
|
||||||
*/
|
*/
|
||||||
fun dismissAttention(runId: Long, kind: AttentionKind) {
|
private fun observeRunAlerts() {
|
||||||
_attentionState.value = _attentionState.value.dismissed(attentionKey(runId, kind))
|
_notificationsAllowed.value = alertSink.notificationsAllowed()
|
||||||
|
viewModelScope.launch {
|
||||||
|
attention.collect { entries -> alertSink.sync(runAlerts(entries)) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Re-reads whether notifications can be shown; called when the app comes to the front. */
|
||||||
|
fun refreshNotificationsAllowed() {
|
||||||
|
val allowed = alertSink.notificationsAllowed()
|
||||||
|
_notificationsAllowed.value = allowed
|
||||||
|
// A grant may have happened after the alert was already needed (the
|
||||||
|
// operator answered the system dialog or changed the setting): re-sync so
|
||||||
|
// the still-pending run is shown now rather than waiting for the next push.
|
||||||
|
// The ledger still prevents re-posting anything already shown.
|
||||||
|
if (allowed) alertSink.sync(runAlerts(attention.value))
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Records that the runtime notification permission has been asked for, so it never nags. */
|
||||||
|
fun markNotificationPermissionAsked() {
|
||||||
|
settings.setNotificationPermissionAsked(true)
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Records that the operator has looked at the finished runs now on the
|
* The operator has reached [runId]: its notification is cleared, and — because
|
||||||
* surface, so a run that merely finished since the last look clears on this
|
* the run is still waiting or failed — it is not posted again. Called through
|
||||||
* look rather than reappearing. Called when the list is opened.
|
* the one path that opens a run, so a tap, an attention tap and a deep link all
|
||||||
|
* clear the same way.
|
||||||
*/
|
*/
|
||||||
fun sawFinishedAttention(ids: Collection<Long>) {
|
fun arrivedAtRun(runId: Long) {
|
||||||
_attentionState.value = _attentionState.value.lookedAtFinished(ids.toSet())
|
alertSink.arrived(runId)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Deliberately dismisses one attention entry for good, so a still-waiting or
|
||||||
|
* still-failed run the operator has chosen to ignore stops asking. The
|
||||||
|
* notification for it is cleared by the same attention change the app's
|
||||||
|
* notifications are fed from.
|
||||||
|
*/
|
||||||
|
fun dismissAttention(runId: Long, kind: AttentionKind) {
|
||||||
|
_attentionState.value = _attentionState.value.dismissed(attentionKey(runId, kind))
|
||||||
}
|
}
|
||||||
|
|
||||||
fun updateServerUrlDraft(value: String) {
|
fun updateServerUrlDraft(value: String) {
|
||||||
@@ -1133,7 +1186,7 @@ class AppViewModel(
|
|||||||
private const val CHAT_HISTORY_LIMIT = 200
|
private const val CHAT_HISTORY_LIMIT = 200
|
||||||
|
|
||||||
fun factory(app: PipelinesApplication) = viewModelFactory {
|
fun factory(app: PipelinesApplication) = viewModelFactory {
|
||||||
initializer { AppViewModel(app.repository, app.settings) }
|
initializer { AppViewModel(app.repository, app.settings, app.runNotifier) }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -8,22 +8,21 @@ import net.awan.pipelines.data.protocol.RunSummary
|
|||||||
* The one place the app decides what needs the operator and how much it matters.
|
* The one place the app decides what needs the operator and how much it matters.
|
||||||
*
|
*
|
||||||
* A run's server status maps to at most one [AttentionKind]: a run parked on a
|
* A run's server status maps to at most one [AttentionKind]: a run parked on a
|
||||||
* person ([AttentionKind.Decision]) is the most important, a failed run
|
* person ([AttentionKind.Decision]) is the most important and a failed run
|
||||||
* ([AttentionKind.Failed]) next, and a run that finished since the operator last
|
* ([AttentionKind.Failed]) next. Everything else — queued, running, succeeded,
|
||||||
* looked ([AttentionKind.Finished]) last. Everything else — queued, running,
|
* canceled, interrupted — asks nothing and is not listed, so the surface (and the
|
||||||
* canceled, interrupted — asks nothing and is not listed, so the surface can only
|
* system tray fed from it) can only ever show something that is genuinely
|
||||||
* ever show something that is genuinely actionable.
|
* actionable. A successful run is never announced.
|
||||||
*
|
*
|
||||||
* The list is advanced from the run events the server already pushes: the same
|
* The list is advanced from the run events the server already pushes: the same
|
||||||
* `RunSummary` rows that the runs list is folded from feed [attentionEntries], so
|
* `RunSummary` rows that the runs list is folded from feed [attentionEntries], so
|
||||||
* an entry appears and clears with no refresh and no request of its own.
|
* an entry appears and clears with no refresh and no request of its own.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
/** The three things the attention surface ranks, most important first. */
|
/** The two things the attention surface ranks, most important first. */
|
||||||
enum class AttentionKind(val rank: Int) {
|
enum class AttentionKind(val rank: Int) {
|
||||||
Decision(0),
|
Decision(0),
|
||||||
Failed(1),
|
Failed(1),
|
||||||
Finished(2),
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/** One entry on the attention surface: what run needs the operator, and why. */
|
/** One entry on the attention surface: what run needs the operator, and why. */
|
||||||
@@ -55,7 +54,6 @@ internal fun attentionKindOf(status: String): AttentionKind? =
|
|||||||
when (status.trim().lowercase()) {
|
when (status.trim().lowercase()) {
|
||||||
"waiting" -> AttentionKind.Decision
|
"waiting" -> AttentionKind.Decision
|
||||||
"failed" -> AttentionKind.Failed
|
"failed" -> AttentionKind.Failed
|
||||||
"succeeded" -> AttentionKind.Finished
|
|
||||||
else -> null
|
else -> null
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -67,22 +65,19 @@ internal fun attentionKindOf(status: String): AttentionKind? =
|
|||||||
internal fun attentionDetail(kind: AttentionKind, run: RunSummary): String = when (kind) {
|
internal fun attentionDetail(kind: AttentionKind, run: RunSummary): String = when (kind) {
|
||||||
AttentionKind.Decision -> "Waiting for your decision"
|
AttentionKind.Decision -> "Waiting for your decision"
|
||||||
AttentionKind.Failed -> run.diagnostic.trim().ifBlank { "Run failed" }
|
AttentionKind.Failed -> run.diagnostic.trim().ifBlank { "Run failed" }
|
||||||
AttentionKind.Finished -> "Finished"
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* The ordered attention list. Every run that needs the operator becomes one
|
* The ordered attention list. Every run that needs the operator becomes one
|
||||||
* entry, ranked by kind (decision, failed, finished) and then newest-first within
|
* entry, ranked by kind (decision, then failure) and then newest-first within a
|
||||||
* a kind, so the order is stable and never reshuffles between reads. An entry the
|
* kind, so the order is stable and never reshuffles between reads. An entry the
|
||||||
* operator explicitly dismissed never returns, and a finished run the operator
|
* operator explicitly dismissed never returns, and a waiting or failed run stays
|
||||||
* has already looked at stays gone; a waiting or failed run returns until it is
|
* until it is resolved or dismissed, because it is still asking.
|
||||||
* resolved or dismissed, because it is still asking.
|
|
||||||
*/
|
*/
|
||||||
internal fun attentionEntries(runs: List<RunSummary>, state: AttentionState): List<AttentionEntry> =
|
internal fun attentionEntries(runs: List<RunSummary>, state: AttentionState): List<AttentionEntry> =
|
||||||
runs.mapNotNull { run ->
|
runs.mapNotNull { run ->
|
||||||
val kind = attentionKindOf(run.status) ?: return@mapNotNull null
|
val kind = attentionKindOf(run.status) ?: return@mapNotNull null
|
||||||
if (attentionKey(run.id, kind) in state.dismissed) return@mapNotNull null
|
if (attentionKey(run.id, kind) in state.dismissed) return@mapNotNull null
|
||||||
if (kind == AttentionKind.Finished && run.id in state.finishedSeen) return@mapNotNull null
|
|
||||||
AttentionEntry(
|
AttentionEntry(
|
||||||
runId = run.id,
|
runId = run.id,
|
||||||
pipeline = run.name,
|
pipeline = run.name,
|
||||||
@@ -103,25 +98,20 @@ internal fun attentionEntries(runs: List<RunSummary>, state: AttentionState): Li
|
|||||||
* stored state:
|
* stored state:
|
||||||
*
|
*
|
||||||
* - [dismissed] is the run+kind keys the operator deliberately dismissed, so a
|
* - [dismissed] is the run+kind keys the operator deliberately dismissed, so a
|
||||||
* still-waiting run stays out of the list after an explicit dismissal.
|
* still-waiting or still-failed run stays out of the list after an explicit
|
||||||
* - [finishedSeen] is the finished runs the operator has looked at, so the list
|
* dismissal.
|
||||||
* shows a completed run once and clears it on the next look.
|
*
|
||||||
|
* A successful run is never on the surface, so there is nothing to remember as
|
||||||
|
* "already looked at": the surface only ever holds work that still asks.
|
||||||
*/
|
*/
|
||||||
@Serializable
|
@Serializable
|
||||||
data class AttentionState(
|
data class AttentionState(
|
||||||
val dismissed: Set<String> = emptySet(),
|
val dismissed: Set<String> = emptySet(),
|
||||||
val finishedSeen: Set<Long> = emptySet(),
|
|
||||||
) {
|
) {
|
||||||
/** Removes one entry for good, whatever its run goes on to do. */
|
/** Removes one entry for good, whatever its run goes on to do. */
|
||||||
fun dismissed(key: String): AttentionState =
|
fun dismissed(key: String): AttentionState =
|
||||||
if (key.isBlank() || key in dismissed) this else copy(dismissed = dismissed + key)
|
if (key.isBlank() || key in dismissed) this else copy(dismissed = dismissed + key)
|
||||||
|
|
||||||
/** Records the finished runs the operator has now looked at. */
|
|
||||||
fun lookedAtFinished(ids: Set<Long>): AttentionState {
|
|
||||||
val added = ids.filter { it > 0 && it !in finishedSeen }.toSet()
|
|
||||||
return if (added.isEmpty()) this else copy(finishedSeen = finishedSeen + added)
|
|
||||||
}
|
|
||||||
|
|
||||||
/** The one-line JSON this value is stored as; never fails on our own value. */
|
/** The one-line JSON this value is stored as; never fails on our own value. */
|
||||||
fun encode(): String = PipelinesJson.encodeToString(serializer(), this)
|
fun encode(): String = PipelinesJson.encodeToString(serializer(), this)
|
||||||
|
|
||||||
@@ -138,7 +128,45 @@ data class AttentionState(
|
|||||||
}
|
}
|
||||||
|
|
||||||
/** The deep-link scheme the run notification's click action opens. */
|
/** The deep-link scheme the run notification's click action opens. */
|
||||||
internal const val RUN_DEEP_LINK_PREFIX = "pipelines://run/"/**
|
internal const val RUN_DEEP_LINK_PREFIX = "pipelines://run/"
|
||||||
|
|
||||||
|
/** The query parameter a run deep link may carry to name what it should open. */
|
||||||
|
internal const val RUN_DEEP_LINK_ACTION_PARAM = "action"
|
||||||
|
|
||||||
|
/** The [RUN_DEEP_LINK_ACTION_PARAM] value that opens a waiting run's decision sheet. */
|
||||||
|
internal const val RUN_DEEP_LINK_ACTION_DECIDE = "decide"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* What a `pipelines://run/<id>` deep link names: the run, and an optional action
|
||||||
|
* for what inside it to open (`decide` opens the decision sheet). Null for
|
||||||
|
* anything that is not a well-formed run link, so a malformed link opens nothing
|
||||||
|
* rather than a guessed run.
|
||||||
|
*/
|
||||||
|
internal data class RunLink(val runId: Long, val action: String?)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Parses the run id and optional action from a run deep link. The id must be the
|
||||||
|
* whole path segment, so `pipelines://run/1x` and `pipelines://run/0` parse to
|
||||||
|
* null instead of being truncated to a real run.
|
||||||
|
*/
|
||||||
|
internal fun runLinkFromDeepLink(link: String?): RunLink? {
|
||||||
|
val value = link?.trim().orEmpty()
|
||||||
|
if (!value.startsWith(RUN_DEEP_LINK_PREFIX)) return null
|
||||||
|
val rest = value.removePrefix(RUN_DEEP_LINK_PREFIX)
|
||||||
|
val path = rest.substringBefore('?')
|
||||||
|
if (path.isEmpty() || !path.all { it.isDigit() }) return null
|
||||||
|
val runId = path.toLongOrNull()?.takeIf { it > 0 } ?: return null
|
||||||
|
val action = rest.substringAfter('?', "")
|
||||||
|
.split('&')
|
||||||
|
.mapNotNull { part ->
|
||||||
|
val pair = part.split('=', limit = 2)
|
||||||
|
pair.getOrNull(1)?.takeIf { pair[0] == RUN_DEEP_LINK_ACTION_PARAM && it.isNotBlank() }
|
||||||
|
}
|
||||||
|
.firstOrNull()
|
||||||
|
return RunLink(runId, action)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
* The one-line headline the indicator shows: the single most important thing when
|
* The one-line headline the indicator shows: the single most important thing when
|
||||||
* there is one entry, else the count. Pure, so it can be asserted without a device.
|
* there is one entry, else the count. Pure, so it can be asserted without a device.
|
||||||
*/
|
*/
|
||||||
@@ -147,7 +175,6 @@ internal fun attentionHeadline(entries: List<AttentionEntry>): String = when {
|
|||||||
entries.size == 1 -> when (entries[0].kind) {
|
entries.size == 1 -> when (entries[0].kind) {
|
||||||
AttentionKind.Decision -> "A run is waiting for you"
|
AttentionKind.Decision -> "A run is waiting for you"
|
||||||
AttentionKind.Failed -> "A run failed"
|
AttentionKind.Failed -> "A run failed"
|
||||||
AttentionKind.Finished -> "A run finished"
|
|
||||||
}
|
}
|
||||||
else -> "${entries.size} runs need you"
|
else -> "${entries.size} runs need you"
|
||||||
}
|
}
|
||||||
@@ -157,10 +184,4 @@ internal fun attentionHeadline(entries: List<AttentionEntry>): String = when {
|
|||||||
* anything else. Pure and total, so a malformed link simply opens nothing rather
|
* anything else. Pure and total, so a malformed link simply opens nothing rather
|
||||||
* than a guessed run.
|
* than a guessed run.
|
||||||
*/
|
*/
|
||||||
internal fun runIdFromDeepLink(link: String?): Long? {
|
internal fun runIdFromDeepLink(link: String?): Long? = runLinkFromDeepLink(link)?.runId
|
||||||
val value = link?.trim().orEmpty()
|
|
||||||
if (!value.startsWith(RUN_DEEP_LINK_PREFIX)) return null
|
|
||||||
val rest = value.removePrefix(RUN_DEEP_LINK_PREFIX)
|
|
||||||
if (rest.isEmpty() || !rest.all { it.isDigit() }) return null
|
|
||||||
return rest.toLongOrNull()?.takeIf { it > 0 }
|
|
||||||
}
|
|
||||||
|
|||||||
@@ -1,6 +1,9 @@
|
|||||||
package net.awan.pipelines.ui
|
package net.awan.pipelines.ui
|
||||||
|
|
||||||
|
import android.Manifest
|
||||||
import androidx.activity.compose.BackHandler
|
import androidx.activity.compose.BackHandler
|
||||||
|
import androidx.activity.compose.rememberLauncherForActivityResult
|
||||||
|
import androidx.activity.result.contract.ActivityResultContracts
|
||||||
import androidx.compose.animation.AnimatedVisibility
|
import androidx.compose.animation.AnimatedVisibility
|
||||||
import androidx.compose.animation.fadeIn
|
import androidx.compose.animation.fadeIn
|
||||||
import androidx.compose.animation.fadeOut
|
import androidx.compose.animation.fadeOut
|
||||||
@@ -23,8 +26,11 @@ import androidx.compose.material.icons.automirrored.filled.Chat
|
|||||||
import androidx.compose.material.icons.filled.AccountTree
|
import androidx.compose.material.icons.filled.AccountTree
|
||||||
import androidx.compose.material.icons.filled.History
|
import androidx.compose.material.icons.filled.History
|
||||||
import androidx.compose.material.icons.filled.Settings
|
import androidx.compose.material.icons.filled.Settings
|
||||||
|
import androidx.compose.material3.AlertDialog
|
||||||
import androidx.compose.material3.MaterialTheme
|
import androidx.compose.material3.MaterialTheme
|
||||||
import androidx.compose.material3.Scaffold
|
import androidx.compose.material3.Scaffold
|
||||||
|
import androidx.compose.material3.Text
|
||||||
|
import androidx.compose.material3.TextButton
|
||||||
import androidx.compose.runtime.Composable
|
import androidx.compose.runtime.Composable
|
||||||
import androidx.compose.runtime.LaunchedEffect
|
import androidx.compose.runtime.LaunchedEffect
|
||||||
import androidx.compose.runtime.getValue
|
import androidx.compose.runtime.getValue
|
||||||
@@ -39,6 +45,8 @@ import androidx.compose.ui.input.pointer.pointerInput
|
|||||||
import androidx.compose.ui.platform.LocalConfiguration
|
import androidx.compose.ui.platform.LocalConfiguration
|
||||||
import androidx.compose.ui.unit.Dp
|
import androidx.compose.ui.unit.Dp
|
||||||
import androidx.compose.ui.unit.dp
|
import androidx.compose.ui.unit.dp
|
||||||
|
import androidx.lifecycle.Lifecycle
|
||||||
|
import androidx.lifecycle.compose.LifecycleEventEffect
|
||||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||||
import androidx.navigation.compose.NavHost
|
import androidx.navigation.compose.NavHost
|
||||||
import androidx.navigation.compose.composable
|
import androidx.navigation.compose.composable
|
||||||
@@ -46,6 +54,8 @@ import androidx.navigation.compose.currentBackStackEntryAsState
|
|||||||
import androidx.navigation.compose.rememberNavController
|
import androidx.navigation.compose.rememberNavController
|
||||||
import net.awan.pipelines.data.protocol.SearchResult
|
import net.awan.pipelines.data.protocol.SearchResult
|
||||||
import net.awan.pipelines.data.transport.ConnectionState
|
import net.awan.pipelines.data.transport.ConnectionState
|
||||||
|
import net.awan.pipelines.notify.NOTIFICATION_RATIONALE
|
||||||
|
import net.awan.pipelines.notify.alertPermissionPrompt
|
||||||
import net.awan.pipelines.ui.chat.ChatScreen
|
import net.awan.pipelines.ui.chat.ChatScreen
|
||||||
import net.awan.pipelines.ui.components.AttentionIndicator
|
import net.awan.pipelines.ui.components.AttentionIndicator
|
||||||
import net.awan.pipelines.ui.components.AttentionSheet
|
import net.awan.pipelines.ui.components.AttentionSheet
|
||||||
@@ -91,6 +101,7 @@ internal fun backFrom(selection: PaneSelection): PaneSelection =
|
|||||||
fun PipelinesApp(
|
fun PipelinesApp(
|
||||||
vm: AppViewModel,
|
vm: AppViewModel,
|
||||||
initialRunId: Long? = null,
|
initialRunId: Long? = null,
|
||||||
|
initialRunAction: String? = null,
|
||||||
onInitialRunHandled: () -> Unit = {},
|
onInitialRunHandled: () -> Unit = {},
|
||||||
) {
|
) {
|
||||||
val navController = rememberNavController()
|
val navController = rememberNavController()
|
||||||
@@ -118,10 +129,42 @@ fun PipelinesApp(
|
|||||||
// run's steps are loaded; the Runs destination applies it then (see below).
|
// run's steps are loaded; the Runs destination applies it then (see below).
|
||||||
var runSearchNav by remember { mutableStateOf<SearchTarget.Run?>(null) }
|
var runSearchNav by remember { mutableStateOf<SearchTarget.Run?>(null) }
|
||||||
|
|
||||||
|
// A waiting run's decision sheet to open once its detail has loaded. Set by a
|
||||||
|
// notification's `decide` deep link (the tap lands on the decision, not just
|
||||||
|
// the run), cleared by the detail once it has opened the sheet.
|
||||||
|
var decisionRequest by rememberSaveable { mutableStateOf<Long?>(null) }
|
||||||
|
|
||||||
// Whether the attention list is open. It is not a navigation destination, so
|
// Whether the attention list is open. It is not a navigation destination, so
|
||||||
// the operator's current destination and panes are untouched while it shows.
|
// the operator's current destination and panes are untouched while it shows.
|
||||||
var attentionOpen by rememberSaveable { mutableStateOf(false) }
|
var attentionOpen by rememberSaveable { mutableStateOf(false) }
|
||||||
|
|
||||||
|
// The notification permission: asked at most once, at a sensible moment — the
|
||||||
|
// first time a run actually needs the operator, or the first time the
|
||||||
|
// attention surface is opened — and never nagged. The rationale is shown
|
||||||
|
// before the one system dialog; a refusal simply leaves the in-app Needs you
|
||||||
|
// surface as the only surface, which is exactly what the app did before.
|
||||||
|
val notificationsAllowed by vm.notificationsAllowed.collectAsStateWithLifecycle()
|
||||||
|
val permissionAsked by vm.notificationPermissionAsked.collectAsStateWithLifecycle()
|
||||||
|
var rationaleOpen by rememberSaveable { mutableStateOf(false) }
|
||||||
|
val permissionLauncher = rememberLauncherForActivityResult(
|
||||||
|
ActivityResultContracts.RequestPermission(),
|
||||||
|
) { vm.refreshNotificationsAllowed() }
|
||||||
|
LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { vm.refreshNotificationsAllowed() }
|
||||||
|
val needsPerson = attention.isNotEmpty()
|
||||||
|
LaunchedEffect(notificationsAllowed, permissionAsked, needsPerson, attentionOpen) {
|
||||||
|
val prompt = alertPermissionPrompt(
|
||||||
|
granted = notificationsAllowed,
|
||||||
|
asked = permissionAsked,
|
||||||
|
trigger = needsPerson || attentionOpen,
|
||||||
|
)
|
||||||
|
if (prompt.request) {
|
||||||
|
// Remember the ask first, so dismissing the rationale is never a nag
|
||||||
|
// and a recomposition cannot ask twice.
|
||||||
|
vm.markNotificationPermissionAsked()
|
||||||
|
rationaleOpen = true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// The bottom container's morph (destination pill <-> omni-search field) is
|
// The bottom container's morph (destination pill <-> omni-search field) is
|
||||||
// saved state, so a still-open field survives rotation, configuration change
|
// saved state, so a still-open field survives rotation, configuration change
|
||||||
// and process death. Opening never navigates, so the destination the pill had
|
// and process death. Opening never navigates, so the destination the pill had
|
||||||
@@ -166,31 +209,35 @@ fun PipelinesApp(
|
|||||||
|
|
||||||
// Opening the run a notification or an attention entry names: the Runs
|
// Opening the run a notification or an attention entry names: the Runs
|
||||||
// destination's saved selection points at it, then that destination is shown.
|
// destination's saved selection points at it, then that destination is shown.
|
||||||
|
// Reaching it also clears its notification, and a run that is still waiting is
|
||||||
|
// not re-notified.
|
||||||
val openRunFromAttention: (Long) -> Unit = { runId ->
|
val openRunFromAttention: (Long) -> Unit = { runId ->
|
||||||
|
vm.arrivedAtRun(runId)
|
||||||
runSelection = PaneSelection(pane = MasterPane.Detail, itemId = runId)
|
runSelection = PaneSelection(pane = MasterPane.Detail, itemId = runId)
|
||||||
navController.navigate("runs") { launchSingleTop = true }
|
navController.navigate("runs") { launchSingleTop = true }
|
||||||
}
|
}
|
||||||
|
|
||||||
// A deep link (or the notification's click action) opens its run once. The
|
// A deep link (or the notification's click action) opens its run once. The
|
||||||
// effect re-runs only when the link changes, and the link is cleared once
|
// effect re-runs only when the link changes, and the link is cleared once
|
||||||
// handled, so a rotation re-opens nothing.
|
// handled, so a rotation re-opens nothing. A waiting run's notification also
|
||||||
LaunchedEffect(initialRunId) {
|
// asks for the decision sheet, so the tap lands on the decision itself.
|
||||||
|
LaunchedEffect(initialRunId, initialRunAction) {
|
||||||
if (initialRunId != null) {
|
if (initialRunId != null) {
|
||||||
|
if (initialRunAction == RUN_DEEP_LINK_ACTION_DECIDE) decisionRequest = initialRunId
|
||||||
openRunFromAttention(initialRunId)
|
openRunFromAttention(initialRunId)
|
||||||
onInitialRunHandled()
|
onInitialRunHandled()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Closing the list counts as looking: a run that merely finished since the
|
// Closing the list counts as looking, but only at what still asks: a waiting
|
||||||
// last look clears on this look, while a waiting or failed run stays until it
|
// or failed run stays on the surface until it is resolved or deliberately
|
||||||
// is resolved or deliberately dismissed.
|
// dismissed, so closing never hides work that still needs the operator.
|
||||||
val closeAttentionList: () -> Unit = {
|
val closeAttentionList: () -> Unit = {
|
||||||
vm.sawFinishedAttention(attention.filter { it.kind == AttentionKind.Finished }.map { it.runId })
|
|
||||||
attentionOpen = false
|
attentionOpen = false
|
||||||
}
|
}
|
||||||
|
|
||||||
// Opening an entry deals with it: a failure (like a finished run) is cleared
|
// Opening an entry deals with it: a failure is cleared by opening it, a
|
||||||
// by opening it, a waiting run is not, because only its decision clears it.
|
// waiting run is not, because only its decision clears it.
|
||||||
val openAttentionEntry: (AttentionEntry) -> Unit = { entry ->
|
val openAttentionEntry: (AttentionEntry) -> Unit = { entry ->
|
||||||
if (entry.kind != AttentionKind.Decision) {
|
if (entry.kind != AttentionKind.Decision) {
|
||||||
vm.dismissAttention(entry.runId, entry.kind)
|
vm.dismissAttention(entry.runId, entry.kind)
|
||||||
@@ -279,6 +326,8 @@ fun PipelinesApp(
|
|||||||
pendingNav = runSearchNav,
|
pendingNav = runSearchNav,
|
||||||
onPendingNavResolved = { runSearchNav = null },
|
onPendingNavResolved = { runSearchNav = null },
|
||||||
listState = runListState,
|
listState = runListState,
|
||||||
|
decisionRequest = decisionRequest,
|
||||||
|
onDecisionRequestHandled = { decisionRequest = null },
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
composable("chat") {
|
composable("chat") {
|
||||||
@@ -370,6 +419,27 @@ fun PipelinesApp(
|
|||||||
onDismiss = closeAttentionList,
|
onDismiss = closeAttentionList,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
// The one-time rationale before the system notification dialog. It is
|
||||||
|
// shown only on the first ask (the permission model decides), so a
|
||||||
|
// refusal or dismissal leaves the in-app surface alone from then on.
|
||||||
|
if (rationaleOpen) {
|
||||||
|
AlertDialog(
|
||||||
|
onDismissRequest = { rationaleOpen = false },
|
||||||
|
title = { Text("Notifications") },
|
||||||
|
text = { Text(NOTIFICATION_RATIONALE) },
|
||||||
|
confirmButton = {
|
||||||
|
TextButton(
|
||||||
|
onClick = {
|
||||||
|
rationaleOpen = false
|
||||||
|
permissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
|
||||||
|
},
|
||||||
|
) { Text("Allow") }
|
||||||
|
},
|
||||||
|
dismissButton = {
|
||||||
|
TextButton(onClick = { rationaleOpen = false }) { Text("Not now") }
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -32,6 +32,8 @@ internal fun RunsDestination(
|
|||||||
pendingNav: SearchTarget.Run?,
|
pendingNav: SearchTarget.Run?,
|
||||||
onPendingNavResolved: () -> Unit,
|
onPendingNavResolved: () -> Unit,
|
||||||
listState: LazyListState,
|
listState: LazyListState,
|
||||||
|
decisionRequest: Long? = null,
|
||||||
|
onDecisionRequestHandled: () -> Unit = {},
|
||||||
) {
|
) {
|
||||||
val depth = selection.depth
|
val depth = selection.depth
|
||||||
val onBack: () -> Unit = { onSelectionChange(backFrom(selection)) }
|
val onBack: () -> Unit = { onSelectionChange(backFrom(selection)) }
|
||||||
@@ -99,6 +101,8 @@ internal fun RunsDestination(
|
|||||||
)
|
)
|
||||||
},
|
},
|
||||||
covered = covered,
|
covered = covered,
|
||||||
|
requestDecision = decisionRequest == itemId,
|
||||||
|
onDecisionRequestHandled = onDecisionRequestHandled,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
2 -> rememberPaneContent(
|
2 -> rememberPaneContent(
|
||||||
|
|||||||
@@ -47,7 +47,6 @@ import net.awan.pipelines.ui.theme.SPACING_S
|
|||||||
internal fun attentionRunState(kind: AttentionKind): RunState = when (kind) {
|
internal fun attentionRunState(kind: AttentionKind): RunState = when (kind) {
|
||||||
AttentionKind.Decision -> RunState.Waiting
|
AttentionKind.Decision -> RunState.Waiting
|
||||||
AttentionKind.Failed -> RunState.Failed
|
AttentionKind.Failed -> RunState.Failed
|
||||||
AttentionKind.Finished -> RunState.Succeeded
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|||||||
@@ -22,6 +22,7 @@ import androidx.compose.material3.Text
|
|||||||
import androidx.compose.material3.TextButton
|
import androidx.compose.material3.TextButton
|
||||||
import androidx.compose.material3.rememberModalBottomSheetState
|
import androidx.compose.material3.rememberModalBottomSheetState
|
||||||
import androidx.compose.runtime.Composable
|
import androidx.compose.runtime.Composable
|
||||||
|
import androidx.compose.runtime.LaunchedEffect
|
||||||
import androidx.compose.runtime.getValue
|
import androidx.compose.runtime.getValue
|
||||||
import androidx.compose.runtime.mutableStateOf
|
import androidx.compose.runtime.mutableStateOf
|
||||||
import androidx.compose.runtime.remember
|
import androidx.compose.runtime.remember
|
||||||
@@ -65,6 +66,8 @@ fun DecisionPrompt(
|
|||||||
decision: PendingDecision?,
|
decision: PendingDecision?,
|
||||||
onSend: (decision: PendingDecision, option: String, feedback: String, onResult: (Result<RunDetail>) -> Unit) -> Unit,
|
onSend: (decision: PendingDecision, option: String, feedback: String, onResult: (Result<RunDetail>) -> Unit) -> Unit,
|
||||||
modifier: Modifier = Modifier,
|
modifier: Modifier = Modifier,
|
||||||
|
openRequest: Boolean = false,
|
||||||
|
onOpenRequestHandled: () -> Unit = {},
|
||||||
) {
|
) {
|
||||||
val shown = rememberPaneContent(decision)
|
val shown = rememberPaneContent(decision)
|
||||||
var open by remember { mutableStateOf(false) }
|
var open by remember { mutableStateOf(false) }
|
||||||
@@ -72,6 +75,16 @@ fun DecisionPrompt(
|
|||||||
var sending by remember { mutableStateOf(false) }
|
var sending by remember { mutableStateOf(false) }
|
||||||
var error by remember { mutableStateOf<String?>(null) }
|
var error by remember { mutableStateOf<String?>(null) }
|
||||||
|
|
||||||
|
// A notification's tap asks for the decision itself, not just the run:
|
||||||
|
// open the sheet once the waiting run's detail has loaded. The request is
|
||||||
|
// consumed here so a recomposition or a dismissal does not reopen it.
|
||||||
|
LaunchedEffect(decision?.runId, openRequest) {
|
||||||
|
if (openRequest && decision != null && !open) {
|
||||||
|
open = true
|
||||||
|
onOpenRequestHandled()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
if (decision != null) {
|
if (decision != null) {
|
||||||
DecisionCard(
|
DecisionCard(
|
||||||
decision = decision,
|
decision = decision,
|
||||||
|
|||||||
@@ -67,6 +67,8 @@ fun RunDetailScreen(
|
|||||||
modifier: Modifier = Modifier,
|
modifier: Modifier = Modifier,
|
||||||
wide: Boolean = false,
|
wide: Boolean = false,
|
||||||
covered: Boolean = false,
|
covered: Boolean = false,
|
||||||
|
requestDecision: Boolean = false,
|
||||||
|
onDecisionRequestHandled: () -> Unit = {},
|
||||||
) {
|
) {
|
||||||
val state by vm.runDetail.collectAsStateWithLifecycle()
|
val state by vm.runDetail.collectAsStateWithLifecycle()
|
||||||
val runsState by vm.runs.collectAsStateWithLifecycle()
|
val runsState by vm.runs.collectAsStateWithLifecycle()
|
||||||
@@ -83,6 +85,9 @@ fun RunDetailScreen(
|
|||||||
val selectionState = rememberArtifactSelection(runId)
|
val selectionState = rememberArtifactSelection(runId)
|
||||||
|
|
||||||
LaunchedEffect(runId) {
|
LaunchedEffect(runId) {
|
||||||
|
// Reaching a run clears its notification, whichever path opened it (the
|
||||||
|
// notification's own tap, the attention list, the runs list or a search).
|
||||||
|
vm.arrivedAtRun(runId)
|
||||||
// Scope evidence to this run: drop the previous run's records, then fetch
|
// Scope evidence to this run: drop the previous run's records, then fetch
|
||||||
// this run's evidence once (on demand; live pushes carry no evidence).
|
// this run's evidence once (on demand; live pushes carry no evidence).
|
||||||
vm.resetEvidence()
|
vm.resetEvidence()
|
||||||
@@ -210,6 +215,8 @@ fun RunDetailScreen(
|
|||||||
vm.decideRun(pending.runId, pending.stageKey, option, feedback, onResult)
|
vm.decideRun(pending.runId, pending.stageKey, option, feedback, onResult)
|
||||||
},
|
},
|
||||||
modifier = Modifier.padding(horizontal = SPACING_L, vertical = SPACING_S),
|
modifier = Modifier.padding(horizontal = SPACING_L, vertical = SPACING_S),
|
||||||
|
openRequest = requestDecision,
|
||||||
|
onOpenRequestHandled = onDecisionRequestHandled,
|
||||||
)
|
)
|
||||||
StateCrossfade(
|
StateCrossfade(
|
||||||
phase = detailLoadPhase(state.error, hasData = run != null),
|
phase = detailLoadPhase(state.error, hasData = run != null),
|
||||||
|
|||||||
@@ -0,0 +1,15 @@
|
|||||||
|
<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<!--
|
||||||
|
The monochrome status-bar glyph for "a run needs you": three attention bars
|
||||||
|
with a raised exclamation-free silhouette, so the small icon reads at 24dp
|
||||||
|
instead of shrinking the full-colour launcher art.
|
||||||
|
-->
|
||||||
|
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||||
|
android:width="24dp"
|
||||||
|
android:height="24dp"
|
||||||
|
android:viewportWidth="24"
|
||||||
|
android:viewportHeight="24">
|
||||||
|
<path
|
||||||
|
android:fillColor="#FFFFFFFF"
|
||||||
|
android:pathData="M4,18h3v-6h-3z M10.5,18h3v-10h-3z M17,18h3v-14h-3z" />
|
||||||
|
</vector>
|
||||||
@@ -0,0 +1,249 @@
|
|||||||
|
package net.awan.pipelines.notify
|
||||||
|
|
||||||
|
import net.awan.pipelines.data.protocol.RunSummary
|
||||||
|
import net.awan.pipelines.ui.AttentionEntry
|
||||||
|
import net.awan.pipelines.ui.AttentionKind
|
||||||
|
import net.awan.pipelines.ui.AttentionState
|
||||||
|
import net.awan.pipelines.ui.RUN_DEEP_LINK_ACTION_DECIDE
|
||||||
|
import net.awan.pipelines.ui.attentionEntries
|
||||||
|
import net.awan.pipelines.ui.runLinkFromDeepLink
|
||||||
|
import org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertFalse
|
||||||
|
import org.junit.Assert.assertNotNull
|
||||||
|
import org.junit.Assert.assertNull
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The notification model's pure rules: the event-to-notification mapping
|
||||||
|
* (waiting and failed only), the permission paths (granted, refused,
|
||||||
|
* not-yet-asked), coalescing into one summary, the dedupe/clear ledger, and the
|
||||||
|
* tap destination. No Android types are involved, so every path is asserted
|
||||||
|
* without a device.
|
||||||
|
*/
|
||||||
|
class RunAlertsTest {
|
||||||
|
|
||||||
|
private fun entry(
|
||||||
|
runId: Long,
|
||||||
|
kind: AttentionKind,
|
||||||
|
label: String = "Ship 1.4",
|
||||||
|
pipeline: String = "release",
|
||||||
|
detail: String = "",
|
||||||
|
) = AttentionEntry(
|
||||||
|
runId = runId,
|
||||||
|
pipeline = pipeline,
|
||||||
|
label = label,
|
||||||
|
kind = kind,
|
||||||
|
detail = detail,
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun run(id: Long, status: String, title: String? = null, diagnostic: String = "") = RunSummary(
|
||||||
|
id = id,
|
||||||
|
pipelineId = 4,
|
||||||
|
name = "release",
|
||||||
|
title = title,
|
||||||
|
status = status,
|
||||||
|
executing = status == "running",
|
||||||
|
diagnostic = diagnostic,
|
||||||
|
)
|
||||||
|
|
||||||
|
// --- event-to-notification mapping ----------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun onlyWaitingAndFailedRaiseANotification() {
|
||||||
|
assertEquals(RunAlertKind.Decision, alertKindOf(AttentionKind.Decision))
|
||||||
|
assertEquals(RunAlertKind.Failed, alertKindOf(AttentionKind.Failed))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aSuccessfulRunningOrCancelledRunRaisesNothing() {
|
||||||
|
val runs = listOf(
|
||||||
|
run(1, "succeeded"),
|
||||||
|
run(2, "running"),
|
||||||
|
run(3, "canceled"),
|
||||||
|
run(4, "interrupted"),
|
||||||
|
run(5, "queued"),
|
||||||
|
)
|
||||||
|
assertTrue(runAlerts(attentionEntries(runs, AttentionState())).isEmpty())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun waitingAndFailedBecomeOneAlertEachAndFinishedDoesNot() {
|
||||||
|
val runs = listOf(
|
||||||
|
run(1, "waiting", title = "Ship 1.4"),
|
||||||
|
run(2, "failed", diagnostic = "provider returned 500"),
|
||||||
|
run(3, "succeeded", title = "Nightly"),
|
||||||
|
)
|
||||||
|
val alerts = runAlerts(attentionEntries(runs, AttentionState()))
|
||||||
|
assertEquals(listOf(1L, 2L), alerts.map { it.runId })
|
||||||
|
assertEquals(listOf(RunAlertKind.Decision, RunAlertKind.Failed), alerts.map { it.kind })
|
||||||
|
assertEquals("A run needs your decision", alerts[0].title)
|
||||||
|
assertEquals("Ship 1.4 · release", alerts[0].text)
|
||||||
|
assertEquals("A run failed", alerts[1].title)
|
||||||
|
assertEquals("release", alerts[1].text)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun oneRunAndEventKindHasOneStableIdentity() {
|
||||||
|
assertEquals(alertKey(7, RunAlertKind.Decision), alertKey(7, RunAlertKind.Decision))
|
||||||
|
assertTrue(alertKey(7, RunAlertKind.Decision) != alertKey(7, RunAlertKind.Failed))
|
||||||
|
assertTrue(alertKey(7, RunAlertKind.Decision) != alertKey(8, RunAlertKind.Decision))
|
||||||
|
// The notification id is stable per run+kind, so a repost updates in place.
|
||||||
|
assertEquals(alertNotificationId(7, RunAlertKind.Decision), alertNotificationId(7, RunAlertKind.Decision))
|
||||||
|
assertTrue(alertNotificationId(7, RunAlertKind.Decision) != alertNotificationId(7, RunAlertKind.Failed))
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- coalescing -------------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aSingleAlertHasNoSummaryButSeveralCoalesceIntoOne() {
|
||||||
|
val one = runAlerts(listOf(entry(1, AttentionKind.Decision)))
|
||||||
|
assertNull(alertSummary(one))
|
||||||
|
|
||||||
|
val several = runAlerts(
|
||||||
|
listOf(
|
||||||
|
entry(1, AttentionKind.Decision),
|
||||||
|
entry(2, AttentionKind.Failed),
|
||||||
|
entry(3, AttentionKind.Failed),
|
||||||
|
),
|
||||||
|
)
|
||||||
|
val summary = alertSummary(several)
|
||||||
|
assertNotNull(summary)
|
||||||
|
assertEquals(3, summary!!.count)
|
||||||
|
assertEquals("3 runs need you", summary.title)
|
||||||
|
assertEquals("1 waiting for you · 2 failed", summary.text)
|
||||||
|
assertEquals(3, summary.lines.size)
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- dedupe and clearing ----------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun theSameRunAndKindIsPostedOnlyOnce() {
|
||||||
|
val ledger = AlertLedger()
|
||||||
|
val alerts = runAlerts(listOf(entry(1, AttentionKind.Decision), entry(2, AttentionKind.Failed)))
|
||||||
|
|
||||||
|
val first = ledger.reconcile(alerts)
|
||||||
|
assertEquals(listOf(1L, 2L), first.post.map { it.runId })
|
||||||
|
assertTrue(first.cancel.isEmpty())
|
||||||
|
|
||||||
|
// A later reconciliation (the run stays waiting/failed) posts nothing.
|
||||||
|
val second = ledger.reconcile(alerts)
|
||||||
|
assertTrue(second.post.isEmpty())
|
||||||
|
assertTrue(second.isEmpty)
|
||||||
|
assertEquals(2, ledger.shown.size)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aResolvedRunIsCancelledAndOnlyTheNewOneIsPosted() {
|
||||||
|
val ledger = AlertLedger()
|
||||||
|
ledger.reconcile(runAlerts(listOf(entry(1, AttentionKind.Decision))))
|
||||||
|
|
||||||
|
val delta = ledger.reconcile(runAlerts(listOf(entry(1, AttentionKind.Decision), entry(2, AttentionKind.Failed))))
|
||||||
|
assertEquals(listOf(2L), delta.post.map { it.runId })
|
||||||
|
assertTrue(delta.cancel.isEmpty())
|
||||||
|
|
||||||
|
// Run 1 resolves/leaves the surface: its notification is cleared, run 2 stays.
|
||||||
|
val cleared = ledger.reconcile(runAlerts(listOf(entry(2, AttentionKind.Failed))))
|
||||||
|
assertTrue(cleared.post.isEmpty())
|
||||||
|
assertEquals(listOf(1L), cleared.cancel.map { it.runId })
|
||||||
|
assertEquals(setOf(alertKey(2, RunAlertKind.Failed)), ledger.shown.keys)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun everythingIsClearedWhenNothingNeedsTheOperator() {
|
||||||
|
val ledger = AlertLedger()
|
||||||
|
ledger.reconcile(runAlerts(listOf(entry(1, AttentionKind.Decision), entry(2, AttentionKind.Failed))))
|
||||||
|
|
||||||
|
val cleared = ledger.reconcile(emptyList())
|
||||||
|
assertEquals(setOf(1L, 2L), cleared.cancel.map { it.runId }.toSet())
|
||||||
|
assertTrue(ledger.shown.isEmpty())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun arrivingAtAStillWaitingRunClearsItWithoutReNotifying() {
|
||||||
|
val ledger = AlertLedger()
|
||||||
|
val alerts = runAlerts(listOf(entry(1, AttentionKind.Decision), entry(2, AttentionKind.Failed)))
|
||||||
|
ledger.reconcile(alerts)
|
||||||
|
assertEquals(2, ledger.visible().size)
|
||||||
|
|
||||||
|
// The operator opens run 1; its notification is cleared and the grouped
|
||||||
|
// summary stops counting it.
|
||||||
|
assertEquals(listOf(1L), ledger.arrived(1).map { it.runId })
|
||||||
|
assertEquals(listOf(2L), ledger.visible().map { it.runId })
|
||||||
|
// The run is still waiting, so the next reconciliation must not re-post it.
|
||||||
|
val again = ledger.reconcile(alerts)
|
||||||
|
assertTrue(again.post.isEmpty())
|
||||||
|
// Run 2 is untouched and still tracked.
|
||||||
|
assertTrue(ledger.shown.containsKey(alertKey(2, RunAlertKind.Failed)))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aRunThatFailsAgainAfterResolvingNotifiesAgain() {
|
||||||
|
val ledger = AlertLedger()
|
||||||
|
val failed = runAlerts(listOf(entry(1, AttentionKind.Failed)))
|
||||||
|
assertEquals(1, ledger.reconcile(failed).post.size)
|
||||||
|
// Resolved (left the surface): the key is forgotten.
|
||||||
|
assertTrue(ledger.reconcile(emptyList()).cancel.isNotEmpty())
|
||||||
|
// A new failure for the same run is a new event and notifies once more.
|
||||||
|
assertEquals(1, ledger.reconcile(failed).post.size)
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- permission paths -------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aGrantedPermissionIsNeverAsked() {
|
||||||
|
val prompt = alertPermissionPrompt(granted = true, asked = false, trigger = true)
|
||||||
|
assertFalse(prompt.request)
|
||||||
|
assertNull(prompt.rationale)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun theFirstTimeSomethingNeedsTheOperatorAsksWithARationale() {
|
||||||
|
val prompt = alertPermissionPrompt(granted = false, asked = false, trigger = true)
|
||||||
|
assertTrue(prompt.request)
|
||||||
|
assertEquals(NOTIFICATION_RATIONALE, prompt.rationale)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun nothingIsAskedBeforeSomethingNeedsTheOperator() {
|
||||||
|
val prompt = alertPermissionPrompt(granted = false, asked = false, trigger = false)
|
||||||
|
assertFalse(prompt.request)
|
||||||
|
assertNull(prompt.rationale)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aRefusalIsRememberedAndNeverAskedAgain() {
|
||||||
|
// "asked" covers both a refusal and a dismissal of the rationale.
|
||||||
|
val prompt = alertPermissionPrompt(granted = false, asked = true, trigger = true)
|
||||||
|
assertFalse(prompt.request)
|
||||||
|
assertNull(prompt.rationale)
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- tap destination --------------------------------------------------------
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aWaitingRunOpensTheDecisionSheetAndAFailedRunOpensTheRun() {
|
||||||
|
assertEquals(AlertTapTarget.DecisionSheet, alertTapTarget(RunAlertKind.Decision))
|
||||||
|
assertEquals(AlertTapTarget.Run, alertTapTarget(RunAlertKind.Failed))
|
||||||
|
|
||||||
|
assertEquals("pipelines://run/42", alertDeepLink(42, RunAlertKind.Failed))
|
||||||
|
assertEquals(
|
||||||
|
"pipelines://run/42?action=$RUN_DEEP_LINK_ACTION_DECIDE",
|
||||||
|
alertDeepLink(42, RunAlertKind.Decision),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun theRunDeepLinkCarriesItsOptionalAction() {
|
||||||
|
val decision = runLinkFromDeepLink("pipelines://run/42?action=$RUN_DEEP_LINK_ACTION_DECIDE")
|
||||||
|
assertEquals(42L, decision?.runId)
|
||||||
|
assertEquals(RUN_DEEP_LINK_ACTION_DECIDE, decision?.action)
|
||||||
|
|
||||||
|
val plain = runLinkFromDeepLink("pipelines://run/42")
|
||||||
|
assertEquals(42L, plain?.runId)
|
||||||
|
assertNull(plain?.action)
|
||||||
|
|
||||||
|
assertNull(runLinkFromDeepLink("pipelines://run/abc?action=$RUN_DEEP_LINK_ACTION_DECIDE"))
|
||||||
|
assertNull(runLinkFromDeepLink("pipelines://run/0"))
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -8,10 +8,11 @@ import org.junit.Assert.assertTrue
|
|||||||
import org.junit.Test
|
import org.junit.Test
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* The attention surface's pure model: the event-to-entry mapping (waiting,
|
* The attention surface's pure model: the event-to-entry mapping (a waiting run
|
||||||
* failed and nothing else), the ranking of the three kinds, an entry appearing
|
* and a failed run, and nothing else — a successful run is never announced), the
|
||||||
* from a pushed run event and clearing when it is resolved, deliberate
|
* ranking of the two kinds, an entry appearing from a pushed run event and
|
||||||
* dismissal, the empty case, persistence, and the notification's deep link.
|
* clearing when it is resolved, deliberate dismissal, the empty case, persistence,
|
||||||
|
* and the notification's deep link.
|
||||||
*/
|
*/
|
||||||
class AttentionTest {
|
class AttentionTest {
|
||||||
|
|
||||||
@@ -45,10 +46,10 @@ class AttentionTest {
|
|||||||
// --- mapping ---------------------------------------------------------------
|
// --- mapping ---------------------------------------------------------------
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun onlyWaitingFailedAndFinishedAskForAttention() {
|
fun onlyAWaitingOrFailedRunAsksForAttention() {
|
||||||
assertEquals(AttentionKind.Decision, attentionKindOf("waiting"))
|
assertEquals(AttentionKind.Decision, attentionKindOf("waiting"))
|
||||||
assertEquals(AttentionKind.Failed, attentionKindOf("failed"))
|
assertEquals(AttentionKind.Failed, attentionKindOf("failed"))
|
||||||
assertEquals(AttentionKind.Finished, attentionKindOf("succeeded"))
|
assertNull(attentionKindOf("succeeded"))
|
||||||
assertNull(attentionKindOf("queued"))
|
assertNull(attentionKindOf("queued"))
|
||||||
assertNull(attentionKindOf("running"))
|
assertNull(attentionKindOf("running"))
|
||||||
assertNull(attentionKindOf("canceled"))
|
assertNull(attentionKindOf("canceled"))
|
||||||
@@ -68,7 +69,7 @@ class AttentionTest {
|
|||||||
),
|
),
|
||||||
AttentionState(),
|
AttentionState(),
|
||||||
)
|
)
|
||||||
assertEquals(3, entries.size)
|
assertEquals(2, entries.size)
|
||||||
val decision = entries[0]
|
val decision = entries[0]
|
||||||
assertEquals(AttentionKind.Decision, decision.kind)
|
assertEquals(AttentionKind.Decision, decision.kind)
|
||||||
assertEquals("Ship 1.4", decision.label)
|
assertEquals("Ship 1.4", decision.label)
|
||||||
@@ -77,25 +78,21 @@ class AttentionTest {
|
|||||||
val failed = entries[1]
|
val failed = entries[1]
|
||||||
assertEquals(AttentionKind.Failed, failed.kind)
|
assertEquals(AttentionKind.Failed, failed.kind)
|
||||||
assertEquals("provider returned 500", failed.detail)
|
assertEquals("provider returned 500", failed.detail)
|
||||||
val finished = entries[2]
|
|
||||||
assertEquals(AttentionKind.Finished, finished.kind)
|
|
||||||
assertEquals("nightly", finished.label)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// --- ordering --------------------------------------------------------------
|
// --- ordering --------------------------------------------------------------
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun decisionRanksBeforeFailedBeforeFinished() {
|
fun decisionRanksBeforeFailed() {
|
||||||
val entries = attentionEntries(
|
val entries = attentionEntries(
|
||||||
listOf(
|
listOf(
|
||||||
run(3, "succeeded", finishedAt = "2026-10-17T09:09:00Z"),
|
|
||||||
run(2, "failed", finishedAt = "2026-10-17T09:08:00Z"),
|
run(2, "failed", finishedAt = "2026-10-17T09:08:00Z"),
|
||||||
run(1, "waiting"),
|
run(1, "waiting"),
|
||||||
),
|
),
|
||||||
AttentionState(),
|
AttentionState(),
|
||||||
)
|
)
|
||||||
assertEquals(listOf(AttentionKind.Decision, AttentionKind.Failed, AttentionKind.Finished), entries.map { it.kind })
|
assertEquals(listOf(AttentionKind.Decision, AttentionKind.Failed), entries.map { it.kind })
|
||||||
assertEquals(listOf(1L, 2L, 3L), entries.map { it.runId })
|
assertEquals(listOf(1L, 2L), entries.map { it.runId })
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
@@ -142,7 +139,7 @@ class AttentionTest {
|
|||||||
assertTrue(attentionEntries(retried, AttentionState()).isEmpty())
|
assertTrue(attentionEntries(retried, AttentionState()).isEmpty())
|
||||||
}
|
}
|
||||||
|
|
||||||
// --- dismissal and look ----------------------------------------------------
|
// --- dismissal -------------------------------------------------------------
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun aDeliberateDismissalRemovesAnEntryForGood() {
|
fun aDeliberateDismissalRemovesAnEntryForGood() {
|
||||||
@@ -155,11 +152,16 @@ class AttentionTest {
|
|||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun aFinishedRunClearsOnceTheOperatorHasLooked() {
|
fun aSuccessfulRunIsNeverListed() {
|
||||||
val runs = listOf(run(1, "succeeded"))
|
assertTrue(attentionEntries(listOf(run(1, "succeeded")), AttentionState()).isEmpty())
|
||||||
assertEquals(1, attentionEntries(runs, AttentionState()).size)
|
// Even a finished run that was never looked at does not appear: a
|
||||||
val looked = AttentionState().lookedAtFinished(setOf(1L))
|
// successful run raises nothing on any surface.
|
||||||
assertTrue(attentionEntries(runs, looked).isEmpty())
|
assertTrue(
|
||||||
|
attentionEntries(
|
||||||
|
listOf(run(2, "succeeded"), run(3, "running"), run(4, "canceled")),
|
||||||
|
AttentionState(),
|
||||||
|
).isEmpty(),
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
// --- empty case ------------------------------------------------------------
|
// --- empty case ------------------------------------------------------------
|
||||||
@@ -169,7 +171,13 @@ class AttentionTest {
|
|||||||
assertTrue(attentionEntries(emptyList(), AttentionState()).isEmpty())
|
assertTrue(attentionEntries(emptyList(), AttentionState()).isEmpty())
|
||||||
assertTrue(
|
assertTrue(
|
||||||
attentionEntries(
|
attentionEntries(
|
||||||
listOf(run(1, "running"), run(2, "queued"), run(3, "canceled"), run(4, "interrupted")),
|
listOf(
|
||||||
|
run(1, "running"),
|
||||||
|
run(2, "queued"),
|
||||||
|
run(3, "canceled"),
|
||||||
|
run(4, "interrupted"),
|
||||||
|
run(5, "succeeded"),
|
||||||
|
),
|
||||||
AttentionState(),
|
AttentionState(),
|
||||||
).isEmpty(),
|
).isEmpty(),
|
||||||
)
|
)
|
||||||
@@ -182,18 +190,21 @@ class AttentionTest {
|
|||||||
assertEquals("A run is waiting for you", attentionHeadline(decision))
|
assertEquals("A run is waiting for you", attentionHeadline(decision))
|
||||||
val failed = attentionEntries(listOf(run(2, "failed"), run(3, "failed")), AttentionState())
|
val failed = attentionEntries(listOf(run(2, "failed"), run(3, "failed")), AttentionState())
|
||||||
assertEquals("2 runs need you", attentionHeadline(failed))
|
assertEquals("2 runs need you", attentionHeadline(failed))
|
||||||
|
val singleFailed = attentionEntries(listOf(run(4, "failed")), AttentionState())
|
||||||
|
assertEquals("A run failed", attentionHeadline(singleFailed))
|
||||||
}
|
}
|
||||||
|
|
||||||
// --- persistence -----------------------------------------------------------
|
// --- persistence -----------------------------------------------------------
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun attentionStateSurvivesAnEncodeDecodeRoundTrip() {
|
fun attentionStateSurvivesAnEncodeDecodeRoundTrip() {
|
||||||
val state = AttentionState()
|
val state = AttentionState().dismissed(attentionKey(7, AttentionKind.Failed))
|
||||||
.dismissed(attentionKey(7, AttentionKind.Failed))
|
|
||||||
.lookedAtFinished(setOf(9L, 11L))
|
|
||||||
assertEquals(state, AttentionState.decode(state.encode()))
|
assertEquals(state, AttentionState.decode(state.encode()))
|
||||||
assertEquals(AttentionState(), AttentionState.decode(""))
|
assertEquals(AttentionState(), AttentionState.decode(""))
|
||||||
assertEquals(AttentionState(), AttentionState.decode("not json"))
|
assertEquals(AttentionState(), AttentionState.decode("not json"))
|
||||||
|
// A state stored by an older build that also recorded looked-at finished
|
||||||
|
// runs still decodes, keeping the dismissals.
|
||||||
|
assertEquals(AttentionState(), AttentionState.decode("""{"finishedSeen":[9,11]}"""))
|
||||||
}
|
}
|
||||||
|
|
||||||
// --- notification deep link ------------------------------------------------
|
// --- notification deep link ------------------------------------------------
|
||||||
|
|||||||
Reference in New Issue
Block a user