mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 12:28:40 +00:00
* feat(updates): install any kept Preview build, link builds to their PR and commit, flag stale test builds * fix(updates): address review of the Updates tab history and test-build watch * fix(updates): notify on switch to a followed PR, keep higher-version rebuilds installable * fix(ci): let full reruns replace every artifact, note only expired PR builds * fix(ci): leave the rebuild note only when the PR build is too old to rerun * fix(ci): poll unfinished PR builds together and queue version-bump runs * fix(ci): also rebuild PR builds that were running when the versionCode changed * fix(ci): rebuild fork and just-finished PR builds, recheck the PR head before a rerun * fix(ci): fail the rebuild sweep when finding candidates fails * fix(ci): time the bump from the rebuild run's creation and scan unfinished builds of any age * fix(ci): check the latest build of every open PR instead of scanning run history * fix(ci): count PR builds that finish between the version push and the rebuild run * fix(ci): use the push time from the event as the rebuild boundary
140 lines
6.1 KiB
Kotlin
140 lines
6.1 KiB
Kotlin
package com.droiddeck.launcher
|
|
|
|
import android.app.Activity
|
|
import android.content.BroadcastReceiver
|
|
import android.content.Context
|
|
import android.content.Intent
|
|
import android.content.IntentFilter
|
|
import android.content.pm.PackageInstaller
|
|
import android.os.Build
|
|
import android.os.Handler
|
|
import androidx.compose.runtime.getValue
|
|
import androidx.compose.runtime.mutableIntStateOf
|
|
import androidx.compose.runtime.mutableStateOf
|
|
import androidx.compose.runtime.setValue
|
|
import com.droiddeck.launcher.session.SessionState
|
|
import com.droiddeck.launcher.ui.UpdatesActions
|
|
import com.droiddeck.launcher.ui.UpdatesState
|
|
import com.droiddeck.launcher.update.AppUpdates
|
|
import com.droiddeck.launcher.update.SelfInstaller
|
|
import com.droiddeck.launcher.update.UpdateWatch
|
|
|
|
internal class UpdatesMenu(private val activity: Activity, private val ui: Handler) {
|
|
var catalog by mutableStateOf<AppUpdates.Catalog?>(null)
|
|
var follow by mutableStateOf(AppUpdates.Follow(AppUpdates.Channel.STABLE))
|
|
var checking by mutableStateOf(false)
|
|
var error by mutableStateOf<String?>(null)
|
|
var stage by mutableStateOf<String?>(null)
|
|
var percent by mutableIntStateOf(-1)
|
|
var askPermission by mutableStateOf(false)
|
|
private var pending: AppUpdates.Release? = null
|
|
private var lastCheck = 0L
|
|
private var request = 0
|
|
@Volatile private var session = -1
|
|
|
|
fun state() = UpdatesState(catalog, follow, checking, error, stage, percent, askPermission)
|
|
|
|
fun actions() = UpdatesActions(
|
|
onCheck = { check(force = true) },
|
|
onFollow = ::choose,
|
|
onInstall = ::install,
|
|
onAllowInstalls = {
|
|
askPermission = false
|
|
runCatching { activity.startActivity(SelfInstaller.permissionIntent(activity)) }
|
|
.onFailure { error = activity.getString(R.string.upd_unknown_apps_failed); pending = null }
|
|
},
|
|
onDismissPermission = { askPermission = false; pending = null },
|
|
onSeen = { r -> UpdateWatch.seen(activity, r) },
|
|
)
|
|
|
|
val hasUpdate: Boolean get() = AppUpdates.hasUpdate(catalog, follow)
|
|
|
|
fun onResume() {
|
|
pending?.let { r ->
|
|
if (SelfInstaller.canInstall(activity)) { pending = null; install(r) }
|
|
}
|
|
if (!SessionState.running) check(force = false)
|
|
}
|
|
|
|
fun check(force: Boolean) {
|
|
if (checking || stage != null) return
|
|
val now = System.currentTimeMillis()
|
|
if (!force && now - lastCheck < 60_000) return
|
|
lastCheck = now
|
|
val id = ++request
|
|
checking = true
|
|
Thread({
|
|
val result = runCatching { AppUpdates.refresh(activity) }
|
|
ui.post {
|
|
if (id != request) return@post
|
|
checking = false
|
|
result.onSuccess {
|
|
catalog = it
|
|
follow = AppUpdates.follow(activity, it)
|
|
error = null
|
|
}.onFailure { if (force) error = activity.getString(R.string.upd_couldnt_check, it.message ?: it.javaClass.simpleName) }
|
|
}
|
|
}, "app-updates").start()
|
|
}
|
|
|
|
private fun choose(f: AppUpdates.Follow) {
|
|
AppUpdates.setFollow(activity, f)
|
|
UpdateWatch.sync(activity, f, catalog?.let { AppUpdates.release(it, f) })
|
|
follow = f
|
|
error = null
|
|
}
|
|
|
|
private fun install(r: AppUpdates.Release) {
|
|
if (stage != null) return
|
|
val apk = r.apk ?: run { error = activity.getString(R.string.upd_no_download); return }
|
|
AppUpdates.installBlock(r)?.let { error = it.message(activity); return }
|
|
if (SessionState.running) { error = activity.getString(R.string.upd_stop_first); return }
|
|
if (!SelfInstaller.canInstall(activity)) { pending = r; askPermission = true; return }
|
|
error = null
|
|
session = -1
|
|
stage = activity.getString(R.string.upd_stage_downloading)
|
|
percent = 0
|
|
Thread({
|
|
val result = runCatching {
|
|
val file = SelfInstaller.download(activity, apk) { pct -> ui.post { percent = pct } }
|
|
ui.post { stage = activity.getString(R.string.upd_stage_installing); percent = -1 }
|
|
SelfInstaller.install(activity, file) { id -> session = id }
|
|
}
|
|
result.onFailure { e -> ui.post { stage = null; error = e.message ?: activity.getString(R.string.upd_failed) } }
|
|
}, "app-update-install").start()
|
|
}
|
|
|
|
private val receiver = object : BroadcastReceiver() {
|
|
override fun onReceive(context: Context, intent: Intent) {
|
|
if (intent.getIntExtra(PackageInstaller.EXTRA_SESSION_ID, -1).let { it < 0 || it != session }) return
|
|
when (val status = intent.getIntExtra(PackageInstaller.EXTRA_STATUS, PackageInstaller.STATUS_FAILURE)) {
|
|
PackageInstaller.STATUS_PENDING_USER_ACTION -> {
|
|
val confirm = if (Build.VERSION.SDK_INT >= 33) intent.getParcelableExtra(Intent.EXTRA_INTENT, Intent::class.java)
|
|
else @Suppress("DEPRECATION") intent.getParcelableExtra(Intent.EXTRA_INTENT)
|
|
val safe = confirm?.let { SelfInstaller.safeConfirmIntent(activity, it) }
|
|
if (safe == null) { stage = null; error = activity.getString(R.string.upd_not_offered); return }
|
|
stage = activity.getString(R.string.upd_stage_confirm)
|
|
if (runCatching { activity.startActivity(safe) }.isFailure) { stage = null; error = activity.getString(R.string.upd_not_offered) }
|
|
}
|
|
PackageInstaller.STATUS_SUCCESS -> stage = null
|
|
else -> {
|
|
stage = null
|
|
error = SelfInstaller.describeFailure(activity, status, intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun start() {
|
|
catalog = AppUpdates.cached(activity)
|
|
follow = AppUpdates.follow(activity, catalog)
|
|
val filter = IntentFilter(SelfInstaller.ACTION_STATUS)
|
|
if (Build.VERSION.SDK_INT >= 33) activity.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
|
|
else activity.registerReceiver(receiver, filter)
|
|
}
|
|
|
|
fun unregister() {
|
|
runCatching { activity.unregisterReceiver(receiver) }
|
|
}
|
|
}
|