Merge: Android in-app notification service
This commit is contained in:
@@ -53,4 +53,10 @@ flutter {
|
||||
|
||||
dependencies {
|
||||
coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.4")
|
||||
// The background notification socket (notify/NotificationService).
|
||||
implementation("com.squareup.okhttp3:okhttp:4.12.0")
|
||||
// JVM tests for the notification protocol and ledger (`gradlew :app:testDebugUnitTest`).
|
||||
testImplementation("junit:junit:4.13.2")
|
||||
// Android's org.json is a stub on the JVM; tests use the real implementation.
|
||||
testImplementation("org.json:json:20180813")
|
||||
}
|
||||
|
||||
@@ -4,6 +4,14 @@
|
||||
<uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES"/>
|
||||
<!-- The client reaches the Pipelines server over the shared socket. -->
|
||||
<uses-permission android:name="android.permission.INTERNET"/>
|
||||
<!-- Background delivery (notify/NotificationService): a foreground
|
||||
service keeps the notification socket open, starts at boot, follows
|
||||
network changes and may ask to be exempt from battery optimisation. -->
|
||||
<uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
|
||||
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE"/>
|
||||
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
|
||||
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
|
||||
<uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
|
||||
<!-- Explicit ws:// LAN/VPN profiles are supported; no automatic TLS
|
||||
downgrade or discovery is performed. Settings warns about cleartext. -->
|
||||
<application
|
||||
@@ -45,6 +53,28 @@
|
||||
<data android:scheme="pipelines" android:host="chat" />
|
||||
</intent-filter>
|
||||
</activity>
|
||||
<!-- Instant delivery of server notifications without the ntfy app.
|
||||
specialUse: a persistent push connection to a self-hosted server
|
||||
has no dedicated type, and dataSync is time-limited on Android 15. -->
|
||||
<service
|
||||
android:name=".notify.NotificationService"
|
||||
android:exported="false"
|
||||
android:foregroundServiceType="specialUse">
|
||||
<property
|
||||
android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
|
||||
android:value="Persistent connection to the user's self-hosted Pipelines server for instant notifications"/>
|
||||
</service>
|
||||
<receiver
|
||||
android:name=".notify.NotificationDismissReceiver"
|
||||
android:exported="false"/>
|
||||
<receiver
|
||||
android:name=".notify.BootReceiver"
|
||||
android:exported="false">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.BOOT_COMPLETED"/>
|
||||
<action android:name="android.intent.action.MY_PACKAGE_REPLACED"/>
|
||||
</intent-filter>
|
||||
</receiver>
|
||||
<!-- Don't delete the meta-data below.
|
||||
This is used by the Flutter tool to generate GeneratedPluginRegistrant.java -->
|
||||
<meta-data
|
||||
|
||||
@@ -1,5 +1,44 @@
|
||||
package net.awan.pipelines_app
|
||||
|
||||
import android.content.Intent
|
||||
import android.os.Bundle
|
||||
import io.flutter.embedding.android.FlutterActivity
|
||||
import io.flutter.embedding.engine.FlutterEngine
|
||||
import net.awan.pipelines_app.notify.NotificationDismissReceiver
|
||||
import net.awan.pipelines_app.notify.NotificationPresenter
|
||||
import net.awan.pipelines_app.notify.NotificationServiceChannel
|
||||
|
||||
class MainActivity : FlutterActivity()
|
||||
class MainActivity : FlutterActivity() {
|
||||
private var notificationChannel: NotificationServiceChannel? = null
|
||||
|
||||
override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
|
||||
super.configureFlutterEngine(flutterEngine)
|
||||
notificationChannel = NotificationServiceChannel(this, flutterEngine.dartExecutor.binaryMessenger)
|
||||
}
|
||||
|
||||
override fun cleanUpFlutterEngine(flutterEngine: FlutterEngine) {
|
||||
notificationChannel?.dispose()
|
||||
notificationChannel = null
|
||||
super.cleanUpFlutterEngine(flutterEngine)
|
||||
}
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
if (savedInstanceState == null) clearOpenedNotification(intent)
|
||||
}
|
||||
|
||||
override fun onNewIntent(intent: Intent) {
|
||||
super.onNewIntent(intent)
|
||||
clearOpenedNotification(intent)
|
||||
}
|
||||
|
||||
/**
|
||||
* A tapped server notification is opened here (Flutter routes its
|
||||
* pipelines:// link) and cleared on the server, so other devices drop it.
|
||||
*/
|
||||
private fun clearOpenedNotification(intent: Intent?) {
|
||||
val id = intent?.getStringExtra(NotificationPresenter.EXTRA_NOTIFICATION_ID) ?: return
|
||||
intent.removeExtra(NotificationPresenter.EXTRA_NOTIFICATION_ID)
|
||||
NotificationDismissReceiver.queueClear(this, id)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
/** Exponential reconnect delay: base, 2x, 4x … capped at [maxMillis]. */
|
||||
class Backoff(private val baseMillis: Long = 1_000, private val maxMillis: Long = 5 * 60_000) {
|
||||
var attempt = 0
|
||||
private set
|
||||
|
||||
fun next(): Long {
|
||||
val shift = attempt.coerceAtMost(20)
|
||||
attempt++
|
||||
return (baseMillis shl shift).coerceAtMost(maxMillis)
|
||||
}
|
||||
|
||||
fun reset() {
|
||||
attempt = 0
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
import android.content.BroadcastReceiver
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
|
||||
/** Restarts background delivery after a reboot or an app update. */
|
||||
class BootReceiver : BroadcastReceiver() {
|
||||
override fun onReceive(context: Context, intent: Intent) {
|
||||
when (intent.action) {
|
||||
Intent.ACTION_BOOT_COMPLETED,
|
||||
Intent.ACTION_MY_PACKAGE_REPLACED,
|
||||
-> NotificationService.start(context)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
/** The few persisted strings the ledger needs; SharedPreferences in the app. */
|
||||
interface LedgerStore {
|
||||
fun getString(key: String): String?
|
||||
fun putString(key: String, value: String?)
|
||||
}
|
||||
|
||||
/**
|
||||
* What this device has already delivered for one server: the replay cursor
|
||||
* (the last notification id received), a bounded set of shown ids so a replay
|
||||
* never alerts twice, and the clears waiting to be sent.
|
||||
*
|
||||
* Switching to another server ([bindServer]) forgets the previous server's
|
||||
* cursor and history, because notification ids are only unique per server.
|
||||
*/
|
||||
class DeliveryLedger(private val store: LedgerStore, private val maxShown: Int = 500) {
|
||||
val cursor: String? get() = store.getString(CURSOR)?.takeIf { it.isNotEmpty() }
|
||||
|
||||
/** Returns true when [serverId] differs from the bound server (state was reset). */
|
||||
fun bindServer(serverId: String): Boolean {
|
||||
if (store.getString(SERVER) == serverId) return false
|
||||
store.putString(SERVER, serverId)
|
||||
store.putString(CURSOR, null)
|
||||
store.putString(SHOWN, null)
|
||||
store.putString(PENDING, null)
|
||||
return true
|
||||
}
|
||||
|
||||
/**
|
||||
* Records a received batch and returns only the notifications not shown
|
||||
* before, in order. The cursor advances to the last id in the batch even
|
||||
* when every item was a duplicate.
|
||||
*/
|
||||
fun accept(batch: List<ServerNotification>): List<ServerNotification> {
|
||||
if (batch.isEmpty()) return emptyList()
|
||||
val shown = shownIds().toMutableList()
|
||||
val fresh = mutableListOf<ServerNotification>()
|
||||
for (notification in batch) {
|
||||
if (notification.id in shown) continue
|
||||
shown.add(notification.id)
|
||||
fresh.add(notification)
|
||||
}
|
||||
while (shown.size > maxShown) shown.removeAt(0)
|
||||
store.putString(SHOWN, encode(shown))
|
||||
store.putString(CURSOR, batch.last().id)
|
||||
return fresh
|
||||
}
|
||||
|
||||
fun shownIds(): List<String> = decode(store.getString(SHOWN))
|
||||
|
||||
/** Queues ids the user dismissed or opened, until a socket can send them. */
|
||||
fun queueClear(ids: Collection<String>) {
|
||||
if (ids.isEmpty()) return
|
||||
val pending = LinkedHashSet(pendingClears())
|
||||
pending.addAll(ids.filter { it.isNotEmpty() })
|
||||
store.putString(PENDING, encode(pending.toList()))
|
||||
}
|
||||
|
||||
fun pendingClears(): List<String> = decode(store.getString(PENDING))
|
||||
|
||||
/** Drops [ids] from the queue once they were written to an open socket. */
|
||||
fun clearsSent(ids: Collection<String>) {
|
||||
val remaining = pendingClears().filterNot { it in ids }
|
||||
store.putString(PENDING, if (remaining.isEmpty()) null else encode(remaining))
|
||||
}
|
||||
|
||||
companion object {
|
||||
const val SERVER = "ledger.server"
|
||||
const val CURSOR = "ledger.cursor"
|
||||
const val SHOWN = "ledger.shown"
|
||||
const val PENDING = "ledger.pendingClears"
|
||||
|
||||
// Ids are opaque server strings; newline is not a valid id character.
|
||||
private fun encode(ids: List<String>) = ids.joinToString("\n")
|
||||
private fun decode(raw: String?): List<String> =
|
||||
raw?.split('\n')?.filter { it.isNotEmpty() } ?: emptyList()
|
||||
|
||||
/** A stable Android notification id for a server id string. */
|
||||
fun notificationId(id: String): Int {
|
||||
// FNV-1a keeps the mapping stable across processes and releases,
|
||||
// unlike String.hashCode collisions with the reserved ids below.
|
||||
var hash = 0x811c9dc5.toInt()
|
||||
for (char in id) {
|
||||
hash = hash xor char.code
|
||||
hash *= 0x01000193
|
||||
}
|
||||
val positive = hash and 0x7fffffff
|
||||
return if (positive <= RESERVED_IDS) positive + RESERVED_IDS + 1 else positive
|
||||
}
|
||||
|
||||
/** Ids at or below this are reserved for the service's own notifications. */
|
||||
const val RESERVED_IDS = 16
|
||||
}
|
||||
}
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
import android.content.BroadcastReceiver
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
|
||||
/**
|
||||
* A swiped-away notification is cleared on the server, so every device drops
|
||||
* it. The id is queued durably and sent by the service when it is connected.
|
||||
*/
|
||||
class NotificationDismissReceiver : BroadcastReceiver() {
|
||||
override fun onReceive(context: Context, intent: Intent) {
|
||||
if (intent.action != ACTION) return
|
||||
val id = intent.getStringExtra(NotificationPresenter.EXTRA_NOTIFICATION_ID) ?: return
|
||||
queueClear(context, id)
|
||||
}
|
||||
|
||||
companion object {
|
||||
const val ACTION = "net.awan.pipelines.notify.DISMISSED"
|
||||
|
||||
/** Shared by dismissals and taps (see MainActivity). */
|
||||
fun queueClear(context: Context, id: String) {
|
||||
DeliveryLedger(ServiceSettings(context)).queueClear(listOf(id))
|
||||
// Only nudge a running service; a stopped one sends the queue on
|
||||
// its next connection.
|
||||
if (NotificationService.running != null) {
|
||||
NotificationService.start(context, NotificationService.ACTION_FLUSH)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+239
@@ -0,0 +1,239 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
import android.app.Notification
|
||||
import android.app.NotificationChannel
|
||||
import android.app.NotificationChannelGroup
|
||||
import android.app.NotificationManager
|
||||
import android.app.PendingIntent
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.net.Uri
|
||||
import android.os.Build
|
||||
import net.awan.pipelines_app.MainActivity
|
||||
import net.awan.pipelines_app.R
|
||||
|
||||
/**
|
||||
* Posts server notifications in the system tray: one channel per kind and
|
||||
* priority (created lazily, grouped by kind), Android groups by the server's
|
||||
* `group`, a tap opens the app at the `click` deep link, and a dismissal is
|
||||
* reported back so the server clears it everywhere.
|
||||
*/
|
||||
class NotificationPresenter(private val context: Context) {
|
||||
private val manager = context.getSystemService(NotificationManager::class.java)
|
||||
|
||||
fun connectionNotification(status: DeliveryStatus): Notification {
|
||||
ensureChannel(CONNECTION_CHANNEL, "Connection", NotificationManager.IMPORTANCE_MIN, null)
|
||||
val text = when (status) {
|
||||
DeliveryStatus.CONNECTED -> "Pipelines is connected"
|
||||
DeliveryStatus.WAITING_FOR_NETWORK -> "Pipelines is waiting for a network"
|
||||
DeliveryStatus.CONNECTING -> "Pipelines is connecting…"
|
||||
else -> "Pipelines is reconnecting…"
|
||||
}
|
||||
val open = PendingIntent.getActivity(
|
||||
context,
|
||||
0,
|
||||
Intent(context, MainActivity::class.java).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK),
|
||||
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
|
||||
)
|
||||
return builder(CONNECTION_CHANNEL)
|
||||
.setSmallIcon(R.drawable.ic_stat_pipelines)
|
||||
.setContentTitle(text)
|
||||
.setContentText("Delivering notifications from your server")
|
||||
.setOngoing(true)
|
||||
.setShowWhen(false)
|
||||
.setContentIntent(open)
|
||||
.setCategory(Notification.CATEGORY_SERVICE)
|
||||
.build()
|
||||
}
|
||||
|
||||
fun updateConnection(status: DeliveryStatus) {
|
||||
manager.notify(CONNECTION_ID, connectionNotification(status))
|
||||
}
|
||||
|
||||
fun show(notification: ServerNotification) {
|
||||
val id = DeliveryLedger.notificationId(notification.id)
|
||||
val channel = channelFor(notification)
|
||||
val title = notification.title.ifEmpty { "Pipelines" }
|
||||
val builder = builder(channel)
|
||||
.setSmallIcon(R.drawable.ic_stat_pipelines)
|
||||
.setContentTitle(title)
|
||||
.setContentText(notification.message)
|
||||
.setStyle(Notification.BigTextStyle().bigText(notification.message))
|
||||
.setAutoCancel(true)
|
||||
.setContentIntent(openIntent(notification, id))
|
||||
.setDeleteIntent(dismissIntent(notification.id, id))
|
||||
createdMillis(notification.createdAt)?.let { builder.setWhen(it).setShowWhen(true) }
|
||||
if (notification.group.isNotEmpty()) builder.setGroup(notification.group)
|
||||
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
|
||||
@Suppress("DEPRECATION")
|
||||
builder.setPriority(effectivePriority(notification.kind, notification.priority) - 3)
|
||||
}
|
||||
manager.notify(id, builder.build())
|
||||
if (notification.group.isNotEmpty()) updateSummary(notification.group, channel)
|
||||
}
|
||||
|
||||
/** Removes notifications cleared on this or another device. */
|
||||
fun cancel(ids: Collection<String>) {
|
||||
val groups = mutableSetOf<String>()
|
||||
val active = manager.activeNotifications
|
||||
for (id in ids) {
|
||||
val notificationId = DeliveryLedger.notificationId(id)
|
||||
active.firstOrNull { it.id == notificationId }?.notification?.group?.let(groups::add)
|
||||
manager.cancel(notificationId)
|
||||
}
|
||||
groups.forEach { updateSummary(it, null) }
|
||||
}
|
||||
|
||||
/** Removes every server notification, keeping the connection one. */
|
||||
fun cancelAll() {
|
||||
manager.activeNotifications
|
||||
.filter { it.id != CONNECTION_ID }
|
||||
.forEach { manager.cancel(it.tag, it.id) }
|
||||
}
|
||||
|
||||
private fun updateSummary(group: String, channel: String?) {
|
||||
val summaryId = DeliveryLedger.notificationId("group:$group")
|
||||
val members = manager.activeNotifications.count {
|
||||
it.notification.group == group && it.id != summaryId
|
||||
}
|
||||
if (members < 2) {
|
||||
if (members == 0) manager.cancel(summaryId)
|
||||
return
|
||||
}
|
||||
val existing = manager.activeNotifications.firstOrNull { it.id == summaryId }
|
||||
val summaryChannel = channel ?: existing?.notification?.channelIdCompat() ?: return
|
||||
manager.notify(
|
||||
summaryId,
|
||||
builder(summaryChannel)
|
||||
.setSmallIcon(R.drawable.ic_stat_pipelines)
|
||||
.setContentTitle("Pipelines")
|
||||
.setContentText("$members notifications")
|
||||
.setGroup(group)
|
||||
.setGroupSummary(true)
|
||||
.setGroupAlertBehavior(Notification.GROUP_ALERT_CHILDREN)
|
||||
.setAutoCancel(true)
|
||||
.build(),
|
||||
)
|
||||
}
|
||||
|
||||
private fun Notification.channelIdCompat(): String? =
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) channelId else CONNECTION_CHANNEL
|
||||
|
||||
private fun openIntent(notification: ServerNotification, requestCode: Int): PendingIntent {
|
||||
val intent = Intent(context, MainActivity::class.java)
|
||||
.addFlags(
|
||||
Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP or
|
||||
Intent.FLAG_ACTIVITY_CLEAR_TOP,
|
||||
)
|
||||
.putExtra(EXTRA_NOTIFICATION_ID, notification.id)
|
||||
// Only the app's own links are routed; Flutter's deep-link handling
|
||||
// turns pipelines://run/<id> and pipelines://chat/<id> into a route.
|
||||
val click = Uri.parse(notification.click)
|
||||
if (click.scheme == "pipelines") intent.setAction(Intent.ACTION_VIEW).setData(click)
|
||||
return PendingIntent.getActivity(
|
||||
context,
|
||||
requestCode,
|
||||
intent,
|
||||
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
|
||||
)
|
||||
}
|
||||
|
||||
private fun dismissIntent(serverId: String, requestCode: Int): PendingIntent =
|
||||
PendingIntent.getBroadcast(
|
||||
context,
|
||||
requestCode,
|
||||
Intent(context, NotificationDismissReceiver::class.java)
|
||||
.setAction(NotificationDismissReceiver.ACTION)
|
||||
.putExtra(EXTRA_NOTIFICATION_ID, serverId),
|
||||
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
|
||||
)
|
||||
|
||||
private fun channelFor(notification: ServerNotification): String {
|
||||
val kind = notification.kind.replace(Regex("[^A-Za-z0-9_.-]"), "_")
|
||||
val priority = effectivePriority(kind, notification.priority)
|
||||
val id = "pipelines.$kind.p$priority"
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
||||
val groupId = "pipelines.kind.$kind"
|
||||
manager.createNotificationChannelGroup(NotificationChannelGroup(groupId, kindLabel(kind)))
|
||||
val name = if (priority == kindPriority(kind)) kindLabel(kind)
|
||||
else "${kindLabel(kind)} (${priorityLabel(priority)})"
|
||||
ensureChannel(id, name, importance(priority), groupId)
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
private fun ensureChannel(id: String, name: String, importance: Int, group: String?) {
|
||||
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
|
||||
if (manager.getNotificationChannel(id) != null) return
|
||||
val channel = NotificationChannel(id, name, importance)
|
||||
if (group != null) channel.group = group
|
||||
if (id == CONNECTION_CHANNEL) {
|
||||
channel.description = "Shown while Pipelines keeps its notification connection open"
|
||||
channel.setShowBadge(false)
|
||||
}
|
||||
manager.createNotificationChannel(channel)
|
||||
}
|
||||
|
||||
@Suppress("DEPRECATION")
|
||||
private fun builder(channel: String): Notification.Builder =
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) Notification.Builder(context, channel)
|
||||
else Notification.Builder(context)
|
||||
|
||||
companion object {
|
||||
const val CONNECTION_ID = 1
|
||||
const val CONNECTION_CHANNEL = "pipelines.connection"
|
||||
const val EXTRA_NOTIFICATION_ID = "net.awan.pipelines.notification_id"
|
||||
|
||||
private val KIND_LABELS = mapOf(
|
||||
"run_waiting" to "Run waiting for you",
|
||||
"run_failed" to "Run failed",
|
||||
"run_succeeded" to "Run succeeded",
|
||||
"stage_failed" to "Stage failed",
|
||||
"stage_succeeded" to "Stage succeeded",
|
||||
"chat_question" to "Chat question",
|
||||
"chat_approval" to "Chat approval",
|
||||
"chat_reply" to "Chat reply",
|
||||
)
|
||||
|
||||
fun importance(priority: Int): Int = when (priority) {
|
||||
1 -> NotificationManager.IMPORTANCE_MIN
|
||||
2 -> NotificationManager.IMPORTANCE_LOW
|
||||
3 -> NotificationManager.IMPORTANCE_DEFAULT
|
||||
else -> NotificationManager.IMPORTANCE_HIGH
|
||||
}
|
||||
|
||||
fun priorityLabel(priority: Int): String = when (priority) {
|
||||
1 -> "Min priority"
|
||||
2 -> "Low priority"
|
||||
3 -> "Default priority"
|
||||
4 -> "High priority"
|
||||
else -> "Urgent"
|
||||
}
|
||||
|
||||
/**
|
||||
* The server sends the default priority (3) for everything, so the
|
||||
* kind decides how loudly a notification arrives; an explicit
|
||||
* non-default priority still wins.
|
||||
*/
|
||||
fun effectivePriority(kind: String, priority: Int): Int =
|
||||
if (priority != 3) priority else kindPriority(kind)
|
||||
|
||||
fun kindPriority(kind: String): Int = when (kind) {
|
||||
"run_waiting", "run_failed", "stage_failed", "chat_question", "chat_approval" -> 4
|
||||
"stage_succeeded" -> 2
|
||||
else -> 3
|
||||
}
|
||||
|
||||
fun kindLabel(kind: String): String = KIND_LABELS[kind] ?:
|
||||
kind.split('_', '-', '.').filter { it.isNotEmpty() }
|
||||
.joinToString(" ") { it.replaceFirstChar(Char::uppercaseChar) }
|
||||
.ifEmpty { "Notifications" }
|
||||
|
||||
fun createdMillis(createdAt: String): Long? = try {
|
||||
if (createdAt.isEmpty()) null
|
||||
else java.time.OffsetDateTime.parse(createdAt).toInstant().toEpochMilli()
|
||||
} catch (_: Exception) {
|
||||
null
|
||||
}
|
||||
}
|
||||
}
|
||||
+115
@@ -0,0 +1,115 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
|
||||
/** One server notification as pushed on the shared socket. */
|
||||
data class ServerNotification(
|
||||
val id: String,
|
||||
val kind: String,
|
||||
val title: String,
|
||||
val message: String,
|
||||
val click: String,
|
||||
/** ntfy-style priority, clamped to 1..5 (3 is the default). */
|
||||
val priority: Int,
|
||||
val tags: List<String>,
|
||||
val createdAt: String,
|
||||
val group: String,
|
||||
)
|
||||
|
||||
/** The frames the notification service reacts to; everything else is [Ignored]. */
|
||||
sealed interface NotificationFrame {
|
||||
/** [clearedIds]: notifications cleared recently (while this device was away). */
|
||||
data class Subscribed(
|
||||
val notifications: List<ServerNotification>,
|
||||
val clearedIds: List<String> = emptyList(),
|
||||
) : NotificationFrame
|
||||
data class Pushed(val notification: ServerNotification) : NotificationFrame
|
||||
data class Cleared(val ids: List<String>) : NotificationFrame
|
||||
data class Refused(val requestId: String, val error: String) : NotificationFrame
|
||||
data object Ignored : NotificationFrame
|
||||
}
|
||||
|
||||
/**
|
||||
* The wire contract of `subscribe_notifications`, `notification`,
|
||||
* `notifications_cleared` and `clear_notifications`. Pure, so it is covered by
|
||||
* JVM unit tests without a device.
|
||||
*/
|
||||
object NotificationProtocol {
|
||||
fun subscribe(requestId: String, after: String?): String {
|
||||
val frame = JSONObject()
|
||||
.put("type", "subscribe_notifications")
|
||||
.put("id", requestId)
|
||||
if (!after.isNullOrEmpty()) frame.put("after", after)
|
||||
return frame.toString()
|
||||
}
|
||||
|
||||
fun clear(requestId: String, ids: Collection<String>): String =
|
||||
JSONObject()
|
||||
.put("type", "clear_notifications")
|
||||
.put("id", requestId)
|
||||
.put("ids", JSONArray(ids.toList()))
|
||||
.toString()
|
||||
|
||||
/** Parses one text frame; malformed input is [NotificationFrame.Ignored]. */
|
||||
fun parse(text: String, subscribeRequestId: String?): NotificationFrame {
|
||||
val frame = try {
|
||||
JSONObject(text)
|
||||
} catch (_: Exception) {
|
||||
return NotificationFrame.Ignored
|
||||
}
|
||||
return when (frame.optString("type")) {
|
||||
"notifications_subscribed" -> NotificationFrame.Subscribed(
|
||||
notifications(frame.optJSONArray("notifications")),
|
||||
strings(frame.optJSONArray("ids")),
|
||||
)
|
||||
"notification" -> notification(frame.optJSONObject("notification") ?: frame)
|
||||
?.let { NotificationFrame.Pushed(it) }
|
||||
?: NotificationFrame.Ignored
|
||||
"notifications_cleared" -> NotificationFrame.Cleared(strings(frame.optJSONArray("ids")))
|
||||
"error" -> {
|
||||
val id = frame.optString("id")
|
||||
if (subscribeRequestId != null && id == subscribeRequestId) {
|
||||
NotificationFrame.Refused(id, frame.text("error"))
|
||||
} else {
|
||||
NotificationFrame.Ignored
|
||||
}
|
||||
}
|
||||
else -> NotificationFrame.Ignored
|
||||
}
|
||||
}
|
||||
|
||||
private fun notifications(array: JSONArray?): List<ServerNotification> {
|
||||
if (array == null) return emptyList()
|
||||
return (0 until array.length()).mapNotNull { index ->
|
||||
array.optJSONObject(index)?.let(::notification)
|
||||
}
|
||||
}
|
||||
|
||||
fun notification(json: JSONObject): ServerNotification? {
|
||||
val id = json.text("id").trim()
|
||||
if (id.isEmpty()) return null
|
||||
return ServerNotification(
|
||||
id = id,
|
||||
kind = json.text("kind").trim().ifEmpty { "general" },
|
||||
title = json.text("title"),
|
||||
message = json.text("message"),
|
||||
click = json.text("click").trim(),
|
||||
priority = json.optInt("priority", 3).let { if (it in 1..5) it else 3 },
|
||||
tags = strings(json.optJSONArray("tags")),
|
||||
createdAt = json.text("created_at"),
|
||||
group = json.text("group").trim(),
|
||||
)
|
||||
}
|
||||
|
||||
/** org.json renders a JSON null as the text "null"; treat it as absent. */
|
||||
private fun JSONObject.text(key: String): String =
|
||||
if (isNull(key)) "" else optString(key)
|
||||
|
||||
private fun strings(array: JSONArray?): List<String> {
|
||||
if (array == null) return emptyList()
|
||||
return (0 until array.length()).mapNotNull { index ->
|
||||
array.optString(index, "").trim().takeIf { it.isNotEmpty() }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,293 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
import android.app.Service
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.pm.ServiceInfo
|
||||
import android.net.ConnectivityManager
|
||||
import android.net.Network
|
||||
import android.os.Build
|
||||
import android.os.Handler
|
||||
import android.os.HandlerThread
|
||||
import android.os.IBinder
|
||||
import android.util.Log
|
||||
import okhttp3.OkHttpClient
|
||||
import okhttp3.Request
|
||||
import okhttp3.Response
|
||||
import okhttp3.WebSocket
|
||||
import okhttp3.WebSocketListener
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
/**
|
||||
* Keeps one authenticated websocket to the configured Pipelines server while
|
||||
* the app is in the background, like ntfy's instant delivery: no Flutter
|
||||
* engine runs here. It subscribes with the replay cursor, posts each pushed
|
||||
* notification, mirrors cross-device clears and sends the user's own clears.
|
||||
*
|
||||
* All state is confined to [handler]'s thread; OkHttp and connectivity
|
||||
* callbacks post onto it.
|
||||
*/
|
||||
class NotificationService : Service() {
|
||||
private lateinit var settings: ServiceSettings
|
||||
private lateinit var ledger: DeliveryLedger
|
||||
private lateinit var presenter: NotificationPresenter
|
||||
private lateinit var thread: HandlerThread
|
||||
private lateinit var handler: Handler
|
||||
private val client = OkHttpClient.Builder()
|
||||
.connectTimeout(15, TimeUnit.SECONDS)
|
||||
.readTimeout(0, TimeUnit.MILLISECONDS)
|
||||
.pingInterval(45, TimeUnit.SECONDS)
|
||||
.followRedirects(false)
|
||||
.build()
|
||||
private val backoff = Backoff()
|
||||
private var socket: WebSocket? = null
|
||||
private var generation = 0
|
||||
private var endpointIndex = 0
|
||||
private var subscribeId: String? = null
|
||||
private var sequence = 0
|
||||
private var networkAvailable = true
|
||||
private var currentNetwork: Network? = null
|
||||
private var networkCallback: ConnectivityManager.NetworkCallback? = null
|
||||
private val reconnect = Runnable { connect() }
|
||||
|
||||
override fun onBind(intent: Intent?): IBinder? = null
|
||||
|
||||
override fun onCreate() {
|
||||
super.onCreate()
|
||||
settings = ServiceSettings(this)
|
||||
ledger = DeliveryLedger(settings)
|
||||
presenter = NotificationPresenter(this)
|
||||
thread = HandlerThread("pipelines-notifications").also { it.start() }
|
||||
handler = Handler(thread.looper)
|
||||
goForeground(DeliveryStatus.CONNECTING)
|
||||
watchNetwork()
|
||||
running = this
|
||||
}
|
||||
|
||||
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
|
||||
val action = intent?.action
|
||||
handler.post {
|
||||
when {
|
||||
!settings.enabled || !settings.configured -> stopEverything()
|
||||
action == ACTION_FLUSH -> flushClears()
|
||||
action == ACTION_RESTART || socket == null -> restart()
|
||||
}
|
||||
}
|
||||
return START_STICKY
|
||||
}
|
||||
|
||||
override fun onDestroy() {
|
||||
running = null
|
||||
networkCallback?.let {
|
||||
getSystemService(ConnectivityManager::class.java).unregisterNetworkCallback(it)
|
||||
}
|
||||
handler.removeCallbacksAndMessages(null)
|
||||
handler.post {
|
||||
generation++
|
||||
socket?.close(1000, "service stopped")
|
||||
socket = null
|
||||
}
|
||||
thread.quitSafely()
|
||||
if (settings.status != DeliveryStatus.UNCONFIGURED) setStatus(DeliveryStatus.OFF, notify = false)
|
||||
super.onDestroy()
|
||||
}
|
||||
|
||||
private fun goForeground(status: DeliveryStatus) {
|
||||
val notification = presenter.connectionNotification(status)
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
|
||||
startForeground(
|
||||
NotificationPresenter.CONNECTION_ID,
|
||||
notification,
|
||||
ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE,
|
||||
)
|
||||
} else {
|
||||
startForeground(NotificationPresenter.CONNECTION_ID, notification)
|
||||
}
|
||||
}
|
||||
|
||||
private fun stopEverything() {
|
||||
generation++
|
||||
socket?.close(1000, "disabled")
|
||||
socket = null
|
||||
setStatus(if (settings.configured) DeliveryStatus.OFF else DeliveryStatus.UNCONFIGURED, notify = false)
|
||||
stopForeground(STOP_FOREGROUND_REMOVE)
|
||||
stopSelf()
|
||||
}
|
||||
|
||||
/** Server changed, credentials changed, or the first start: reopen now. */
|
||||
private fun restart() {
|
||||
if (ledger.bindServer(settings.serverId)) presenter.cancelAll()
|
||||
handler.removeCallbacks(reconnect)
|
||||
backoff.reset()
|
||||
endpointIndex = 0
|
||||
connect()
|
||||
}
|
||||
|
||||
private fun connect() {
|
||||
handler.removeCallbacks(reconnect)
|
||||
generation++
|
||||
socket?.cancel()
|
||||
socket = null
|
||||
subscribeId = null
|
||||
val endpoints = settings.endpoints
|
||||
if (endpoints.isEmpty()) return stopEverything()
|
||||
if (!networkAvailable) return setStatus(DeliveryStatus.WAITING_FOR_NETWORK)
|
||||
val endpoint = endpoints[endpointIndex % endpoints.size]
|
||||
val request = try {
|
||||
Request.Builder().url(endpoint).apply {
|
||||
if (settings.cookie.isNotEmpty()) header("Cookie", settings.cookie)
|
||||
}.build()
|
||||
} catch (error: IllegalArgumentException) {
|
||||
Log.w(TAG, "invalid endpoint $endpoint", error)
|
||||
return scheduleReconnect()
|
||||
}
|
||||
setStatus(if (backoff.attempt == 0) DeliveryStatus.CONNECTING else DeliveryStatus.RECONNECTING)
|
||||
val current = generation
|
||||
socket = client.newWebSocket(request, Listener(current))
|
||||
}
|
||||
|
||||
private fun scheduleReconnect() {
|
||||
generation++
|
||||
socket?.cancel()
|
||||
socket = null
|
||||
subscribeId = null
|
||||
if (!networkAvailable) return setStatus(DeliveryStatus.WAITING_FOR_NETWORK)
|
||||
setStatus(DeliveryStatus.RECONNECTING)
|
||||
// Rotate through the server's trusted aliases on each failure.
|
||||
endpointIndex++
|
||||
handler.postDelayed(reconnect, backoff.next())
|
||||
}
|
||||
|
||||
private fun onOpen(webSocket: WebSocket) {
|
||||
backoff.reset()
|
||||
val id = "notify-${++sequence}"
|
||||
subscribeId = id
|
||||
webSocket.send(NotificationProtocol.subscribe(id, ledger.cursor))
|
||||
setStatus(DeliveryStatus.CONNECTED)
|
||||
flushClears()
|
||||
}
|
||||
|
||||
private fun onText(text: String) {
|
||||
when (val frame = NotificationProtocol.parse(text, subscribeId)) {
|
||||
is NotificationFrame.Subscribed -> {
|
||||
presenter.cancel(frame.clearedIds)
|
||||
ledger.accept(frame.notifications)
|
||||
.filterNot { it.id in frame.clearedIds }
|
||||
.forEach(presenter::show)
|
||||
}
|
||||
is NotificationFrame.Pushed -> ledger.accept(listOf(frame.notification)).forEach(presenter::show)
|
||||
is NotificationFrame.Cleared -> presenter.cancel(frame.ids)
|
||||
is NotificationFrame.Refused -> {
|
||||
Log.w(TAG, "subscribe_notifications refused: ${frame.error}")
|
||||
scheduleReconnect()
|
||||
}
|
||||
NotificationFrame.Ignored -> Unit
|
||||
}
|
||||
}
|
||||
|
||||
private fun flushClears() {
|
||||
val open = socket ?: return
|
||||
if (settings.status != DeliveryStatus.CONNECTED) return
|
||||
val pending = ledger.pendingClears()
|
||||
if (pending.isEmpty()) return
|
||||
if (open.send(NotificationProtocol.clear("clear-${++sequence}", pending))) {
|
||||
ledger.clearsSent(pending)
|
||||
}
|
||||
}
|
||||
|
||||
private fun setStatus(status: DeliveryStatus, notify: Boolean = true) {
|
||||
if (settings.status == status) return
|
||||
settings.status = status
|
||||
if (notify) presenter.updateConnection(status)
|
||||
statusListener?.invoke(status)
|
||||
}
|
||||
|
||||
private fun watchNetwork() {
|
||||
val connectivity = getSystemService(ConnectivityManager::class.java)
|
||||
currentNetwork = connectivity.activeNetwork
|
||||
networkAvailable = currentNetwork != null
|
||||
val callback = object : ConnectivityManager.NetworkCallback() {
|
||||
override fun onAvailable(network: Network) {
|
||||
handler.post {
|
||||
val previous = currentNetwork
|
||||
currentNetwork = network
|
||||
networkAvailable = true
|
||||
// A new default network invalidates the old socket's route;
|
||||
// a returning network retries at once instead of waiting
|
||||
// out the backoff.
|
||||
val moved = previous != null && previous != network
|
||||
val idle = settings.status == DeliveryStatus.WAITING_FOR_NETWORK ||
|
||||
settings.status == DeliveryStatus.RECONNECTING
|
||||
if (settings.configured && (moved || previous == null || idle)) {
|
||||
backoff.reset()
|
||||
connect()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun onLost(network: Network) {
|
||||
handler.post {
|
||||
if (network != currentNetwork) return@post
|
||||
currentNetwork = null
|
||||
networkAvailable = false
|
||||
scheduleReconnect()
|
||||
}
|
||||
}
|
||||
}
|
||||
connectivity.registerDefaultNetworkCallback(callback)
|
||||
networkCallback = callback
|
||||
}
|
||||
|
||||
private inner class Listener(private val owner: Int) : WebSocketListener() {
|
||||
private fun current(block: () -> Unit) {
|
||||
handler.post { if (owner == generation) block() }
|
||||
}
|
||||
|
||||
override fun onOpen(webSocket: WebSocket, response: Response) = current { onOpen(webSocket) }
|
||||
override fun onMessage(webSocket: WebSocket, text: String) = current { onText(text) }
|
||||
override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
|
||||
webSocket.close(1000, null)
|
||||
}
|
||||
|
||||
override fun onClosed(webSocket: WebSocket, code: Int, reason: String) = current { scheduleReconnect() }
|
||||
override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) = current {
|
||||
Log.i(TAG, "socket failed (${response?.code}): ${t.message}")
|
||||
scheduleReconnect()
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val TAG = "PipelinesNotify"
|
||||
const val ACTION_RESTART = "net.awan.pipelines.notify.RESTART"
|
||||
const val ACTION_FLUSH = "net.awan.pipelines.notify.FLUSH"
|
||||
|
||||
@Volatile
|
||||
var running: NotificationService? = null
|
||||
private set
|
||||
|
||||
/** Settings' live status; called on the service thread. */
|
||||
@Volatile
|
||||
var statusListener: ((DeliveryStatus) -> Unit)? = null
|
||||
|
||||
/** Starts (or nudges) the service when it is enabled and configured. */
|
||||
fun start(context: Context, action: String? = null): Boolean {
|
||||
val settings = ServiceSettings(context)
|
||||
if (!settings.enabled || !settings.configured) return false
|
||||
val intent = Intent(context, NotificationService::class.java).setAction(action)
|
||||
return try {
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) context.startForegroundService(intent)
|
||||
else context.startService(intent)
|
||||
true
|
||||
} catch (error: Exception) {
|
||||
// Android 12+ refuses a foreground start from some background
|
||||
// contexts; the next app launch or boot starts it instead.
|
||||
Log.w(TAG, "could not start the notification service", error)
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
fun stop(context: Context) {
|
||||
context.stopService(Intent(context, NotificationService::class.java))
|
||||
}
|
||||
}
|
||||
}
|
||||
+120
@@ -0,0 +1,120 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
import android.annotation.SuppressLint
|
||||
import android.app.Activity
|
||||
import android.content.Intent
|
||||
import android.net.Uri
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.os.PowerManager
|
||||
import android.provider.Settings
|
||||
import android.app.NotificationManager
|
||||
import io.flutter.plugin.common.BinaryMessenger
|
||||
import io.flutter.plugin.common.MethodCall
|
||||
import io.flutter.plugin.common.MethodChannel
|
||||
|
||||
/**
|
||||
* The Flutter side's handle on background delivery (`pipelines/notification_service`).
|
||||
*
|
||||
* Dart hands over the server it is connected to (`configure`), switches
|
||||
* delivery on or off (`setEnabled`), reads `status` and asks for the battery
|
||||
* exemption. Status changes are pushed back as `statusChanged`.
|
||||
*/
|
||||
class NotificationServiceChannel(private val activity: Activity, messenger: BinaryMessenger) :
|
||||
MethodChannel.MethodCallHandler {
|
||||
private val channel = MethodChannel(messenger, NAME)
|
||||
private val settings = ServiceSettings(activity)
|
||||
private val main = Handler(Looper.getMainLooper())
|
||||
|
||||
init {
|
||||
channel.setMethodCallHandler(this)
|
||||
NotificationService.statusListener = { main.post { channel.invokeMethod("statusChanged", status()) } }
|
||||
}
|
||||
|
||||
fun dispose() {
|
||||
channel.setMethodCallHandler(null)
|
||||
NotificationService.statusListener = null
|
||||
}
|
||||
|
||||
override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
|
||||
when (call.method) {
|
||||
"status" -> result.success(status())
|
||||
"start" -> {
|
||||
NotificationService.start(activity)
|
||||
result.success(status())
|
||||
}
|
||||
"configure" -> {
|
||||
val serverId = call.argument<String>("serverId") ?: ""
|
||||
val endpoints = call.argument<List<String>>("endpoints") ?: emptyList()
|
||||
val cookie = call.argument<String>("cookie") ?: ""
|
||||
if (endpoints.isEmpty()) {
|
||||
result.error("invalid", "configure needs at least one endpoint", null)
|
||||
return
|
||||
}
|
||||
val changed = settings.configure(serverId, endpoints, cookie)
|
||||
val running = NotificationService.running != null
|
||||
if (changed || !running) {
|
||||
NotificationService.start(activity, if (changed) NotificationService.ACTION_RESTART else null)
|
||||
}
|
||||
result.success(status())
|
||||
}
|
||||
"setEnabled" -> {
|
||||
val enabled = call.argument<Boolean>("enabled") ?: true
|
||||
settings.enabled = enabled
|
||||
if (enabled) {
|
||||
NotificationService.start(activity, NotificationService.ACTION_RESTART)
|
||||
} else {
|
||||
NotificationService.stop(activity)
|
||||
settings.status = DeliveryStatus.OFF
|
||||
}
|
||||
result.success(status())
|
||||
}
|
||||
"requestBatteryExemption" -> {
|
||||
result.success(requestBatteryExemption())
|
||||
}
|
||||
else -> result.notImplemented()
|
||||
}
|
||||
}
|
||||
|
||||
private fun status(): Map<String, Any> {
|
||||
val running = NotificationService.running != null
|
||||
val status = when {
|
||||
!settings.configured -> DeliveryStatus.UNCONFIGURED
|
||||
!settings.enabled || !running -> DeliveryStatus.OFF
|
||||
else -> settings.status
|
||||
}
|
||||
return mapOf(
|
||||
"enabled" to settings.enabled,
|
||||
"configured" to settings.configured,
|
||||
"status" to status.wire,
|
||||
"notificationsAllowed" to activity.getSystemService(NotificationManager::class.java).areNotificationsEnabled(),
|
||||
"batteryExempt" to batteryExempt(),
|
||||
)
|
||||
}
|
||||
|
||||
private fun batteryExempt(): Boolean =
|
||||
activity.getSystemService(PowerManager::class.java).isIgnoringBatteryOptimizations(activity.packageName)
|
||||
|
||||
/** Opens the system's exemption prompt; true when it could be shown. */
|
||||
@SuppressLint("BatteryLife")
|
||||
private fun requestBatteryExemption(): Boolean {
|
||||
if (batteryExempt()) return true
|
||||
val direct = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS)
|
||||
.setData(Uri.parse("package:${activity.packageName}"))
|
||||
return try {
|
||||
activity.startActivity(direct)
|
||||
true
|
||||
} catch (_: Exception) {
|
||||
try {
|
||||
activity.startActivity(Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS))
|
||||
true
|
||||
} catch (_: Exception) {
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
const val NAME = "pipelines/notification_service"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
import android.content.Context
|
||||
import android.content.SharedPreferences
|
||||
|
||||
/** Connection states the service reports to Settings. */
|
||||
enum class DeliveryStatus(val wire: String) {
|
||||
OFF("off"),
|
||||
UNCONFIGURED("unconfigured"),
|
||||
CONNECTING("connecting"),
|
||||
CONNECTED("connected"),
|
||||
RECONNECTING("reconnecting"),
|
||||
WAITING_FOR_NETWORK("waiting_for_network"),
|
||||
}
|
||||
|
||||
/**
|
||||
* The service's own preferences. The Flutter app hands over the server it is
|
||||
* connected to (its trusted endpoints and the web sign-in cookie) through the
|
||||
* method channel; the service never reads Flutter's storage.
|
||||
*/
|
||||
class ServiceSettings(context: Context) : LedgerStore {
|
||||
private val prefs: SharedPreferences =
|
||||
context.applicationContext.getSharedPreferences(FILE, Context.MODE_PRIVATE)
|
||||
|
||||
/** On by default: the app delivers its own notifications unless switched off. */
|
||||
var enabled: Boolean
|
||||
get() = prefs.getBoolean(ENABLED, true)
|
||||
set(value) = prefs.edit().putBoolean(ENABLED, value).apply()
|
||||
|
||||
val serverId: String get() = prefs.getString(SERVER_ID, "") ?: ""
|
||||
val endpoints: List<String>
|
||||
get() = (prefs.getString(ENDPOINTS, "") ?: "").split('\n').filter { it.isNotEmpty() }
|
||||
val cookie: String get() = prefs.getString(COOKIE, "") ?: ""
|
||||
val configured: Boolean get() = endpoints.isNotEmpty()
|
||||
|
||||
/** Returns true when the server, addresses or credentials changed. */
|
||||
fun configure(serverId: String, endpoints: List<String>, cookie: String): Boolean {
|
||||
val joined = endpoints.filter { it.isNotEmpty() }.joinToString("\n")
|
||||
val changed = serverId != this.serverId ||
|
||||
joined != prefs.getString(ENDPOINTS, "") ||
|
||||
cookie != this.cookie
|
||||
if (changed) {
|
||||
prefs.edit()
|
||||
.putString(SERVER_ID, serverId)
|
||||
.putString(ENDPOINTS, joined)
|
||||
.putString(COOKIE, cookie)
|
||||
.commit()
|
||||
}
|
||||
return changed
|
||||
}
|
||||
|
||||
var status: DeliveryStatus
|
||||
get() = DeliveryStatus.entries.firstOrNull { it.wire == prefs.getString(STATUS, null) }
|
||||
?: DeliveryStatus.OFF
|
||||
set(value) = prefs.edit().putString(STATUS, value.wire).apply()
|
||||
|
||||
override fun getString(key: String): String? = prefs.getString(key, null)
|
||||
|
||||
override fun putString(key: String, value: String?) {
|
||||
// Ledger writes are committed so a process kill cannot replay an alert.
|
||||
if (value == null) prefs.edit().remove(key).commit()
|
||||
else prefs.edit().putString(key, value).commit()
|
||||
}
|
||||
|
||||
companion object {
|
||||
const val FILE = "pipelines.notification_service"
|
||||
private const val ENABLED = "enabled"
|
||||
private const val SERVER_ID = "serverId"
|
||||
private const val ENDPOINTS = "endpoints"
|
||||
private const val COOKIE = "cookie"
|
||||
private const val STATUS = "status"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- Status-bar icon for background delivery: a small pipeline graph (two
|
||||
stages feeding a third). Monochrome, as Android requires. -->
|
||||
<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="M3,3h6v6H3z M3,15h6v6H3z M15,9h6v6h-6z M9,5.25h3.75v6h2.25v1.5h-2.25v6H9v-1.5h2.25V6.75H9z" />
|
||||
</vector>
|
||||
@@ -0,0 +1,93 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class DeliveryLedgerTest {
|
||||
private class MemoryStore : LedgerStore {
|
||||
val values = mutableMapOf<String, String>()
|
||||
override fun getString(key: String) = values[key]
|
||||
override fun putString(key: String, value: String?) {
|
||||
if (value == null) values.remove(key) else values[key] = value
|
||||
}
|
||||
}
|
||||
|
||||
private fun n(id: String) = ServerNotification(id, "k", "t", "m", "", 3, emptyList(), "", "")
|
||||
|
||||
@Test
|
||||
fun cursorFollowsTheLastReceivedId() {
|
||||
val ledger = DeliveryLedger(MemoryStore())
|
||||
ledger.bindServer("s")
|
||||
assertNull(ledger.cursor)
|
||||
ledger.accept(listOf(n("a"), n("b")))
|
||||
assertEquals("b", ledger.cursor)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun replayedIdsAreNotShownTwice() {
|
||||
val ledger = DeliveryLedger(MemoryStore())
|
||||
ledger.bindServer("s")
|
||||
assertEquals(listOf("a", "b"), ledger.accept(listOf(n("a"), n("b"))).map { it.id })
|
||||
assertEquals(listOf("c"), ledger.accept(listOf(n("b"), n("c"), n("c"))).map { it.id })
|
||||
assertEquals("c", ledger.cursor)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun stateSurvivesANewLedgerOnTheSameStore() {
|
||||
val store = MemoryStore()
|
||||
DeliveryLedger(store).apply { bindServer("s"); accept(listOf(n("a"))) }
|
||||
val reopened = DeliveryLedger(store)
|
||||
assertFalse(reopened.bindServer("s"))
|
||||
assertEquals("a", reopened.cursor)
|
||||
assertTrue(reopened.accept(listOf(n("a"))).isEmpty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anotherServerResetsCursorHistoryAndClears() {
|
||||
val ledger = DeliveryLedger(MemoryStore())
|
||||
ledger.bindServer("one")
|
||||
ledger.accept(listOf(n("a")))
|
||||
ledger.queueClear(listOf("a"))
|
||||
assertTrue(ledger.bindServer("two"))
|
||||
assertNull(ledger.cursor)
|
||||
assertTrue(ledger.pendingClears().isEmpty())
|
||||
assertEquals(1, ledger.accept(listOf(n("a"))).size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun shownHistoryIsBounded() {
|
||||
val ledger = DeliveryLedger(MemoryStore(), maxShown = 3)
|
||||
ledger.bindServer("s")
|
||||
ledger.accept((1..5).map { n("$it") })
|
||||
assertEquals(listOf("3", "4", "5"), ledger.shownIds())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun pendingClearsAreDedupedAndRemovedOnceSent() {
|
||||
val ledger = DeliveryLedger(MemoryStore())
|
||||
ledger.queueClear(listOf("a", "b"))
|
||||
ledger.queueClear(listOf("b", "c"))
|
||||
assertEquals(listOf("a", "b", "c"), ledger.pendingClears())
|
||||
ledger.clearsSent(listOf("a", "b"))
|
||||
assertEquals(listOf("c"), ledger.pendingClears())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun notificationIdsAreStableAndAvoidReservedIds() {
|
||||
val first = DeliveryLedger.notificationId("n-7")
|
||||
assertEquals(first, DeliveryLedger.notificationId("n-7"))
|
||||
assertTrue(first > DeliveryLedger.RESERVED_IDS)
|
||||
assertTrue(DeliveryLedger.notificationId("n-8") != first)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun backoffDoublesUpToTheCapAndResets() {
|
||||
val backoff = Backoff(baseMillis = 1000, maxMillis = 5000)
|
||||
assertEquals(listOf(1000L, 2000L, 4000L, 5000L, 5000L), (1..5).map { backoff.next() })
|
||||
backoff.reset()
|
||||
assertEquals(1000L, backoff.next())
|
||||
}
|
||||
}
|
||||
+130
@@ -0,0 +1,130 @@
|
||||
package net.awan.pipelines_app.notify
|
||||
|
||||
import org.json.JSONObject
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class NotificationProtocolTest {
|
||||
private val pushed = """
|
||||
{"type":"notification","id":"n-7","kind":"run_failed","title":"Run 12 failed",
|
||||
"message":"Step build failed","click":"pipelines://run/12","priority":4,
|
||||
"tags":["x","warning"],"created_at":"2026-11-01T10:00:00Z","group":"run-12"}
|
||||
""".trimIndent()
|
||||
|
||||
@Test
|
||||
fun subscribeOmitsAfterWithoutCursor() {
|
||||
val frame = JSONObject(NotificationProtocol.subscribe("r1", null))
|
||||
assertEquals("subscribe_notifications", frame.getString("type"))
|
||||
assertEquals("r1", frame.getString("id"))
|
||||
assertFalse(frame.has("after"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun subscribeSendsCursor() {
|
||||
val frame = JSONObject(NotificationProtocol.subscribe("r1", "n-9"))
|
||||
assertEquals("n-9", frame.getString("after"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun clearListsIds() {
|
||||
val frame = JSONObject(NotificationProtocol.clear("c1", listOf("a", "b")))
|
||||
assertEquals("clear_notifications", frame.getString("type"))
|
||||
assertEquals(2, frame.getJSONArray("ids").length())
|
||||
assertEquals("b", frame.getJSONArray("ids").getString(1))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun parsesPushedNotification() {
|
||||
val frame = NotificationProtocol.parse(pushed, "r1") as NotificationFrame.Pushed
|
||||
val n = frame.notification
|
||||
assertEquals("n-7", n.id)
|
||||
assertEquals("run_failed", n.kind)
|
||||
assertEquals("Run 12 failed", n.title)
|
||||
assertEquals("pipelines://run/12", n.click)
|
||||
assertEquals(4, n.priority)
|
||||
assertEquals(listOf("x", "warning"), n.tags)
|
||||
assertEquals("run-12", n.group)
|
||||
assertEquals("2026-11-01T10:00:00Z", n.createdAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun parsesNestedNotificationObject() {
|
||||
val text = """{"type":"notification","notification":{"id":"n-1","title":"t"}}"""
|
||||
val frame = NotificationProtocol.parse(text, null) as NotificationFrame.Pushed
|
||||
assertEquals("n-1", frame.notification.id)
|
||||
assertEquals("general", frame.notification.kind)
|
||||
assertEquals(3, frame.notification.priority)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun nullsAndOutOfRangePriorityFallBack() {
|
||||
val text = """{"type":"notification","id":"n-1","click":null,"group":null,"priority":9}"""
|
||||
val n = (NotificationProtocol.parse(text, null) as NotificationFrame.Pushed).notification
|
||||
assertEquals("", n.click)
|
||||
assertEquals("", n.group)
|
||||
assertEquals(3, n.priority)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun parsesSubscribedReplayAndSkipsItemsWithoutId() {
|
||||
val text = """{"type":"notifications_subscribed","id":"r1","notifications":[
|
||||
{"id":"a","title":"A"},{"title":"no id"},{"id":"b","title":"B"}]}"""
|
||||
val frame = NotificationProtocol.parse(text, "r1") as NotificationFrame.Subscribed
|
||||
assertEquals(listOf("a", "b"), frame.notifications.map { it.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun parsesServerShapesWithRecentlyClearedIdsAndExtraFields() {
|
||||
val text = """{"type":"notifications_subscribed","id":"1","build":"abc","protocol":3,
|
||||
"notifications":[{"id":"run:4:2:failed","kind":"run_failed","title":"t","message":"m",
|
||||
"click":"pipelines://run/4","priority":3,"tags":[],"created_at":"2026-11-01T10:00:00.123456789Z",
|
||||
"group":"run:4"}],"ids":["chat:9:reply:1"]}"""
|
||||
val frame = NotificationProtocol.parse(text, "1") as NotificationFrame.Subscribed
|
||||
assertEquals("run:4", frame.notifications.single().group)
|
||||
assertEquals(listOf("chat:9:reply:1"), frame.clearedIds)
|
||||
val push = """{"type":"notification","build":"abc","notification":{"id":"chat:9:form:2",
|
||||
"kind":"chat_question","priority":3,"group":"chat:9","click":"pipelines://chat/9"}}"""
|
||||
val pushed = (NotificationProtocol.parse(push, "1") as NotificationFrame.Pushed).notification
|
||||
assertEquals("chat:9:form:2", pushed.id)
|
||||
assertEquals("pipelines://chat/9", pushed.click)
|
||||
val reply = """{"type":"notifications_cleared","id":"2","ids":["chat:9:form:2"]}"""
|
||||
assertEquals(listOf("chat:9:form:2"), (NotificationProtocol.parse(reply, "1") as NotificationFrame.Cleared).ids)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun kindDecidesImportanceWhenPriorityIsDefault() {
|
||||
assertEquals(4, NotificationPresenter.effectivePriority("run_waiting", 3))
|
||||
assertEquals(4, NotificationPresenter.effectivePriority("chat_approval", 3))
|
||||
assertEquals(3, NotificationPresenter.effectivePriority("chat_reply", 3))
|
||||
assertEquals(2, NotificationPresenter.effectivePriority("stage_succeeded", 3))
|
||||
assertEquals(5, NotificationPresenter.effectivePriority("stage_succeeded", 5))
|
||||
assertEquals("Run waiting for you", NotificationPresenter.kindLabel("run_waiting"))
|
||||
assertEquals("Custom Kind", NotificationPresenter.kindLabel("custom_kind"))
|
||||
assertEquals(1761991200123L, NotificationPresenter.createdMillis("2025-11-01T10:00:00.123456789Z"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun parsesCleared() {
|
||||
val frame = NotificationProtocol.parse(
|
||||
"""{"type":"notifications_cleared","ids":["a","","b"]}""",
|
||||
null,
|
||||
) as NotificationFrame.Cleared
|
||||
assertEquals(listOf("a", "b"), frame.ids)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun onlyTheSubscribeErrorIsARefusal() {
|
||||
val error = """{"type":"error","id":"r1","error":"unknown type"}"""
|
||||
assertTrue(NotificationProtocol.parse(error, "r1") is NotificationFrame.Refused)
|
||||
assertEquals(NotificationFrame.Ignored, NotificationProtocol.parse(error, "r2"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun ignoresMalformedAndUnrelatedFrames() {
|
||||
assertEquals(NotificationFrame.Ignored, NotificationProtocol.parse("not json", null))
|
||||
assertEquals(NotificationFrame.Ignored, NotificationProtocol.parse("""{"type":"run_event"}""", null))
|
||||
assertEquals(NotificationFrame.Ignored, NotificationProtocol.parse("""{"type":"notification"}""", null))
|
||||
}
|
||||
}
|
||||
@@ -13,6 +13,8 @@ import '../shell/destination.dart';
|
||||
import '../features/attention/notify/notification_controller.dart';
|
||||
import '../features/attention/notify/chat_question_notices.dart';
|
||||
import '../features/attention/notify/notification_store.dart';
|
||||
import '../features/notification_service/notification_service_bridge.dart';
|
||||
import '../features/notification_service/notification_service_handoff.dart';
|
||||
import '../features/attention/runtime/attention_ack_queue.dart';
|
||||
import '../features/attention/runtime/attention_ack_sync.dart';
|
||||
import '../features/attention/runtime/attention_controller.dart';
|
||||
@@ -147,6 +149,11 @@ class _PipelinesAppState extends State<PipelinesApp>
|
||||
/// The count the shell's Runs tab shows; only a changed count rebuilds it.
|
||||
final ValueNotifier<int> _attentionCount = ValueNotifier<int>(0);
|
||||
|
||||
/// Android background delivery (no service elsewhere).
|
||||
final NotificationServiceBridge _deliveryService =
|
||||
createNotificationServiceBridge();
|
||||
NotificationServiceHandoff? _deliveryHandoff;
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
@@ -157,6 +164,12 @@ class _PipelinesAppState extends State<PipelinesApp>
|
||||
knownServer: widget.knownServer,
|
||||
addresses: widget.serverAddresses,
|
||||
);
|
||||
// The service authenticates like the app: hand over each proven server.
|
||||
_deliveryHandoff = NotificationServiceHandoff(
|
||||
bridge: _deliveryService,
|
||||
client: _session.client,
|
||||
serverId: widget.serverId,
|
||||
);
|
||||
bindServerIdentity(_session.gateway, widget.serverId);
|
||||
_ownsProvider = widget.routeInformationProvider == null;
|
||||
_provider =
|
||||
@@ -228,6 +241,7 @@ class _PipelinesAppState extends State<PipelinesApp>
|
||||
@override
|
||||
void dispose() {
|
||||
WidgetsBinding.instance.removeObserver(this);
|
||||
_deliveryHandoff?.dispose();
|
||||
_session.removeListener(_attentionSessionChanged);
|
||||
unawaited(_attentionFrames?.cancel());
|
||||
_attention.removeListener(_attentionChanged);
|
||||
@@ -552,6 +566,7 @@ class _PipelinesAppState extends State<PipelinesApp>
|
||||
),
|
||||
onOpenTemplates: _delegate.openTemplates,
|
||||
notifications: _notifications,
|
||||
deliveryService: _deliveryService,
|
||||
),
|
||||
},
|
||||
);
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
import 'dart:io';
|
||||
|
||||
/// The real host OS, not the (test-overridable) target platform.
|
||||
bool get runsOnAndroid => Platform.isAndroid;
|
||||
@@ -0,0 +1,2 @@
|
||||
/// Browsers have no background service.
|
||||
bool get runsOnAndroid => false;
|
||||
@@ -0,0 +1,139 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:flutter/services.dart';
|
||||
|
||||
import 'host_platform_stub.dart' if (dart.library.io) 'host_platform_io.dart';
|
||||
import 'notification_service_status.dart';
|
||||
|
||||
export 'notification_service_status.dart';
|
||||
|
||||
/// The app's handle on Android background delivery: a native foreground
|
||||
/// service (android/…/notify/NotificationService.kt) that keeps its own
|
||||
/// socket to the server and shows the server's notifications, so the ntfy app
|
||||
/// is not needed. Other platforms have no service ([supported] is false).
|
||||
abstract interface class NotificationServiceBridge {
|
||||
bool get supported;
|
||||
|
||||
/// Status pushed by the service whenever its connection changes.
|
||||
Stream<NotificationServiceStatus> get changes;
|
||||
|
||||
Future<NotificationServiceStatus> status();
|
||||
|
||||
/// Starts the service if delivery is enabled and a server was handed over.
|
||||
Future<NotificationServiceStatus> start();
|
||||
|
||||
/// Hands over the server the app is connected to: its trusted addresses
|
||||
/// (tried in order) and the web sign-in cookie, empty when none.
|
||||
Future<NotificationServiceStatus> configure({
|
||||
required String serverId,
|
||||
required List<String> endpoints,
|
||||
required String cookie,
|
||||
});
|
||||
|
||||
Future<NotificationServiceStatus> setEnabled(bool enabled);
|
||||
|
||||
/// Opens Android's "ignore battery optimisations" prompt.
|
||||
Future<bool> requestBatteryExemption();
|
||||
}
|
||||
|
||||
/// The bridge for this platform. One instance owns the channel's handler.
|
||||
NotificationServiceBridge createNotificationServiceBridge() => runsOnAndroid
|
||||
? MethodChannelNotificationServiceBridge.instance
|
||||
: const UnsupportedNotificationServiceBridge();
|
||||
|
||||
/// `pipelines/notification_service`, implemented by NotificationServiceChannel.kt.
|
||||
class MethodChannelNotificationServiceBridge
|
||||
implements NotificationServiceBridge {
|
||||
@visibleForTesting
|
||||
MethodChannelNotificationServiceBridge([
|
||||
this._channel = const MethodChannel(channelName),
|
||||
]) {
|
||||
_channel.setMethodCallHandler(_onCall);
|
||||
}
|
||||
|
||||
static const channelName = 'pipelines/notification_service';
|
||||
static final instance = MethodChannelNotificationServiceBridge();
|
||||
|
||||
final MethodChannel _channel;
|
||||
final _changes = StreamController<NotificationServiceStatus>.broadcast();
|
||||
|
||||
@override
|
||||
bool get supported => true;
|
||||
|
||||
@override
|
||||
Stream<NotificationServiceStatus> get changes => _changes.stream;
|
||||
|
||||
Future<void> _onCall(MethodCall call) async {
|
||||
if (call.method == 'statusChanged') {
|
||||
_changes.add(NotificationServiceStatus.fromMap(call.arguments));
|
||||
}
|
||||
}
|
||||
|
||||
Future<NotificationServiceStatus> _invoke(
|
||||
String method, [
|
||||
Map<String, Object?>? arguments,
|
||||
]) async {
|
||||
final reply = await _channel.invokeMethod<Object?>(method, arguments);
|
||||
final status = NotificationServiceStatus.fromMap(reply);
|
||||
_changes.add(status);
|
||||
return status;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> status() => _invoke('status');
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> start() => _invoke('start');
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> configure({
|
||||
required String serverId,
|
||||
required List<String> endpoints,
|
||||
required String cookie,
|
||||
}) => _invoke('configure', {
|
||||
'serverId': serverId,
|
||||
'endpoints': endpoints,
|
||||
'cookie': cookie,
|
||||
});
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> setEnabled(bool enabled) =>
|
||||
_invoke('setEnabled', {'enabled': enabled});
|
||||
|
||||
@override
|
||||
Future<bool> requestBatteryExemption() async =>
|
||||
await _channel.invokeMethod<bool>('requestBatteryExemption') ?? false;
|
||||
}
|
||||
|
||||
/// Web, iOS and desktop: no background service; nothing is pretended.
|
||||
class UnsupportedNotificationServiceBridge
|
||||
implements NotificationServiceBridge {
|
||||
const UnsupportedNotificationServiceBridge();
|
||||
|
||||
@override
|
||||
bool get supported => false;
|
||||
|
||||
@override
|
||||
Stream<NotificationServiceStatus> get changes => const Stream.empty();
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> status() async =>
|
||||
NotificationServiceStatus.unsupported;
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> start() => status();
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> configure({
|
||||
required String serverId,
|
||||
required List<String> endpoints,
|
||||
required String cookie,
|
||||
}) => status();
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> setEnabled(bool enabled) => status();
|
||||
|
||||
@override
|
||||
Future<bool> requestBatteryExemption() async => false;
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
|
||||
import 'notification_service_bridge.dart';
|
||||
|
||||
/// Settings' view of background delivery: the switch, the live status and the
|
||||
/// battery exemption, all read from the native service (never guessed).
|
||||
class NotificationServiceController extends ChangeNotifier {
|
||||
NotificationServiceController(
|
||||
this.bridge, {
|
||||
this.requestNotificationPermission,
|
||||
}) {
|
||||
_changes = bridge.changes.listen(_apply);
|
||||
}
|
||||
|
||||
final NotificationServiceBridge bridge;
|
||||
|
||||
/// Asks Android 13+ for POST_NOTIFICATIONS (the app's existing request).
|
||||
final Future<void> Function()? requestNotificationPermission;
|
||||
|
||||
late final StreamSubscription<NotificationServiceStatus> _changes;
|
||||
NotificationServiceStatus? _status;
|
||||
bool _busy = false;
|
||||
String _error = '';
|
||||
bool _disposed = false;
|
||||
|
||||
NotificationServiceStatus? get status => _status;
|
||||
bool get busy => _busy;
|
||||
String get error => _error;
|
||||
|
||||
Future<void> load() => _run(bridge.status);
|
||||
|
||||
/// Re-reads after returning from a system screen (permission, battery).
|
||||
Future<void> refresh() => load();
|
||||
|
||||
Future<void> setEnabled(bool enabled) => _run(() async {
|
||||
if (enabled && _status?.notificationsAllowed == false) {
|
||||
await requestNotificationPermission?.call();
|
||||
}
|
||||
return bridge.setEnabled(enabled);
|
||||
});
|
||||
|
||||
Future<void> allowNotifications() => _run(() async {
|
||||
await requestNotificationPermission?.call();
|
||||
return bridge.status();
|
||||
});
|
||||
|
||||
Future<void> allowBackgroundDelivery() => _run(() async {
|
||||
await bridge.requestBatteryExemption();
|
||||
return bridge.status();
|
||||
});
|
||||
|
||||
Future<void> _run(Future<NotificationServiceStatus> Function() action) async {
|
||||
if (_busy) return;
|
||||
_busy = true;
|
||||
_error = '';
|
||||
_notify();
|
||||
try {
|
||||
_status = await action();
|
||||
} catch (error) {
|
||||
_error = 'Background delivery is unavailable: $error';
|
||||
} finally {
|
||||
_busy = false;
|
||||
_notify();
|
||||
}
|
||||
}
|
||||
|
||||
void _apply(NotificationServiceStatus status) {
|
||||
_status = status;
|
||||
_notify();
|
||||
}
|
||||
|
||||
void _notify() {
|
||||
if (!_disposed) notifyListeners();
|
||||
}
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
_disposed = true;
|
||||
unawaited(_changes.cancel());
|
||||
super.dispose();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
|
||||
import '../../core/session/server_session.dart';
|
||||
import '../../core/transport/pipelines_client.dart';
|
||||
import 'notification_service_bridge.dart';
|
||||
|
||||
/// Shares the app's proven connection with the background service.
|
||||
///
|
||||
/// Whenever the shared client connects, the server it reached (its trusted
|
||||
/// addresses and the web sign-in cookie the socket used) is handed to the
|
||||
/// service, so the service authenticates exactly like the app. On creation it
|
||||
/// starts the service if delivery is enabled and a server was handed over
|
||||
/// before, which covers app launches after the service was stopped.
|
||||
class NotificationServiceHandoff {
|
||||
NotificationServiceHandoff({
|
||||
required this.bridge,
|
||||
required this.client,
|
||||
required this.serverId,
|
||||
@visibleForTesting Map<String, String> Function(Uri endpoint)? headersFor,
|
||||
}) : _headersFor = headersFor ?? ServerSession.headersFor {
|
||||
if (!bridge.supported) return;
|
||||
unawaited(_guard(bridge.start()));
|
||||
_states = client.states.listen(_onState);
|
||||
if (client.state.kind == ConnectionKind.connected) _handOver();
|
||||
}
|
||||
|
||||
final NotificationServiceBridge bridge;
|
||||
final PipelinesClient client;
|
||||
|
||||
/// The logical server; falls back to the connected address when absent.
|
||||
final String? serverId;
|
||||
final Map<String, String> Function(Uri endpoint) _headersFor;
|
||||
StreamSubscription<ConnectionState>? _states;
|
||||
|
||||
void _onState(ConnectionState state) {
|
||||
if (state.kind == ConnectionKind.connected) _handOver();
|
||||
}
|
||||
|
||||
void _handOver() {
|
||||
final endpoint = client.endpoint;
|
||||
if (endpoint == null) return;
|
||||
final addresses = client.endpoints.isEmpty ? [endpoint] : client.endpoints;
|
||||
// Connected address first: it is the one known to work right now.
|
||||
final ordered = <String>{
|
||||
endpoint.toString(),
|
||||
for (final address in addresses) address.toString(),
|
||||
}.toList();
|
||||
final id = serverId;
|
||||
unawaited(
|
||||
_guard(
|
||||
bridge.configure(
|
||||
serverId: id == null || id.isEmpty ? ordered.first : id,
|
||||
endpoints: ordered,
|
||||
cookie: _headersFor(endpoint)['Cookie'] ?? '',
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/// A missing or failing platform side must never break the app.
|
||||
Future<void> _guard(Future<Object?> call) async {
|
||||
try {
|
||||
await call;
|
||||
} catch (error) {
|
||||
debugPrint('Notification service: $error');
|
||||
}
|
||||
}
|
||||
|
||||
void dispose() {
|
||||
unawaited(_states?.cancel());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
/// The background connection's state, in the service's wire words.
|
||||
enum DeliveryState {
|
||||
off('off'),
|
||||
unconfigured('unconfigured'),
|
||||
connecting('connecting'),
|
||||
connected('connected'),
|
||||
reconnecting('reconnecting'),
|
||||
waitingForNetwork('waiting_for_network');
|
||||
|
||||
const DeliveryState(this.wire);
|
||||
|
||||
final String wire;
|
||||
|
||||
static DeliveryState parse(Object? value) => DeliveryState.values.firstWhere(
|
||||
(state) => state.wire == value,
|
||||
orElse: () => DeliveryState.off,
|
||||
);
|
||||
}
|
||||
|
||||
/// What the native service reports: the switch, whether a server was handed
|
||||
/// over, the connection, and the two Android permissions delivery relies on.
|
||||
class NotificationServiceStatus {
|
||||
const NotificationServiceStatus({
|
||||
required this.enabled,
|
||||
required this.configured,
|
||||
required this.state,
|
||||
required this.notificationsAllowed,
|
||||
required this.batteryExempt,
|
||||
});
|
||||
|
||||
static const unsupported = NotificationServiceStatus(
|
||||
enabled: false,
|
||||
configured: false,
|
||||
state: DeliveryState.off,
|
||||
notificationsAllowed: false,
|
||||
batteryExempt: false,
|
||||
);
|
||||
|
||||
final bool enabled;
|
||||
final bool configured;
|
||||
final DeliveryState state;
|
||||
final bool notificationsAllowed;
|
||||
final bool batteryExempt;
|
||||
|
||||
factory NotificationServiceStatus.fromMap(Object? raw) {
|
||||
final map = raw is Map ? raw : const {};
|
||||
return NotificationServiceStatus(
|
||||
enabled: map['enabled'] == true,
|
||||
configured: map['configured'] == true,
|
||||
state: DeliveryState.parse(map['status']),
|
||||
notificationsAllowed: map['notificationsAllowed'] == true,
|
||||
batteryExempt: map['batteryExempt'] == true,
|
||||
);
|
||||
}
|
||||
|
||||
/// One short line for Settings.
|
||||
String get label => switch (state) {
|
||||
DeliveryState.connected => 'Connected',
|
||||
DeliveryState.connecting => 'Connecting…',
|
||||
DeliveryState.reconnecting => 'Reconnecting…',
|
||||
DeliveryState.waitingForNetwork => 'Waiting for a network',
|
||||
DeliveryState.unconfigured => 'Starts after the app connects to a server',
|
||||
DeliveryState.off => enabled ? 'Not running' : 'Off',
|
||||
};
|
||||
}
|
||||
@@ -27,6 +27,14 @@ const ntfySettings = <NtfySetting>[
|
||||
NtfySetting('chat_reply_finished', 'Chat reply finished'),
|
||||
];
|
||||
|
||||
/// The server's switch for also publishing to ntfy. Optional: older servers
|
||||
/// do not send it, and Settings hides the switch then.
|
||||
const ntfyEnabledSetting = NtfySetting(
|
||||
'ntfy_enabled',
|
||||
'Also send to ntfy',
|
||||
subtitle: 'For devices that still use the ntfy app',
|
||||
);
|
||||
|
||||
/// Loads and changes the server's ntfy notification settings through the
|
||||
/// shared gateway (`notification_settings` / `set_notification_settings`).
|
||||
///
|
||||
@@ -112,6 +120,8 @@ class NtfySettingsController extends ChangeNotifier {
|
||||
}
|
||||
result[setting.key] = value;
|
||||
}
|
||||
final ntfy = raw[ntfyEnabledSetting.key];
|
||||
if (ntfy is bool) result[ntfyEnabledSetting.key] = ntfy;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,148 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/cupertino.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
|
||||
import '../notification_service/notification_service_bridge.dart';
|
||||
import '../notification_service/notification_service_controller.dart';
|
||||
import 'settings_group.dart';
|
||||
import 'settings_row.dart';
|
||||
import 'settings_theme.dart';
|
||||
|
||||
const deviceDeliveryTitle = 'Notifications in Pipelines';
|
||||
const deviceDeliverySwitchLabel = 'Receive notifications in Pipelines';
|
||||
const deviceDeliveryNote =
|
||||
'Pipelines keeps its own connection to the server and shows its '
|
||||
'notifications, so the ntfy app is no longer needed. Android shows a '
|
||||
'quiet "Pipelines is connected" notification while it runs.';
|
||||
const deviceDeliveryBatteryLabel = 'Allow background delivery';
|
||||
const deviceDeliveryNotificationsLabel = 'Allow notifications';
|
||||
|
||||
abstract final class DeviceDeliveryKeys {
|
||||
static const toggle = ValueKey<String>('settings.deviceDelivery.toggle');
|
||||
static const status = ValueKey<String>('settings.deviceDelivery.status');
|
||||
static const battery = ValueKey<String>('settings.deviceDelivery.battery');
|
||||
static const permission = ValueKey<String>(
|
||||
'settings.deviceDelivery.permission',
|
||||
);
|
||||
static const error = ValueKey<String>('settings.deviceDelivery.error');
|
||||
}
|
||||
|
||||
/// Android background delivery in Settings: the switch, the service's live
|
||||
/// status, and the two system grants it relies on (notification permission and
|
||||
/// the battery-optimisation exemption). Absent where there is no service.
|
||||
class SettingsDeviceDeliverySection extends StatefulWidget {
|
||||
const SettingsDeviceDeliverySection({
|
||||
super.key,
|
||||
required this.bridge,
|
||||
this.requestNotificationPermission,
|
||||
});
|
||||
|
||||
final NotificationServiceBridge bridge;
|
||||
final Future<void> Function()? requestNotificationPermission;
|
||||
|
||||
@override
|
||||
State<SettingsDeviceDeliverySection> createState() =>
|
||||
_SettingsDeviceDeliverySectionState();
|
||||
}
|
||||
|
||||
class _SettingsDeviceDeliverySectionState
|
||||
extends State<SettingsDeviceDeliverySection> {
|
||||
late final NotificationServiceController _controller =
|
||||
NotificationServiceController(
|
||||
widget.bridge,
|
||||
requestNotificationPermission: widget.requestNotificationPermission,
|
||||
);
|
||||
|
||||
// System prompts (permission, battery) return by resuming the app.
|
||||
late final AppLifecycleListener _lifecycle = AppLifecycleListener(
|
||||
onResume: () => unawaited(_controller.refresh()),
|
||||
);
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
_lifecycle;
|
||||
unawaited(_controller.load());
|
||||
}
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
_lifecycle.dispose();
|
||||
_controller.dispose();
|
||||
super.dispose();
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) => ListenableBuilder(
|
||||
listenable: _controller,
|
||||
builder: (context, _) => _body(context),
|
||||
);
|
||||
|
||||
Widget _body(BuildContext context) {
|
||||
final cupertino = usesCupertinoControls(context);
|
||||
final status = _controller.status;
|
||||
final enabled = status?.enabled ?? false;
|
||||
final onChanged = status == null || _controller.busy
|
||||
? null
|
||||
: (bool value) => unawaited(_controller.setEnabled(value));
|
||||
return SettingsGroup(
|
||||
title: deviceDeliveryTitle,
|
||||
footer: Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.stretch,
|
||||
children: <Widget>[
|
||||
const Text(deviceDeliveryNote),
|
||||
if (_controller.error.isNotEmpty)
|
||||
Text(
|
||||
_controller.error,
|
||||
key: DeviceDeliveryKeys.error,
|
||||
style: TextStyle(color: settingsErrorColor(context)),
|
||||
),
|
||||
],
|
||||
),
|
||||
children: <Widget>[
|
||||
if (cupertino)
|
||||
CupertinoListTile(
|
||||
key: DeviceDeliveryKeys.toggle,
|
||||
title: const Text(deviceDeliverySwitchLabel),
|
||||
trailing: CupertinoSwitch(value: enabled, onChanged: onChanged),
|
||||
onTap: onChanged == null ? null : () => onChanged(!enabled),
|
||||
)
|
||||
else
|
||||
SwitchListTile(
|
||||
key: DeviceDeliveryKeys.toggle,
|
||||
title: const Text(deviceDeliverySwitchLabel),
|
||||
value: enabled,
|
||||
onChanged: onChanged,
|
||||
),
|
||||
SettingsRow(
|
||||
key: DeviceDeliveryKeys.status,
|
||||
title: const Text('Status'),
|
||||
subtitle: Text(status == null ? 'Loading…' : status.label),
|
||||
),
|
||||
if (status != null && enabled && !status.notificationsAllowed)
|
||||
SettingsRow(
|
||||
key: DeviceDeliveryKeys.permission,
|
||||
title: const Text(deviceDeliveryNotificationsLabel),
|
||||
subtitle: const Text('Android is blocking Pipelines notifications'),
|
||||
action: true,
|
||||
enabled: !_controller.busy,
|
||||
onTap: () => unawaited(_controller.allowNotifications()),
|
||||
),
|
||||
if (status != null && enabled)
|
||||
SettingsRow(
|
||||
key: DeviceDeliveryKeys.battery,
|
||||
title: const Text(deviceDeliveryBatteryLabel),
|
||||
subtitle: Text(
|
||||
status.batteryExempt
|
||||
? 'Allowed: battery optimisation will not pause delivery'
|
||||
: 'Keeps notifications instant while the phone is idle',
|
||||
),
|
||||
action: !status.batteryExempt,
|
||||
enabled: !status.batteryExempt && !_controller.busy,
|
||||
onTap: () => unawaited(_controller.allowBackgroundDelivery()),
|
||||
),
|
||||
],
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -15,6 +15,12 @@ const ntfySectionTitle = 'Phone notifications';
|
||||
const ntfySectionSubtitle =
|
||||
'Sent through ntfy to the devices subscribed to this server.';
|
||||
|
||||
/// The subtitle once the server delivers to the app itself (it reports
|
||||
/// `ntfy_enabled`).
|
||||
const ntfySectionAppSubtitle =
|
||||
'What the server notifies about: shown by the Pipelines app and, when '
|
||||
'enabled, also sent through ntfy.';
|
||||
|
||||
/// Shown instead of loading while the shared connection is down.
|
||||
const ntfyOfflineText = 'Connect to a server to change these.';
|
||||
|
||||
@@ -84,8 +90,12 @@ class _SettingsNtfySectionState extends State<SettingsNtfySection> {
|
||||
: _controller.loading && values == null
|
||||
? 'Loading…'
|
||||
: '';
|
||||
final hasNtfySwitch = values?.containsKey(ntfyEnabledSetting.key) ?? false;
|
||||
final tiles = <Widget>[
|
||||
for (final setting in ntfySettings)
|
||||
for (final setting in [
|
||||
...ntfySettings,
|
||||
if (hasNtfySwitch) ntfyEnabledSetting,
|
||||
])
|
||||
_tile(
|
||||
cupertino,
|
||||
setting,
|
||||
@@ -99,7 +109,7 @@ class _SettingsNtfySectionState extends State<SettingsNtfySection> {
|
||||
footer: Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.stretch,
|
||||
children: <Widget>[
|
||||
const Text(ntfySectionSubtitle),
|
||||
Text(hasNtfySwitch ? ntfySectionAppSubtitle : ntfySectionSubtitle),
|
||||
if (status.isNotEmpty) Text(status),
|
||||
if (_controller.error.isNotEmpty)
|
||||
Semantics(
|
||||
|
||||
@@ -14,6 +14,8 @@ import 'settings_group.dart';
|
||||
import 'settings_page_body.dart';
|
||||
import 'settings_notifications_section.dart';
|
||||
import 'settings_ntfy_section.dart';
|
||||
import 'settings_device_delivery_section.dart';
|
||||
import '../notification_service/notification_service_bridge.dart';
|
||||
import 'settings_android_download_section.dart';
|
||||
import 'settings_schedules_section.dart';
|
||||
import 'settings_sections.dart';
|
||||
@@ -48,8 +50,12 @@ class SettingsScreen extends StatefulWidget {
|
||||
this.showSignIn = false,
|
||||
this.showAndroidDownload = false,
|
||||
this.servers,
|
||||
this.deliveryService,
|
||||
});
|
||||
|
||||
/// Android background delivery; hidden when absent or unsupported.
|
||||
final NotificationServiceBridge? deliveryService;
|
||||
|
||||
final transport.PipelinesClient client;
|
||||
|
||||
/// Whether to offer the web sign-in (the native app; a browser has its own).
|
||||
@@ -183,6 +189,15 @@ class _SettingsScreenState extends State<SettingsScreen> {
|
||||
),
|
||||
if (widget.notifications case final notifications?)
|
||||
SettingsNotificationsSection(controller: notifications),
|
||||
if (widget.deliveryService case final service? when service.supported)
|
||||
SettingsDeviceDeliverySection(
|
||||
bridge: service,
|
||||
requestNotificationPermission: widget.notifications == null
|
||||
? null
|
||||
: () async {
|
||||
await widget.notifications!.requestPermission();
|
||||
},
|
||||
),
|
||||
// The server's ntfy choices, beside the in-app permission.
|
||||
SettingsNtfySection(
|
||||
gateway: widget.client,
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
# Android background delivery (notifications without ntfy)
|
||||
|
||||
## Design
|
||||
- `android/app/src/main/kotlin/net/awan/pipelines_app/notify/`: native foreground
|
||||
service (`specialUse`, no Flutter engine), OkHttp websocket with the app's
|
||||
session cookie, exponential backoff (1 s .. 5 min) rotating through the
|
||||
server's trusted addresses, default-network callback (reconnect on network
|
||||
change, "waiting for network" when none), quiet "Pipelines is connected"
|
||||
notification. It starts at boot or after an app update (`BootReceiver`) and
|
||||
at app launch.
|
||||
- Protocol: `subscribe_notifications` with `after` = last received id;
|
||||
`notifications_subscribed` (`notifications`, plus recently cleared `ids` that
|
||||
are dismissed), `notification` (`{"notification": N}`), `notifications_cleared`.
|
||||
Taps (MainActivity) and dismissals (`NotificationDismissReceiver`) queue
|
||||
`clear_notifications` durably until the socket is connected.
|
||||
- `DeliveryLedger`: cursor, bounded shown-id dedupe, pending clears; reset when
|
||||
the server changes. Stable notification id = FNV-1a of the server id.
|
||||
- Channels per kind (and non-default priority), grouped by kind; importance from
|
||||
kind because the server sends priority 3. Android groups by `group`, with a summary.
|
||||
- Dart: `lib/features/notification_service/` (MethodChannel bridge
|
||||
`pipelines/notification_service`, handoff of the connected server and cookie
|
||||
on every connect, Settings controller); Settings section
|
||||
`settings_device_delivery_section.dart`; the server's optional `ntfy_enabled`
|
||||
appears as "Also send to ntfy".
|
||||
|
||||
## Checks
|
||||
- Kotlin JVM tests: `cd android && ./gradlew :app:testDebugUnitTest`
|
||||
(needs a JDK Gradle supports, e.g. Android Studio's JBR via `JAVA_HOME`).
|
||||
- On-device check against a loopback stand-in server:
|
||||
`python3 -I tool/fake_notification_server.py --port 18765 --log /tmp/notify.log`,
|
||||
connect the emulator app to `ws://10.0.2.2:18765/connect`, then
|
||||
`curl -X POST 'http://127.0.0.1:18765/push?id=run:1:0:failed&click=pipelines://run/1'`.
|
||||
@@ -0,0 +1,88 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:pipelines_app/features/notification_service/notification_service_bridge.dart';
|
||||
|
||||
/// A scripted background service: records calls and reports [current].
|
||||
class FakeNotificationService implements NotificationServiceBridge {
|
||||
FakeNotificationService({NotificationServiceStatus? status})
|
||||
: current =
|
||||
status ??
|
||||
const NotificationServiceStatus(
|
||||
enabled: true,
|
||||
configured: true,
|
||||
state: DeliveryState.connected,
|
||||
notificationsAllowed: true,
|
||||
batteryExempt: false,
|
||||
);
|
||||
|
||||
NotificationServiceStatus current;
|
||||
final calls = <(String, Map<String, Object?>)>[];
|
||||
final _changes = StreamController<NotificationServiceStatus>.broadcast();
|
||||
bool batteryGranted = true;
|
||||
|
||||
void push(NotificationServiceStatus status) {
|
||||
current = status;
|
||||
_changes.add(status);
|
||||
}
|
||||
|
||||
NotificationServiceStatus copy({
|
||||
bool? enabled,
|
||||
DeliveryState? state,
|
||||
bool? notificationsAllowed,
|
||||
bool? batteryExempt,
|
||||
}) => NotificationServiceStatus(
|
||||
enabled: enabled ?? current.enabled,
|
||||
configured: current.configured,
|
||||
state: state ?? current.state,
|
||||
notificationsAllowed: notificationsAllowed ?? current.notificationsAllowed,
|
||||
batteryExempt: batteryExempt ?? current.batteryExempt,
|
||||
);
|
||||
|
||||
@override
|
||||
bool get supported => true;
|
||||
|
||||
@override
|
||||
Stream<NotificationServiceStatus> get changes => _changes.stream;
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> status() async {
|
||||
calls.add(('status', const {}));
|
||||
return current;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> start() async {
|
||||
calls.add(('start', const {}));
|
||||
return current;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> configure({
|
||||
required String serverId,
|
||||
required List<String> endpoints,
|
||||
required String cookie,
|
||||
}) async {
|
||||
calls.add((
|
||||
'configure',
|
||||
{'serverId': serverId, 'endpoints': endpoints, 'cookie': cookie},
|
||||
));
|
||||
return current;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<NotificationServiceStatus> setEnabled(bool enabled) async {
|
||||
calls.add(('setEnabled', {'enabled': enabled}));
|
||||
current = copy(
|
||||
enabled: enabled,
|
||||
state: enabled ? DeliveryState.connecting : DeliveryState.off,
|
||||
);
|
||||
return current;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> requestBatteryExemption() async {
|
||||
calls.add(('requestBatteryExemption', const {}));
|
||||
if (batteryGranted) current = copy(batteryExempt: true);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
import 'package:flutter/services.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/features/notification_service/notification_service_bridge.dart';
|
||||
|
||||
void main() {
|
||||
TestWidgetsFlutterBinding.ensureInitialized();
|
||||
const channel = MethodChannel('test/notification_service');
|
||||
final messenger =
|
||||
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger;
|
||||
late List<MethodCall> calls;
|
||||
|
||||
Map<String, Object?> reply({String status = 'connected'}) => {
|
||||
'enabled': true,
|
||||
'configured': true,
|
||||
'status': status,
|
||||
'notificationsAllowed': true,
|
||||
'batteryExempt': false,
|
||||
};
|
||||
|
||||
setUp(() {
|
||||
calls = [];
|
||||
messenger.setMockMethodCallHandler(channel, (call) async {
|
||||
calls.add(call);
|
||||
return call.method == 'requestBatteryExemption' ? true : reply();
|
||||
});
|
||||
});
|
||||
|
||||
tearDown(() => messenger.setMockMethodCallHandler(channel, null));
|
||||
|
||||
test('the production channel name matches the Kotlin side', () {
|
||||
expect(
|
||||
MethodChannelNotificationServiceBridge.channelName,
|
||||
'pipelines/notification_service',
|
||||
);
|
||||
});
|
||||
|
||||
test('configure hands over the server, addresses and cookie', () async {
|
||||
final bridge = MethodChannelNotificationServiceBridge(channel);
|
||||
final status = await bridge.configure(
|
||||
serverId: 'home',
|
||||
endpoints: ['wss://a:8443/connect', 'ws://b:8081/connect'],
|
||||
cookie: 'pipelines_session=abc',
|
||||
);
|
||||
expect(calls.single.method, 'configure');
|
||||
expect(calls.single.arguments, {
|
||||
'serverId': 'home',
|
||||
'endpoints': ['wss://a:8443/connect', 'ws://b:8081/connect'],
|
||||
'cookie': 'pipelines_session=abc',
|
||||
});
|
||||
expect(status.state, DeliveryState.connected);
|
||||
expect(status.enabled, isTrue);
|
||||
expect(status.batteryExempt, isFalse);
|
||||
});
|
||||
|
||||
test('setEnabled, start, status and the battery prompt', () async {
|
||||
final bridge = MethodChannelNotificationServiceBridge(channel);
|
||||
await bridge.setEnabled(false);
|
||||
await bridge.start();
|
||||
await bridge.status();
|
||||
expect(await bridge.requestBatteryExemption(), isTrue);
|
||||
expect(calls.map((call) => call.method), [
|
||||
'setEnabled',
|
||||
'start',
|
||||
'status',
|
||||
'requestBatteryExemption',
|
||||
]);
|
||||
expect(calls.first.arguments, {'enabled': false});
|
||||
});
|
||||
|
||||
test('statusChanged from the service reaches listeners', () async {
|
||||
final bridge = MethodChannelNotificationServiceBridge(channel);
|
||||
final next = bridge.changes.first;
|
||||
await messenger.handlePlatformMessage(
|
||||
channel.name,
|
||||
channel.codec.encodeMethodCall(
|
||||
MethodCall('statusChanged', reply(status: 'waiting_for_network')),
|
||||
),
|
||||
(_) {},
|
||||
);
|
||||
expect((await next).state, DeliveryState.waitingForNetwork);
|
||||
});
|
||||
|
||||
test('unknown or malformed status falls back to off', () {
|
||||
expect(
|
||||
NotificationServiceStatus.fromMap({'status': 'weird'}).state,
|
||||
DeliveryState.off,
|
||||
);
|
||||
expect(NotificationServiceStatus.fromMap(null).enabled, isFalse);
|
||||
});
|
||||
|
||||
test('the host test platform has no service', () async {
|
||||
final bridge = createNotificationServiceBridge();
|
||||
expect(bridge.supported, isFalse);
|
||||
expect((await bridge.status()).state, DeliveryState.off);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/core/transport/pipelines_client.dart';
|
||||
import 'package:pipelines_app/features/notification_service/notification_service_bridge.dart';
|
||||
import 'package:pipelines_app/features/notification_service/notification_service_handoff.dart';
|
||||
|
||||
import '../settings/fake_channel.dart';
|
||||
import 'fake_notification_service.dart';
|
||||
|
||||
void main() {
|
||||
test('each connection hands the proven server to the service', () async {
|
||||
final channels = <FakeChannel>[];
|
||||
final client = PipelinesClient(
|
||||
channelFactory: (uri) {
|
||||
final channel = FakeChannel(uri)..markReady();
|
||||
channels.add(channel);
|
||||
return channel;
|
||||
},
|
||||
);
|
||||
final service = FakeNotificationService();
|
||||
final handoff = NotificationServiceHandoff(
|
||||
bridge: service,
|
||||
client: client,
|
||||
serverId: 'home',
|
||||
headersFor: (uri) => uri.host == 'b'
|
||||
? {'Cookie': 'pipelines_session=abc'}
|
||||
: const <String, String>{},
|
||||
);
|
||||
// The app starts the service at launch when it is enabled.
|
||||
expect(service.calls.single.$1, 'start');
|
||||
|
||||
await client.connectAny([
|
||||
Uri.parse('wss://b:8443/connect'),
|
||||
Uri.parse('ws://a:8081/connect'),
|
||||
]);
|
||||
await pumpEventQueue();
|
||||
final configure = service.calls.last;
|
||||
expect(configure.$1, 'configure');
|
||||
expect(configure.$2, {
|
||||
'serverId': 'home',
|
||||
'endpoints': ['wss://b:8443/connect', 'ws://a:8081/connect'],
|
||||
'cookie': 'pipelines_session=abc',
|
||||
});
|
||||
|
||||
handoff.dispose();
|
||||
await client.dispose();
|
||||
});
|
||||
|
||||
test('without a server id the connected address names the server', () async {
|
||||
final client = PipelinesClient(
|
||||
channelFactory: (uri) => FakeChannel(uri)..markReady(),
|
||||
);
|
||||
final service = FakeNotificationService();
|
||||
final handoff = NotificationServiceHandoff(
|
||||
bridge: service,
|
||||
client: client,
|
||||
serverId: null,
|
||||
headersFor: (_) => const <String, String>{},
|
||||
);
|
||||
await client.connect(Uri.parse('ws://a:8081/connect'));
|
||||
await pumpEventQueue();
|
||||
expect(service.calls.last.$2['serverId'], 'ws://a:8081/connect');
|
||||
expect(service.calls.last.$2['cookie'], '');
|
||||
handoff.dispose();
|
||||
await client.dispose();
|
||||
});
|
||||
|
||||
test('an unsupported platform is never called', () async {
|
||||
final client = PipelinesClient(
|
||||
channelFactory: (uri) => FakeChannel(uri)..markReady(),
|
||||
);
|
||||
final handoff = NotificationServiceHandoff(
|
||||
bridge: const UnsupportedNotificationServiceBridge(),
|
||||
client: client,
|
||||
serverId: 'home',
|
||||
headersFor: (_) => throw StateError('must not read credentials'),
|
||||
);
|
||||
await client.connect(Uri.parse('ws://a:8081/connect'));
|
||||
await pumpEventQueue();
|
||||
handoff.dispose();
|
||||
await client.dispose();
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
import 'package:flutter/cupertino.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/features/notification_service/notification_service_bridge.dart';
|
||||
import 'package:pipelines_app/features/settings/settings_device_delivery_section.dart';
|
||||
|
||||
import '../notification_service/fake_notification_service.dart';
|
||||
|
||||
Widget _host(
|
||||
NotificationServiceBridge bridge, {
|
||||
required bool cupertino,
|
||||
Future<void> Function()? requestPermission,
|
||||
}) => MaterialApp(
|
||||
theme: ThemeData(
|
||||
platform: cupertino ? TargetPlatform.iOS : TargetPlatform.android,
|
||||
),
|
||||
home: Scaffold(
|
||||
body: SingleChildScrollView(
|
||||
child: SettingsDeviceDeliverySection(
|
||||
bridge: bridge,
|
||||
requestNotificationPermission: requestPermission,
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
|
||||
bool _switchValue(WidgetTester tester, {required bool cupertino}) {
|
||||
final tile = find.byKey(DeviceDeliveryKeys.toggle);
|
||||
if (cupertino) {
|
||||
return tester
|
||||
.widget<CupertinoSwitch>(
|
||||
find.descendant(of: tile, matching: find.byType(CupertinoSwitch)),
|
||||
)
|
||||
.value;
|
||||
}
|
||||
return tester.widget<SwitchListTile>(tile).value;
|
||||
}
|
||||
|
||||
void main() {
|
||||
for (final cupertino in [false, true]) {
|
||||
final style = cupertino ? 'Cupertino' : 'Material';
|
||||
|
||||
testWidgets('$style shows the switch, status and ntfy note', (
|
||||
tester,
|
||||
) async {
|
||||
final service = FakeNotificationService();
|
||||
await tester.pumpWidget(_host(service, cupertino: cupertino));
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.text(deviceDeliverySwitchLabel), findsOneWidget);
|
||||
expect(_switchValue(tester, cupertino: cupertino), isTrue);
|
||||
expect(find.text('Connected'), findsOneWidget);
|
||||
expect(find.text(deviceDeliveryNote), findsOneWidget);
|
||||
expect(find.text(deviceDeliveryBatteryLabel), findsOneWidget);
|
||||
expect(find.byKey(DeviceDeliveryKeys.permission), findsNothing);
|
||||
});
|
||||
|
||||
testWidgets('$style switching off stops delivery', (tester) async {
|
||||
final service = FakeNotificationService();
|
||||
await tester.pumpWidget(_host(service, cupertino: cupertino));
|
||||
await tester.pumpAndSettle();
|
||||
await tester.tap(find.byKey(DeviceDeliveryKeys.toggle));
|
||||
await tester.pumpAndSettle();
|
||||
expect(service.calls.last.$1, 'setEnabled');
|
||||
expect(service.calls.last.$2, {'enabled': false});
|
||||
expect(_switchValue(tester, cupertino: cupertino), isFalse);
|
||||
expect(find.text('Off'), findsOneWidget);
|
||||
// The grants only matter while delivery is on.
|
||||
expect(find.text(deviceDeliveryBatteryLabel), findsNothing);
|
||||
});
|
||||
}
|
||||
|
||||
testWidgets('live status pushed by the service is shown', (tester) async {
|
||||
final service = FakeNotificationService();
|
||||
await tester.pumpWidget(_host(service, cupertino: false));
|
||||
await tester.pumpAndSettle();
|
||||
service.push(service.copy(state: DeliveryState.reconnecting));
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.text('Reconnecting…'), findsOneWidget);
|
||||
});
|
||||
|
||||
testWidgets('allow background delivery asks for the exemption', (
|
||||
tester,
|
||||
) async {
|
||||
final service = FakeNotificationService();
|
||||
await tester.pumpWidget(_host(service, cupertino: false));
|
||||
await tester.pumpAndSettle();
|
||||
await tester.tap(find.text(deviceDeliveryBatteryLabel));
|
||||
await tester.pumpAndSettle();
|
||||
expect(
|
||||
service.calls.map((call) => call.$1),
|
||||
contains('requestBatteryExemption'),
|
||||
);
|
||||
expect(
|
||||
find.text('Allowed: battery optimisation will not pause delivery'),
|
||||
findsOneWidget,
|
||||
);
|
||||
});
|
||||
|
||||
testWidgets('blocked notifications offer the permission request', (
|
||||
tester,
|
||||
) async {
|
||||
var asked = 0;
|
||||
final service = FakeNotificationService();
|
||||
service.current = service.copy(notificationsAllowed: false);
|
||||
await tester.pumpWidget(
|
||||
_host(
|
||||
service,
|
||||
cupertino: false,
|
||||
requestPermission: () async {
|
||||
asked++;
|
||||
service.current = service.copy(notificationsAllowed: true);
|
||||
},
|
||||
),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
await tester.tap(find.byKey(DeviceDeliveryKeys.permission));
|
||||
await tester.pumpAndSettle();
|
||||
expect(asked, 1);
|
||||
expect(find.byKey(DeviceDeliveryKeys.permission), findsNothing);
|
||||
});
|
||||
|
||||
testWidgets('switching on asks for notifications when blocked', (
|
||||
tester,
|
||||
) async {
|
||||
var asked = 0;
|
||||
final service = FakeNotificationService();
|
||||
service.current = service.copy(
|
||||
enabled: false,
|
||||
state: DeliveryState.off,
|
||||
notificationsAllowed: false,
|
||||
);
|
||||
await tester.pumpWidget(
|
||||
_host(service, cupertino: false, requestPermission: () async => asked++),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
await tester.tap(find.byKey(DeviceDeliveryKeys.toggle));
|
||||
await tester.pumpAndSettle();
|
||||
expect(asked, 1);
|
||||
expect(service.calls.last.$1, 'setEnabled');
|
||||
expect(service.calls.last.$2, {'enabled': true});
|
||||
});
|
||||
|
||||
testWidgets('a failing platform is reported, not hidden', (tester) async {
|
||||
await tester.pumpWidget(_host(_FailingService(), cupertino: false));
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.byKey(DeviceDeliveryKeys.error), findsOneWidget);
|
||||
});
|
||||
}
|
||||
|
||||
class _FailingService extends FakeNotificationService {
|
||||
@override
|
||||
Future<NotificationServiceStatus> status() async =>
|
||||
throw StateError('no service');
|
||||
}
|
||||
@@ -200,4 +200,50 @@ void main() {
|
||||
isFalse,
|
||||
);
|
||||
});
|
||||
|
||||
group('ntfy_enabled', () {
|
||||
JsonMap withNtfy(bool ntfy) => {
|
||||
'type': 'notification_settings',
|
||||
'notification_settings': {
|
||||
...(_reply(true, true, false)['notification_settings'] as Map),
|
||||
'ntfy_enabled': ntfy,
|
||||
},
|
||||
};
|
||||
|
||||
testWidgets('hidden when the server does not send it', (tester) async {
|
||||
final gateway = _Gateway((_, _) => _reply(true, true, false));
|
||||
await tester.pumpWidget(_host(gateway, cupertino: false));
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.byKey(ntfySettingKey('ntfy_enabled')), findsNothing);
|
||||
expect(find.text(ntfySectionSubtitle), findsOneWidget);
|
||||
});
|
||||
|
||||
for (final cupertino in [false, true]) {
|
||||
testWidgets(
|
||||
'${cupertino ? 'Cupertino' : 'Material'} shows and writes it',
|
||||
(tester) async {
|
||||
final gateway = _Gateway(
|
||||
(type, _) => withNtfy(type == 'set_notification_settings'),
|
||||
);
|
||||
await tester.pumpWidget(_host(gateway, cupertino: cupertino));
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.text('Also send to ntfy'), findsOneWidget);
|
||||
expect(find.text(ntfySectionAppSubtitle), findsOneWidget);
|
||||
expect(
|
||||
_checked(tester, 'ntfy_enabled', cupertino: cupertino),
|
||||
isFalse,
|
||||
);
|
||||
await tester.tap(find.byKey(ntfySettingKey('ntfy_enabled')));
|
||||
await tester.pumpAndSettle();
|
||||
expect(gateway.calls.last.$2, {
|
||||
'notification_settings': {'ntfy_enabled': true},
|
||||
});
|
||||
expect(
|
||||
_checked(tester, 'ntfy_enabled', cupertino: cupertino),
|
||||
isTrue,
|
||||
);
|
||||
},
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@@ -0,0 +1,213 @@
|
||||
#!/usr/bin/env python3
|
||||
"""A loopback stand-in for the Pipelines server's notification socket.
|
||||
|
||||
For checking Android background delivery on the managed emulator without the
|
||||
real server: the emulator reaches it at ws://10.0.2.2:<port>/connect.
|
||||
|
||||
python3 -I tool/fake_notification_server.py --port 0 --log /tmp/notify.log
|
||||
|
||||
* GET /login answers 302, so the app treats the device as signed in.
|
||||
* /connect speaks the notification protocol: `subscribe_notifications`
|
||||
(replayed with `notifications_subscribed`), `clear_notifications` (logged and
|
||||
echoed to every socket as `notifications_cleared`). Any other request gets an
|
||||
`error` reply so the app does not wait for its timeout.
|
||||
* POST /push?id=&kind=&title=&message=&click=&priority=&group= pushes
|
||||
`{"type":"notification","notification":{...}}`.
|
||||
* POST /clear?id=a,b pushes `notifications_cleared` (another device cleared).
|
||||
|
||||
Every frame received is appended to --log as one JSON line. Standard library
|
||||
only; not a general websocket server (text frames, no fragmentation).
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
import datetime
|
||||
import hashlib
|
||||
import json
|
||||
import socketserver
|
||||
import struct
|
||||
import threading
|
||||
import urllib.parse
|
||||
from http.server import BaseHTTPRequestHandler
|
||||
|
||||
GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
|
||||
clients = []
|
||||
store = [] # active notifications, oldest first
|
||||
cleared = [] # recently cleared ids, sent with notifications_subscribed
|
||||
lock = threading.Lock()
|
||||
log_path = None
|
||||
|
||||
|
||||
def log(entry):
|
||||
line = json.dumps(entry)
|
||||
print(line, flush=True)
|
||||
if log_path:
|
||||
with open(log_path, "a", encoding="utf-8") as handle:
|
||||
handle.write(line + "\n")
|
||||
|
||||
|
||||
def frame(text):
|
||||
data = text.encode()
|
||||
header = bytearray([0x81])
|
||||
if len(data) < 126:
|
||||
header.append(len(data))
|
||||
elif len(data) < 65536:
|
||||
header += bytes([126]) + struct.pack(">H", len(data))
|
||||
else:
|
||||
header += bytes([127]) + struct.pack(">Q", len(data))
|
||||
return bytes(header) + data
|
||||
|
||||
|
||||
def broadcast(message):
|
||||
payload = frame(json.dumps(message))
|
||||
with lock:
|
||||
for wfile in list(clients):
|
||||
try:
|
||||
wfile.write(payload)
|
||||
wfile.flush()
|
||||
except OSError:
|
||||
clients.remove(wfile)
|
||||
|
||||
|
||||
def read_frame(rfile):
|
||||
head = rfile.read(2)
|
||||
if len(head) < 2:
|
||||
return None, None
|
||||
opcode = head[0] & 0x0F
|
||||
length = head[1] & 0x7F
|
||||
if length == 126:
|
||||
length = struct.unpack(">H", rfile.read(2))[0]
|
||||
elif length == 127:
|
||||
length = struct.unpack(">Q", rfile.read(8))[0]
|
||||
mask = rfile.read(4) if head[1] & 0x80 else b"\0\0\0\0"
|
||||
data = bytes(b ^ mask[i % 4] for i, b in enumerate(rfile.read(length)))
|
||||
return opcode, data
|
||||
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
# Clients reject an "HTTP/1.0 101" upgrade.
|
||||
protocol_version = "HTTP/1.1"
|
||||
def log_message(self, *args):
|
||||
pass
|
||||
|
||||
def do_GET(self):
|
||||
path = urllib.parse.urlparse(self.path).path
|
||||
if path == "/login":
|
||||
self.send_response(302)
|
||||
self.send_header("Location", "/")
|
||||
self.send_header("Content-Length", "0")
|
||||
self.end_headers()
|
||||
elif path == "/connect" and self.headers.get("Upgrade", "").lower() == "websocket":
|
||||
self.websocket()
|
||||
else:
|
||||
self.send_response(404)
|
||||
self.send_header("Content-Length", "0")
|
||||
self.end_headers()
|
||||
|
||||
def do_POST(self):
|
||||
url = urllib.parse.urlparse(self.path)
|
||||
query = {k: v[-1] for k, v in urllib.parse.parse_qs(url.query).items()}
|
||||
if url.path == "/push":
|
||||
notification = {
|
||||
"id": query.get("id", "n-%d" % len(store)),
|
||||
"kind": query.get("kind", "run_failed"),
|
||||
"title": query.get("title", "Run failed"),
|
||||
"message": query.get("message", "A step failed"),
|
||||
"click": query.get("click", "pipelines://run/1"),
|
||||
"priority": int(query.get("priority", "3")),
|
||||
"tags": [],
|
||||
"created_at": datetime.datetime.now(datetime.timezone.utc).isoformat(),
|
||||
"group": query.get("group", ""),
|
||||
}
|
||||
store.append(notification)
|
||||
broadcast({"type": "notification", "notification": notification})
|
||||
elif url.path == "/clear":
|
||||
ids = [i for i in query.get("id", "").split(",") if i]
|
||||
store[:] = [n for n in store if n["id"] not in ids]
|
||||
cleared.extend(ids)
|
||||
broadcast({"type": "notifications_cleared", "ids": ids})
|
||||
else:
|
||||
self.send_response(404)
|
||||
self.send_header("Content-Length", "0")
|
||||
self.end_headers()
|
||||
return
|
||||
self.send_response(204)
|
||||
self.send_header("Content-Length", "0")
|
||||
self.end_headers()
|
||||
|
||||
def websocket(self):
|
||||
key = self.headers["Sec-WebSocket-Key"]
|
||||
accept = base64.b64encode(hashlib.sha1((key + GUID).encode()).digest()).decode()
|
||||
self.send_response(101)
|
||||
self.send_header("Upgrade", "websocket")
|
||||
self.send_header("Connection", "Upgrade")
|
||||
self.send_header("Sec-WebSocket-Accept", accept)
|
||||
self.end_headers()
|
||||
self.wfile.flush()
|
||||
log({"event": "connect", "cookie": self.headers.get("Cookie", ""),
|
||||
"agent": self.headers.get("User-Agent", "")})
|
||||
with lock:
|
||||
clients.append(self.wfile)
|
||||
try:
|
||||
while True:
|
||||
opcode, data = read_frame(self.rfile)
|
||||
if opcode is None or opcode == 0x8:
|
||||
break
|
||||
if opcode == 0x9: # ping -> pong
|
||||
with lock:
|
||||
self.wfile.write(bytes([0x8A, len(data)]) + data)
|
||||
self.wfile.flush()
|
||||
continue
|
||||
if opcode != 0x1:
|
||||
continue
|
||||
self.on_message(json.loads(data))
|
||||
finally:
|
||||
with lock:
|
||||
if self.wfile in clients:
|
||||
clients.remove(self.wfile)
|
||||
log({"event": "disconnect"})
|
||||
|
||||
def send(self, message):
|
||||
with lock:
|
||||
self.wfile.write(frame(json.dumps(message)))
|
||||
self.wfile.flush()
|
||||
|
||||
def on_message(self, message):
|
||||
log({"event": "received", "message": message})
|
||||
kind, request = message.get("type"), message.get("id")
|
||||
if kind == "subscribe_notifications":
|
||||
after = message.get("after")
|
||||
ids = [n["id"] for n in store]
|
||||
replay = store[ids.index(after) + 1:] if after in ids else list(store)
|
||||
self.send({"type": "notifications_subscribed", "id": request,
|
||||
"notifications": replay, "ids": cleared[-50:]})
|
||||
elif kind == "clear_notifications":
|
||||
ids = message.get("ids", [])
|
||||
store[:] = [n for n in store if n["id"] not in ids]
|
||||
cleared.extend(ids)
|
||||
self.send({"type": "notifications_cleared", "id": request, "ids": ids})
|
||||
broadcast({"type": "notifications_cleared", "ids": ids})
|
||||
elif request:
|
||||
self.send({"type": "error", "id": request, "error": "fake server: %s" % kind})
|
||||
|
||||
|
||||
class Server(socketserver.ThreadingMixIn, socketserver.TCPServer):
|
||||
allow_reuse_address = True
|
||||
daemon_threads = True
|
||||
|
||||
|
||||
def main():
|
||||
global log_path
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--host", default="127.0.0.1")
|
||||
parser.add_argument("--port", type=int, default=0)
|
||||
parser.add_argument("--log")
|
||||
args = parser.parse_args()
|
||||
log_path = args.log
|
||||
with Server((args.host, args.port), Handler) as server:
|
||||
log({"event": "listening", "port": server.server_address[1]})
|
||||
server.serve_forever()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user