mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 05:46:03 +00:00
Integrate current main while preserving the original SDK migration history. Update the Android toolchain, runtime permissions, foreground service lifecycle, storage access, native execution and platform API compatibility. Complete translations and regression coverage. Validation: 3,260 JVM tests, 1,620 Python tests (eight skips), 171 Rust tests, six native regression programs and release lint with zero errors. Signed APK upgrade installed on the requested device. Signed app bundle validated with bundletool. Review candidate: physical before/after feature checks, performance parity and native 16 KiB audio compatibility remain pending. Play Console acceptance has not been verified.
138 lines
6.0 KiB
Kotlin
138 lines
6.0 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
|
|
|
|
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 },
|
|
)
|
|
|
|
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)
|
|
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))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@android.annotation.SuppressLint("UnspecifiedRegisterReceiverFlag")
|
|
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) }
|
|
}
|
|
}
|