Merge notif: post real system-tray notifications when a run needs the operator
This commit is contained in:
@@ -3,6 +3,14 @@
|
||||
|
||||
<uses-permission android:name="android.permission.INTERNET" />
|
||||
<uses-permission android:name="android.permission.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