android: post real system-tray notifications when a run needs the operator
The app already had an in-app attention surface but nothing in the system tray. This adds the app's own Android notifications for the two events that need a person: a run waiting for a decision (highest importance) and a run that failed. A successful, running or cancelled run raises nothing. - RunAlerts.kt: the pure model. Maps the attention list's kinds to run alerts, coalesces several into one grouped summary, dedupes one notification per run+kind via AlertLedger (never repeated while the run stays failed or waiting), clears on resolution/dismissal/arrival, and decides the one-time permission prompt and tap destination. Unit-tested. - RunNotifier.kt: the Android edge. Creates the single "Runs that need you" channel, posts/clears through NotificationManagerCompat, and reports notificationsAllowed() from POST_NOTIFICATIONS (API 33+) / the system notification switch. Posted from the app's own process. - Manifest: POST_NOTIFICATIONS runtime permission; PipelinesApplication creates the channel before anything can post. - SettingsRepository/AppViewModel: remembers that the permission was asked once (never nags), keeps notificationsAllowed fresh on resume, feeds the tray from the same attention flow, and clears a run's notification when the operator arrives at it. - PipelinesApp/DecisionPrompt/RunDetailScreen: the one-time rationale before the system dialog, asked at a sensible moment (first run that needs the operator, or first open of the attention surface), degrading to the existing in-app surface on refusal; a waiting run's tap opens its decision sheet (pipelines://run/<id>?action=decide), a failed run's tap opens the run; reaching a run clears its notification. - Attention.kt: drops the Finished kind so a successful run is never announced on any surface (the operator's rule), keeps the deep-link parser (now carrying an optional action) and still decodes an older state's looked-at-finished set. - AttentionTest.kt / RunAlertsTest.kt: the mapping (waiting and failed only), the permission paths (granted, refused, not-yet-asked), coalescing and clearing, dedupe, and the tap destination. Checks: `:app:assembleDebug` and `:app:testDebugUnitTest --rerun-tasks` pass (578 tests, 0 failures). Reflected-where-it-belongs check: this is an android/-only change and the packaged authoring skill references and the packaged templates describe the server's ntfy notification authoring, not the Android app's tray, so none of them needs updating. No README or other shared documentation file was touched.
This commit is contained in:
@@ -3,6 +3,14 @@
|
||||
|
||||
<uses-permission android:name="android.permission.INTERNET" />
|
||||
<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
|
||||
android:allowBackup="true"
|
||||
|
||||
@@ -11,18 +11,21 @@ import androidx.compose.runtime.setValue
|
||||
import androidx.lifecycle.viewmodel.compose.viewModel
|
||||
import net.awan.pipelines.ui.AppViewModel
|
||||
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
|
||||
|
||||
class MainActivity : ComponentActivity() {
|
||||
// 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
|
||||
// PipelinesApp has opened it, so a recomposition never re-navigates.
|
||||
// click action — and what inside it to open (a waiting run's `decide` action
|
||||
// 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 deepLinkedAction by mutableStateOf<String?>(null)
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
deepLinkedRunId = runIdFromDeepLink(intent?.data?.toString())
|
||||
applyDeepLink(intent)
|
||||
enableEdgeToEdge()
|
||||
val app = application as PipelinesApplication
|
||||
setContent {
|
||||
@@ -31,7 +34,11 @@ class MainActivity : ComponentActivity() {
|
||||
PipelinesApp(
|
||||
vm = vm,
|
||||
initialRunId = deepLinkedRunId,
|
||||
onInitialRunHandled = { deepLinkedRunId = null },
|
||||
initialRunAction = deepLinkedAction,
|
||||
onInitialRunHandled = {
|
||||
deepLinkedRunId = null
|
||||
deepLinkedAction = null
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -41,6 +48,12 @@ class MainActivity : ComponentActivity() {
|
||||
override fun onNewIntent(intent: Intent) {
|
||||
super.onNewIntent(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.SettingsRepository
|
||||
import net.awan.pipelines.data.transport.PipelinesClient
|
||||
import net.awan.pipelines.notify.RunNotifier
|
||||
|
||||
/**
|
||||
* 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 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())
|
||||
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) {
|
||||
val trimmed = value.trim()
|
||||
_serverUrl.value = trimmed
|
||||
@@ -141,6 +148,13 @@ class SettingsRepository(context: Context) {
|
||||
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. */
|
||||
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_SEEN = "chat_seen"
|
||||
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.transport.ConnectionState
|
||||
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.ChatSessionOverrides
|
||||
import net.awan.pipelines.ui.chat.ChatSeenState
|
||||
@@ -61,6 +64,7 @@ data class LoadState<T>(
|
||||
class AppViewModel(
|
||||
private val repository: PipelinesRepository,
|
||||
private val settings: SettingsRepository,
|
||||
private val alertSink: RunAlertSink = NoRunAlerts,
|
||||
) : ViewModel() {
|
||||
|
||||
val connectionState: StateFlow<ConnectionState> = repository.connectionState
|
||||
@@ -135,6 +139,20 @@ class AppViewModel(
|
||||
attentionEntries(runs.data?.runs.orEmpty(), state)
|
||||
}.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
|
||||
// top of a newer one; the pure ordering lives in SearchSequencer.
|
||||
private val searchSequencer = SearchSequencer()
|
||||
@@ -209,6 +227,7 @@ class AppViewModel(
|
||||
observeChatOverrides()
|
||||
observeChatSeen()
|
||||
observeAttention()
|
||||
observeRunAlerts()
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -543,20 +562,54 @@ class AppViewModel(
|
||||
}
|
||||
|
||||
/**
|
||||
* Deliberately dismisses one attention entry for good, so a still-waiting or
|
||||
* still-failed run the operator has chosen to ignore stops asking.
|
||||
* Feeds the app's Android notifications from the same attention list the
|
||||
* 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) {
|
||||
_attentionState.value = _attentionState.value.dismissed(attentionKey(runId, kind))
|
||||
private fun observeRunAlerts() {
|
||||
_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
|
||||
* surface, so a run that merely finished since the last look clears on this
|
||||
* look rather than reappearing. Called when the list is opened.
|
||||
* The operator has reached [runId]: its notification is cleared, and — because
|
||||
* the run is still waiting or failed — it is not posted again. Called through
|
||||
* 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>) {
|
||||
_attentionState.value = _attentionState.value.lookedAtFinished(ids.toSet())
|
||||
fun arrivedAtRun(runId: Long) {
|
||||
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) {
|
||||
@@ -1133,7 +1186,7 @@ class AppViewModel(
|
||||
private const val CHAT_HISTORY_LIMIT = 200
|
||||
|
||||
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.
|
||||
*
|
||||
* 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
|
||||
* ([AttentionKind.Failed]) next, and a run that finished since the operator last
|
||||
* looked ([AttentionKind.Finished]) last. Everything else — queued, running,
|
||||
* canceled, interrupted — asks nothing and is not listed, so the surface can only
|
||||
* ever show something that is genuinely actionable.
|
||||
* person ([AttentionKind.Decision]) is the most important and a failed run
|
||||
* ([AttentionKind.Failed]) next. Everything else — queued, running, succeeded,
|
||||
* canceled, interrupted — asks nothing and is not listed, so the surface (and the
|
||||
* system tray fed from it) can only ever show something that is genuinely
|
||||
* actionable. A successful run is never announced.
|
||||
*
|
||||
* 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
|
||||
* 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) {
|
||||
Decision(0),
|
||||
Failed(1),
|
||||
Finished(2),
|
||||
}
|
||||
|
||||
/** 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()) {
|
||||
"waiting" -> AttentionKind.Decision
|
||||
"failed" -> AttentionKind.Failed
|
||||
"succeeded" -> AttentionKind.Finished
|
||||
else -> null
|
||||
}
|
||||
|
||||
@@ -67,22 +65,19 @@ internal fun attentionKindOf(status: String): AttentionKind? =
|
||||
internal fun attentionDetail(kind: AttentionKind, run: RunSummary): String = when (kind) {
|
||||
AttentionKind.Decision -> "Waiting for your decision"
|
||||
AttentionKind.Failed -> run.diagnostic.trim().ifBlank { "Run failed" }
|
||||
AttentionKind.Finished -> "Finished"
|
||||
}
|
||||
|
||||
/**
|
||||
* The ordered attention list. Every run that needs the operator becomes one
|
||||
* entry, ranked by kind (decision, failed, finished) and then newest-first within
|
||||
* a 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
|
||||
* has already looked at stays gone; a waiting or failed run returns until it is
|
||||
* resolved or dismissed, because it is still asking.
|
||||
* entry, ranked by kind (decision, then failure) and then newest-first within a
|
||||
* kind, so the order is stable and never reshuffles between reads. An entry the
|
||||
* operator explicitly dismissed never returns, and a waiting or failed run stays
|
||||
* until it is resolved or dismissed, because it is still asking.
|
||||
*/
|
||||
internal fun attentionEntries(runs: List<RunSummary>, state: AttentionState): List<AttentionEntry> =
|
||||
runs.mapNotNull { run ->
|
||||
val kind = attentionKindOf(run.status) ?: 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(
|
||||
runId = run.id,
|
||||
pipeline = run.name,
|
||||
@@ -103,25 +98,20 @@ internal fun attentionEntries(runs: List<RunSummary>, state: AttentionState): Li
|
||||
* stored state:
|
||||
*
|
||||
* - [dismissed] is the run+kind keys the operator deliberately dismissed, so a
|
||||
* still-waiting run stays out of the list after an explicit dismissal.
|
||||
* - [finishedSeen] is the finished runs the operator has looked at, so the list
|
||||
* shows a completed run once and clears it on the next look.
|
||||
* still-waiting or still-failed run stays out of the list after an explicit
|
||||
* dismissal.
|
||||
*
|
||||
* 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
|
||||
data class AttentionState(
|
||||
val dismissed: Set<String> = emptySet(),
|
||||
val finishedSeen: Set<Long> = emptySet(),
|
||||
) {
|
||||
/** Removes one entry for good, whatever its run goes on to do. */
|
||||
fun dismissed(key: String): AttentionState =
|
||||
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. */
|
||||
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. */
|
||||
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
|
||||
* 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) {
|
||||
AttentionKind.Decision -> "A run is waiting for you"
|
||||
AttentionKind.Failed -> "A run failed"
|
||||
AttentionKind.Finished -> "A run finished"
|
||||
}
|
||||
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
|
||||
* than a guessed run.
|
||||
*/
|
||||
internal fun runIdFromDeepLink(link: String?): Long? {
|
||||
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 }
|
||||
}
|
||||
internal fun runIdFromDeepLink(link: String?): Long? = runLinkFromDeepLink(link)?.runId
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import android.Manifest
|
||||
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.fadeIn
|
||||
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.History
|
||||
import androidx.compose.material.icons.filled.Settings
|
||||
import androidx.compose.material3.AlertDialog
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Scaffold
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.material3.TextButton
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
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.unit.Dp
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.lifecycle.Lifecycle
|
||||
import androidx.lifecycle.compose.LifecycleEventEffect
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import androidx.navigation.compose.NavHost
|
||||
import androidx.navigation.compose.composable
|
||||
@@ -46,6 +54,8 @@ import androidx.navigation.compose.currentBackStackEntryAsState
|
||||
import androidx.navigation.compose.rememberNavController
|
||||
import net.awan.pipelines.data.protocol.SearchResult
|
||||
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.components.AttentionIndicator
|
||||
import net.awan.pipelines.ui.components.AttentionSheet
|
||||
@@ -91,6 +101,7 @@ internal fun backFrom(selection: PaneSelection): PaneSelection =
|
||||
fun PipelinesApp(
|
||||
vm: AppViewModel,
|
||||
initialRunId: Long? = null,
|
||||
initialRunAction: String? = null,
|
||||
onInitialRunHandled: () -> Unit = {},
|
||||
) {
|
||||
val navController = rememberNavController()
|
||||
@@ -118,10 +129,42 @@ fun PipelinesApp(
|
||||
// run's steps are loaded; the Runs destination applies it then (see below).
|
||||
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
|
||||
// the operator's current destination and panes are untouched while it shows.
|
||||
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
|
||||
// saved state, so a still-open field survives rotation, configuration change
|
||||
// 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
|
||||
// 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 ->
|
||||
vm.arrivedAtRun(runId)
|
||||
runSelection = PaneSelection(pane = MasterPane.Detail, itemId = runId)
|
||||
navController.navigate("runs") { launchSingleTop = true }
|
||||
}
|
||||
|
||||
// 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
|
||||
// handled, so a rotation re-opens nothing.
|
||||
LaunchedEffect(initialRunId) {
|
||||
// handled, so a rotation re-opens nothing. A waiting run's notification also
|
||||
// asks for the decision sheet, so the tap lands on the decision itself.
|
||||
LaunchedEffect(initialRunId, initialRunAction) {
|
||||
if (initialRunId != null) {
|
||||
if (initialRunAction == RUN_DEEP_LINK_ACTION_DECIDE) decisionRequest = initialRunId
|
||||
openRunFromAttention(initialRunId)
|
||||
onInitialRunHandled()
|
||||
}
|
||||
}
|
||||
|
||||
// Closing the list counts as looking: a run that merely finished since the
|
||||
// last look clears on this look, while a waiting or failed run stays until it
|
||||
// is resolved or deliberately dismissed.
|
||||
// Closing the list counts as looking, but only at what still asks: a waiting
|
||||
// or failed run stays on the surface until it is resolved or deliberately
|
||||
// dismissed, so closing never hides work that still needs the operator.
|
||||
val closeAttentionList: () -> Unit = {
|
||||
vm.sawFinishedAttention(attention.filter { it.kind == AttentionKind.Finished }.map { it.runId })
|
||||
attentionOpen = false
|
||||
}
|
||||
|
||||
// Opening an entry deals with it: a failure (like a finished run) is cleared
|
||||
// by opening it, a waiting run is not, because only its decision clears it.
|
||||
// Opening an entry deals with it: a failure is cleared by opening it, a
|
||||
// waiting run is not, because only its decision clears it.
|
||||
val openAttentionEntry: (AttentionEntry) -> Unit = { entry ->
|
||||
if (entry.kind != AttentionKind.Decision) {
|
||||
vm.dismissAttention(entry.runId, entry.kind)
|
||||
@@ -279,6 +326,8 @@ fun PipelinesApp(
|
||||
pendingNav = runSearchNav,
|
||||
onPendingNavResolved = { runSearchNav = null },
|
||||
listState = runListState,
|
||||
decisionRequest = decisionRequest,
|
||||
onDecisionRequestHandled = { decisionRequest = null },
|
||||
)
|
||||
}
|
||||
composable("chat") {
|
||||
@@ -370,6 +419,27 @@ fun PipelinesApp(
|
||||
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?,
|
||||
onPendingNavResolved: () -> Unit,
|
||||
listState: LazyListState,
|
||||
decisionRequest: Long? = null,
|
||||
onDecisionRequestHandled: () -> Unit = {},
|
||||
) {
|
||||
val depth = selection.depth
|
||||
val onBack: () -> Unit = { onSelectionChange(backFrom(selection)) }
|
||||
@@ -99,6 +101,8 @@ internal fun RunsDestination(
|
||||
)
|
||||
},
|
||||
covered = covered,
|
||||
requestDecision = decisionRequest == itemId,
|
||||
onDecisionRequestHandled = onDecisionRequestHandled,
|
||||
)
|
||||
}
|
||||
2 -> rememberPaneContent(
|
||||
|
||||
@@ -47,7 +47,6 @@ import net.awan.pipelines.ui.theme.SPACING_S
|
||||
internal fun attentionRunState(kind: AttentionKind): RunState = when (kind) {
|
||||
AttentionKind.Decision -> RunState.Waiting
|
||||
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.rememberModalBottomSheetState
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
@@ -65,6 +66,8 @@ fun DecisionPrompt(
|
||||
decision: PendingDecision?,
|
||||
onSend: (decision: PendingDecision, option: String, feedback: String, onResult: (Result<RunDetail>) -> Unit) -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
openRequest: Boolean = false,
|
||||
onOpenRequestHandled: () -> Unit = {},
|
||||
) {
|
||||
val shown = rememberPaneContent(decision)
|
||||
var open by remember { mutableStateOf(false) }
|
||||
@@ -72,6 +75,16 @@ fun DecisionPrompt(
|
||||
var sending by remember { mutableStateOf(false) }
|
||||
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) {
|
||||
DecisionCard(
|
||||
decision = decision,
|
||||
|
||||
@@ -67,6 +67,8 @@ fun RunDetailScreen(
|
||||
modifier: Modifier = Modifier,
|
||||
wide: Boolean = false,
|
||||
covered: Boolean = false,
|
||||
requestDecision: Boolean = false,
|
||||
onDecisionRequestHandled: () -> Unit = {},
|
||||
) {
|
||||
val state by vm.runDetail.collectAsStateWithLifecycle()
|
||||
val runsState by vm.runs.collectAsStateWithLifecycle()
|
||||
@@ -83,6 +85,9 @@ fun RunDetailScreen(
|
||||
val selectionState = rememberArtifactSelection(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
|
||||
// this run's evidence once (on demand; live pushes carry no evidence).
|
||||
vm.resetEvidence()
|
||||
@@ -210,6 +215,8 @@ fun RunDetailScreen(
|
||||
vm.decideRun(pending.runId, pending.stageKey, option, feedback, onResult)
|
||||
},
|
||||
modifier = Modifier.padding(horizontal = SPACING_L, vertical = SPACING_S),
|
||||
openRequest = requestDecision,
|
||||
onOpenRequestHandled = onDecisionRequestHandled,
|
||||
)
|
||||
StateCrossfade(
|
||||
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
|
||||
|
||||
/**
|
||||
* The attention surface's pure model: the event-to-entry mapping (waiting,
|
||||
* failed and nothing else), the ranking of the three kinds, an entry appearing
|
||||
* from a pushed run event and clearing when it is resolved, deliberate
|
||||
* dismissal, the empty case, persistence, and the notification's deep link.
|
||||
* The attention surface's pure model: the event-to-entry mapping (a waiting run
|
||||
* and a failed run, and nothing else — a successful run is never announced), the
|
||||
* ranking of the two kinds, an entry appearing from a pushed run event and
|
||||
* clearing when it is resolved, deliberate dismissal, the empty case, persistence,
|
||||
* and the notification's deep link.
|
||||
*/
|
||||
class AttentionTest {
|
||||
|
||||
@@ -45,10 +46,10 @@ class AttentionTest {
|
||||
// --- mapping ---------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
fun onlyWaitingFailedAndFinishedAskForAttention() {
|
||||
fun onlyAWaitingOrFailedRunAsksForAttention() {
|
||||
assertEquals(AttentionKind.Decision, attentionKindOf("waiting"))
|
||||
assertEquals(AttentionKind.Failed, attentionKindOf("failed"))
|
||||
assertEquals(AttentionKind.Finished, attentionKindOf("succeeded"))
|
||||
assertNull(attentionKindOf("succeeded"))
|
||||
assertNull(attentionKindOf("queued"))
|
||||
assertNull(attentionKindOf("running"))
|
||||
assertNull(attentionKindOf("canceled"))
|
||||
@@ -68,7 +69,7 @@ class AttentionTest {
|
||||
),
|
||||
AttentionState(),
|
||||
)
|
||||
assertEquals(3, entries.size)
|
||||
assertEquals(2, entries.size)
|
||||
val decision = entries[0]
|
||||
assertEquals(AttentionKind.Decision, decision.kind)
|
||||
assertEquals("Ship 1.4", decision.label)
|
||||
@@ -77,25 +78,21 @@ class AttentionTest {
|
||||
val failed = entries[1]
|
||||
assertEquals(AttentionKind.Failed, failed.kind)
|
||||
assertEquals("provider returned 500", failed.detail)
|
||||
val finished = entries[2]
|
||||
assertEquals(AttentionKind.Finished, finished.kind)
|
||||
assertEquals("nightly", finished.label)
|
||||
}
|
||||
|
||||
// --- ordering --------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
fun decisionRanksBeforeFailedBeforeFinished() {
|
||||
fun decisionRanksBeforeFailed() {
|
||||
val entries = attentionEntries(
|
||||
listOf(
|
||||
run(3, "succeeded", finishedAt = "2026-10-17T09:09:00Z"),
|
||||
run(2, "failed", finishedAt = "2026-10-17T09:08:00Z"),
|
||||
run(1, "waiting"),
|
||||
),
|
||||
AttentionState(),
|
||||
)
|
||||
assertEquals(listOf(AttentionKind.Decision, AttentionKind.Failed, AttentionKind.Finished), entries.map { it.kind })
|
||||
assertEquals(listOf(1L, 2L, 3L), entries.map { it.runId })
|
||||
assertEquals(listOf(AttentionKind.Decision, AttentionKind.Failed), entries.map { it.kind })
|
||||
assertEquals(listOf(1L, 2L), entries.map { it.runId })
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -142,7 +139,7 @@ class AttentionTest {
|
||||
assertTrue(attentionEntries(retried, AttentionState()).isEmpty())
|
||||
}
|
||||
|
||||
// --- dismissal and look ----------------------------------------------------
|
||||
// --- dismissal -------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
fun aDeliberateDismissalRemovesAnEntryForGood() {
|
||||
@@ -155,11 +152,16 @@ class AttentionTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aFinishedRunClearsOnceTheOperatorHasLooked() {
|
||||
val runs = listOf(run(1, "succeeded"))
|
||||
assertEquals(1, attentionEntries(runs, AttentionState()).size)
|
||||
val looked = AttentionState().lookedAtFinished(setOf(1L))
|
||||
assertTrue(attentionEntries(runs, looked).isEmpty())
|
||||
fun aSuccessfulRunIsNeverListed() {
|
||||
assertTrue(attentionEntries(listOf(run(1, "succeeded")), AttentionState()).isEmpty())
|
||||
// Even a finished run that was never looked at does not appear: a
|
||||
// successful run raises nothing on any surface.
|
||||
assertTrue(
|
||||
attentionEntries(
|
||||
listOf(run(2, "succeeded"), run(3, "running"), run(4, "canceled")),
|
||||
AttentionState(),
|
||||
).isEmpty(),
|
||||
)
|
||||
}
|
||||
|
||||
// --- empty case ------------------------------------------------------------
|
||||
@@ -169,7 +171,13 @@ class AttentionTest {
|
||||
assertTrue(attentionEntries(emptyList(), AttentionState()).isEmpty())
|
||||
assertTrue(
|
||||
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(),
|
||||
).isEmpty(),
|
||||
)
|
||||
@@ -182,18 +190,21 @@ class AttentionTest {
|
||||
assertEquals("A run is waiting for you", attentionHeadline(decision))
|
||||
val failed = attentionEntries(listOf(run(2, "failed"), run(3, "failed")), AttentionState())
|
||||
assertEquals("2 runs need you", attentionHeadline(failed))
|
||||
val singleFailed = attentionEntries(listOf(run(4, "failed")), AttentionState())
|
||||
assertEquals("A run failed", attentionHeadline(singleFailed))
|
||||
}
|
||||
|
||||
// --- persistence -----------------------------------------------------------
|
||||
|
||||
@Test
|
||||
fun attentionStateSurvivesAnEncodeDecodeRoundTrip() {
|
||||
val state = AttentionState()
|
||||
.dismissed(attentionKey(7, AttentionKind.Failed))
|
||||
.lookedAtFinished(setOf(9L, 11L))
|
||||
val state = AttentionState().dismissed(attentionKey(7, AttentionKind.Failed))
|
||||
assertEquals(state, AttentionState.decode(state.encode()))
|
||||
assertEquals(AttentionState(), AttentionState.decode(""))
|
||||
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 ------------------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user