Merge notif: post real system-tray notifications when a run needs the operator

This commit is contained in:
2026-10-17 23:58:07 +01:00
16 changed files with 1010 additions and 83 deletions
+8
View File
@@ -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 ------------------------------------------------