mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 12:28:40 +00:00
feat(wow): download addons from WoWInterface and open CurseForge in the browser (#2219)
This commit is contained in:
1 parent
5446497301
commit
875f8e3ce2
39 files changed
+910
No files matched your search
@@ -12,6 +12,9 @@ object Hashes {
|
||||
@JvmStatic
|
||||
fun sha512(file: File): String = hex(file, "SHA-512")
|
||||
|
||||
@JvmStatic
|
||||
fun md5(file: File): String = hex(file, "MD5")
|
||||
|
||||
@JvmStatic
|
||||
fun isGithubSha256(digest: String?): Boolean = digest != null && digest.matches(GITHUB_SHA256)
|
||||
|
||||
|
||||
@@ -0,0 +1,245 @@
|
||||
package com.droiddeck.launcher.runtime
|
||||
|
||||
import android.content.Context
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.R
|
||||
import com.droiddeck.launcher.core.Downloader
|
||||
import com.droiddeck.launcher.core.Hashes
|
||||
import com.droiddeck.launcher.stores.StoreNet
|
||||
import org.json.JSONArray
|
||||
import java.io.File
|
||||
import java.io.IOException
|
||||
import java.net.URLEncoder
|
||||
|
||||
object WowAddonCatalog {
|
||||
private const val TAG = "WowAddonCatalog"
|
||||
enum class Sort { POPULAR, UPDATED, NAME, DOWNLOADS }
|
||||
|
||||
class Category(val id: String, val name: String)
|
||||
|
||||
class Client(val folder: String, val family: String?)
|
||||
|
||||
class Query(val text: String = "", val category: String? = null, val client: Client, val sort: Sort = Sort.POPULAR)
|
||||
|
||||
class Addon(
|
||||
val id: String,
|
||||
val name: String,
|
||||
val author: String,
|
||||
val summary: String,
|
||||
val downloads: Long,
|
||||
val updated: Long,
|
||||
val thumb: String?,
|
||||
)
|
||||
|
||||
class Page(val items: List<Addon>, val more: Boolean)
|
||||
|
||||
internal class Entry(val addon: Addon, val category: String, val flavors: Set<String>?, val monthly: Long = 0L)
|
||||
|
||||
internal class Cat(val id: String, val name: String, val parents: List<String>)
|
||||
|
||||
private const val WOWI = "https://api.mmoui.com/v3/game/WOW/"
|
||||
private const val CURSEFORGE = "https://www.curseforge.com/wow/search?class=addons"
|
||||
private const val WOWI_FILES = "wowi-filelist.json"
|
||||
internal const val FRESH_MS = 6L * 60 * 60 * 1000
|
||||
|
||||
internal const val RETAIL = "_retail_"
|
||||
internal const val ERA = "_classic_era_"
|
||||
internal const val CLASSIC = "_classic_"
|
||||
internal const val ANNIVERSARY = "_anniversary_"
|
||||
internal const val FOREVER = "_forever_"
|
||||
|
||||
private val TEST_SUFFIX = Regex("_(beta|ptr|xptr)_$")
|
||||
|
||||
internal fun flavorOf(version: String): String? {
|
||||
val major = version.substringBefore('.').trim().toIntOrNull() ?: return null
|
||||
return when {
|
||||
major == 1 -> ERA
|
||||
major == 2 -> ANNIVERSARY
|
||||
major in 3..5 -> CLASSIC
|
||||
major >= 10 -> RETAIL
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
|
||||
internal fun baseFolder(folder: String): String = folder.replace(TEST_SUFFIX, "_")
|
||||
|
||||
internal fun folderFamily(folder: String): String? = when (val base = baseFolder(folder)) {
|
||||
FOREVER -> RETAIL
|
||||
RETAIL, ERA, CLASSIC, ANNIVERSARY -> base
|
||||
else -> null
|
||||
}
|
||||
|
||||
internal fun buildInfoVersion(buildInfo: String, product: String): String? {
|
||||
val lines = buildInfo.lineSequence().map { it.trim() }.filter { it.isNotEmpty() }.toList()
|
||||
if (lines.isEmpty()) return null
|
||||
val header = lines.first().split('|').map { it.substringBefore('!').trim().lowercase() }
|
||||
val productAt = header.indexOf("product")
|
||||
val versionAt = header.indexOf("version")
|
||||
if (productAt < 0 || versionAt < 0) return null
|
||||
return lines.drop(1).map { it.split('|') }
|
||||
.firstOrNull { it.getOrNull(productAt)?.trim().equals(product, ignoreCase = true) }
|
||||
?.getOrNull(versionAt)?.trim()?.ifEmpty { null }
|
||||
}
|
||||
|
||||
internal fun flavorProduct(flavorInfo: String): String? =
|
||||
flavorInfo.lineSequence().map { it.trim() }.filter { it.isNotEmpty() && '!' !in it }.firstOrNull()
|
||||
|
||||
internal fun clientVersion(flavorDir: File): String? {
|
||||
val product = runCatching { File(flavorDir, ".flavor.info").readText() }.getOrNull()?.let(::flavorProduct) ?: return null
|
||||
val info = runCatching { File(flavorDir.parentFile, ".build.info").readText() }.getOrNull() ?: return null
|
||||
return buildInfoVersion(info, product)
|
||||
}
|
||||
|
||||
internal fun client(folder: String, version: String?): Client =
|
||||
Client(folder, version?.let(::flavorOf) ?: folderFamily(folder))
|
||||
|
||||
fun client(target: WowAddons.Target): Client {
|
||||
val dir = target.addOns.parentFile?.parentFile
|
||||
return client(target.flavor, dir?.let(::clientVersion))
|
||||
}
|
||||
|
||||
internal fun flavorMatches(flavors: Set<String>?, family: String?): Boolean =
|
||||
flavors == null || family == null || family in flavors
|
||||
|
||||
internal fun parseWowiFiles(json: String): List<Entry> {
|
||||
val arr = JSONArray(json)
|
||||
val out = ArrayList<Entry>(arr.length())
|
||||
for (i in 0 until arr.length()) {
|
||||
val o = arr.optJSONObject(i) ?: continue
|
||||
val id = o.optString("UID")
|
||||
if (id.isEmpty()) continue
|
||||
val compat = o.optJSONArray("UICompatibility")
|
||||
val flavors = if (compat == null || compat.length() == 0) null else {
|
||||
val set = HashSet<String>()
|
||||
for (k in 0 until compat.length()) compat.optJSONObject(k)?.optString("version")?.let(::flavorOf)?.let(set::add)
|
||||
set
|
||||
}
|
||||
val thumbs = o.optJSONArray("UIIMG_Thumbs")
|
||||
val thumb = if (thumbs != null && thumbs.length() > 0) thumbs.optString(0).ifEmpty { null } else null
|
||||
val addon = Addon(
|
||||
id, o.optString("UIName"), o.optString("UIAuthorName"), o.optString("UIVersion"),
|
||||
o.optString("UIDownloadTotal").toLongOrNull() ?: 0L, o.optLong("UIDate"), thumb,
|
||||
)
|
||||
out.add(Entry(addon, o.optString("UICATID"), flavors, o.optString("UIDownloadMonthly").toLongOrNull() ?: 0L))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
internal fun parseWowiCategories(json: String): List<Cat> {
|
||||
val arr = JSONArray(json)
|
||||
val out = ArrayList<Cat>(arr.length())
|
||||
for (i in 0 until arr.length()) {
|
||||
val o = arr.optJSONObject(i) ?: continue
|
||||
val parents = o.optJSONArray("UICATParentIDs")
|
||||
out.add(Cat(o.optString("UICATID"), o.optString("UICATTitle"), (0 until (parents?.length() ?: 0)).map { parents!!.optString(it) }))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
internal fun filterWowi(entries: List<Entry>, cats: List<Cat>, query: Query): List<Addon> {
|
||||
val parents = cats.associate { it.id to it.parents }
|
||||
val text = query.text.trim().lowercase()
|
||||
val list = entries.filter { e ->
|
||||
flavorMatches(e.flavors, query.client.family) &&
|
||||
(query.category == null || e.category == query.category || query.category in (parents[e.category] ?: emptyList())) &&
|
||||
(text.isEmpty() || e.addon.name.lowercase().contains(text) || e.addon.author.lowercase().contains(text))
|
||||
}
|
||||
return when (query.sort) {
|
||||
Sort.POPULAR -> list.sortedWith(compareByDescending<Entry> { it.monthly }.thenByDescending { it.addon.downloads })
|
||||
Sort.DOWNLOADS -> list.sortedByDescending { it.addon.downloads }
|
||||
Sort.UPDATED -> list.sortedByDescending { it.addon.updated }
|
||||
Sort.NAME -> list.sortedBy { it.addon.name.lowercase() }
|
||||
}.map { it.addon }
|
||||
}
|
||||
|
||||
internal fun pageOf(all: List<Addon>, page: Int, pageSize: Int): Page {
|
||||
val from = (page * pageSize).coerceAtMost(all.size)
|
||||
val to = (from + pageSize).coerceAtMost(all.size)
|
||||
return Page(all.subList(from, to), to < all.size)
|
||||
}
|
||||
|
||||
internal fun cached(file: File, now: Long, fetch: () -> String?): String? {
|
||||
val kept = if (file.isFile) file.readText().takeIf(::isJsonArray) else null
|
||||
if (kept != null && isFresh(file, now)) return kept
|
||||
val body = fetch()?.takeIf(::isJsonArray)
|
||||
if (body != null) {
|
||||
val part = File(file.parentFile, "${file.name}.${java.util.UUID.randomUUID()}.part")
|
||||
runCatching {
|
||||
file.parentFile?.mkdirs()
|
||||
part.writeText(body)
|
||||
part.setLastModified(now)
|
||||
if (!part.renameTo(file)) Log.w(TAG, "could not keep ${file.name}")
|
||||
}.onFailure { Log.w(TAG, "could not keep ${file.name}", it) }
|
||||
part.delete()
|
||||
return body
|
||||
}
|
||||
return kept
|
||||
}
|
||||
|
||||
private fun isJsonArray(body: String): Boolean =
|
||||
runCatching { org.json.JSONTokener(body).nextValue() }.getOrNull() is JSONArray
|
||||
|
||||
private fun isFresh(file: File, now: Long) = file.isFile && now - file.lastModified() < FRESH_MS
|
||||
|
||||
private fun cacheFile(context: Context, name: String) = File(File(context.cacheDir, "wowaddons"), name)
|
||||
|
||||
private fun cachedGet(context: Context, name: String, url: String): String? =
|
||||
cached(cacheFile(context, name), System.currentTimeMillis()) { StoreNet.get(url, timeoutMs = 60_000) }
|
||||
|
||||
private fun unreachable(context: Context) =
|
||||
IOException(context.getString(R.string.addons_unreachable, context.getString(R.string.addons_source_wowi)))
|
||||
|
||||
fun search(context: Context, query: Query, page: Int, pageSize: Int = 40): Page =
|
||||
pageOf(filterWowi(wowiEntries(context), wowiCategories(context), query), page, pageSize)
|
||||
|
||||
private class Memo(val stamp: Long, val size: Long, val entries: List<Entry>)
|
||||
|
||||
@Volatile private var wowiMemo: Memo? = null
|
||||
|
||||
private fun wowiEntries(context: Context): List<Entry> {
|
||||
val file = cacheFile(context, WOWI_FILES)
|
||||
val memo = wowiMemo
|
||||
if (memo != null && isFresh(file, System.currentTimeMillis()) && memo.stamp == file.lastModified() && memo.size == file.length()) return memo.entries
|
||||
val body = cachedGet(context, WOWI_FILES, WOWI + "filelist.json") ?: throw unreachable(context)
|
||||
return parseWowiFiles(body).also { wowiMemo = Memo(file.lastModified(), file.length(), it) }
|
||||
}
|
||||
|
||||
private fun wowiCategories(context: Context): List<Cat> =
|
||||
cachedGet(context, "wowi-categories.json", WOWI + "categorylist.json")?.let(::parseWowiCategories) ?: emptyList()
|
||||
|
||||
fun categories(context: Context): List<Category> = wowiCategories(context).map { Category(it.id, it.name) }
|
||||
|
||||
internal fun parseWowiDetails(json: String): Pair<String, String?>? {
|
||||
val o = JSONArray(json).optJSONObject(0) ?: return null
|
||||
val url = o.optString("UIDownload").ifEmpty { return null }
|
||||
return url to o.optString("UIMD5").ifEmpty { null }
|
||||
}
|
||||
|
||||
internal fun isHttps(url: String) = url.startsWith("https://", ignoreCase = true)
|
||||
|
||||
internal fun md5Matches(file: File, expected: String?): Boolean =
|
||||
expected.isNullOrBlank() || Hashes.md5(file).equals(expected.trim(), ignoreCase = true)
|
||||
|
||||
fun download(context: Context, addon: Addon, dest: File, progress: (Int) -> Unit): File {
|
||||
val body = StoreNet.get(WOWI + "filedetails/${URLEncoder.encode(addon.id, "UTF-8")}.json", timeoutMs = 30_000)
|
||||
?: throw unreachable(context)
|
||||
val (url, md5) = parseWowiDetails(body) ?: throw IOException(context.getString(R.string.addons_no_file))
|
||||
if (!isHttps(url)) throw IOException(context.getString(R.string.addons_no_file))
|
||||
dest.parentFile?.mkdirs()
|
||||
dest.delete()
|
||||
val ok = Downloader.downloadFile(url, dest, false) { f -> if (f >= 0) progress((f * 100).toInt().coerceIn(0, 100)) }
|
||||
if (!ok || !dest.isFile) {
|
||||
dest.delete()
|
||||
throw unreachable(context)
|
||||
}
|
||||
if (!md5Matches(dest, md5)) {
|
||||
dest.delete()
|
||||
throw IOException(context.getString(R.string.selfinst_checksum_mismatch))
|
||||
}
|
||||
progress(100)
|
||||
return dest
|
||||
}
|
||||
|
||||
internal fun curseForgeUrl(text: String): String =
|
||||
text.trim().let { if (it.isEmpty()) CURSEFORGE else CURSEFORGE + "&search=" + URLEncoder.encode(it, "UTF-8") }
|
||||
}
|
||||
@@ -0,0 +1,226 @@
|
||||
package com.droiddeck.launcher.ui
|
||||
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.net.Uri
|
||||
import android.widget.Toast
|
||||
import androidx.compose.foundation.LocalIndication
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.hoverable
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Box
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.height
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.lazy.grid.GridCells
|
||||
import androidx.compose.foundation.lazy.grid.GridItemSpan
|
||||
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
|
||||
import androidx.compose.foundation.lazy.grid.items
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.Check
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.LinearProgressIndicator
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableIntStateOf
|
||||
import androidx.compose.runtime.mutableStateListOf
|
||||
import androidx.compose.runtime.mutableStateMapOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.produceState
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.rememberCoroutineScope
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.draw.clip
|
||||
import androidx.compose.ui.platform.LocalConfiguration
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.ui.res.stringResource
|
||||
import androidx.compose.ui.semantics.Role
|
||||
import androidx.compose.ui.text.style.TextOverflow
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.unit.sp
|
||||
import com.droiddeck.launcher.R
|
||||
import com.droiddeck.launcher.runtime.WowAddonCatalog
|
||||
import com.droiddeck.launcher.runtime.WowAddons
|
||||
import com.droiddeck.launcher.session.SessionState
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withContext
|
||||
import java.io.File
|
||||
|
||||
private class AddonResults {
|
||||
val items = mutableStateListOf<WowAddonCatalog.Addon>()
|
||||
var page by mutableIntStateOf(0)
|
||||
var loading by mutableStateOf(false)
|
||||
var failed by mutableStateOf<String?>(null)
|
||||
var more by mutableStateOf(false)
|
||||
}
|
||||
|
||||
@Composable
|
||||
internal fun AddonBrowserDialog(targets: List<WowAddons.Target>, initial: WowAddons.Target, onDismiss: () -> Unit) {
|
||||
val context = LocalContext.current.applicationContext
|
||||
val scope = rememberCoroutineScope()
|
||||
val shown = rememberShown(onDismiss)
|
||||
val close = { shown.targetState = false }
|
||||
var target by remember { mutableStateOf(initial) }
|
||||
var text by remember { mutableStateOf("") }
|
||||
var category by remember { mutableStateOf<WowAddonCatalog.Category?>(null) }
|
||||
var sort by remember { mutableStateOf(WowAddonCatalog.Sort.POPULAR) }
|
||||
val results = remember(text, category, sort, target) { AddonResults() }
|
||||
val installing = remember { mutableStateMapOf<String, Int>() }
|
||||
val installed = remember { mutableStateMapOf<String, Boolean>() }
|
||||
val categories by produceState(emptyList<WowAddonCatalog.Category>()) {
|
||||
value = withContext(Dispatchers.IO) { runCatching { WowAddonCatalog.categories(context) }.getOrDefault(emptyList()) }
|
||||
}
|
||||
fun load(page: Int) {
|
||||
if (results.loading) return
|
||||
results.loading = true
|
||||
results.failed = null
|
||||
val into = target
|
||||
val words = text
|
||||
val cat = category?.id
|
||||
val order = sort
|
||||
scope.launch {
|
||||
val got = withContext(Dispatchers.IO) {
|
||||
runCatching { WowAddonCatalog.search(context, WowAddonCatalog.Query(words, cat, WowAddonCatalog.client(into), order), page) }
|
||||
}
|
||||
got.onSuccess {
|
||||
if (page == 0) results.items.clear()
|
||||
results.items.addAll(it.items.filter { addon -> results.items.none { seen -> seen.id == addon.id } })
|
||||
results.page = page
|
||||
results.more = it.more
|
||||
}.onFailure { results.failed = it.message ?: it.javaClass.simpleName }
|
||||
results.loading = false
|
||||
}
|
||||
}
|
||||
LaunchedEffect(results) {
|
||||
if (text.isNotEmpty()) delay(350)
|
||||
load(0)
|
||||
}
|
||||
fun install(addon: WowAddonCatalog.Addon) {
|
||||
val key = installKey(addon, target)
|
||||
if (key in installing) return
|
||||
if (SessionState.running) {
|
||||
Toast.makeText(context, R.string.main_addons_close_session, Toast.LENGTH_LONG).show()
|
||||
return
|
||||
}
|
||||
val into = target
|
||||
installing[key] = 0
|
||||
scope.launch {
|
||||
val message = withContext(Dispatchers.IO) { installAddon(context, addon, into) { pct -> scope.launch { if (key in installing) installing[key] = pct } } }
|
||||
installing.remove(key)
|
||||
if (message.second) installed[key] = true
|
||||
Toast.makeText(context, message.first, Toast.LENGTH_LONG).show()
|
||||
}
|
||||
}
|
||||
val sourceName = stringResource(R.string.addons_source_wowi)
|
||||
AppDialog(shown, close, "addonBrowser", wide = true, scrollable = false) {
|
||||
DialogTitleRow(stringResource(R.string.addons_download), close)
|
||||
ModeHeader(sourceName, text, { text = it }, stringResource(R.string.stores_search_catalog, sourceName)) {
|
||||
BrowseChip(stringResource(R.string.addons_source_curse), false) {
|
||||
runCatching { context.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(WowAddonCatalog.curseForgeUrl(text))).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)) }
|
||||
}
|
||||
}
|
||||
ChipRow {
|
||||
BrowseDropdown(sortLabel(sort)) { first, done ->
|
||||
WowAddonCatalog.Sort.entries.forEachIndexed { index, option ->
|
||||
MenuItem(sortLabel(option), sort == option, focusRequester = if (index == 0) first else null) { sort = option; done() }
|
||||
}
|
||||
}
|
||||
if (categories.isNotEmpty()) BrowseDropdown(category?.name ?: stringResource(R.string.addons_category_all)) { first, done ->
|
||||
MenuItem(stringResource(R.string.addons_category_all), category == null, focusRequester = first) { category = null; done() }
|
||||
categories.forEach { option -> MenuItem(option.name, category?.id == option.id) { category = option; done() } }
|
||||
}
|
||||
if (targets.size > 1) BrowseDropdown(target.flavor) { first, done ->
|
||||
targets.forEachIndexed { index, option ->
|
||||
MenuItem(option.flavor, option.addOns == target.addOns, focusRequester = if (index == 0) first else null) { target = option; done() }
|
||||
}
|
||||
}
|
||||
}
|
||||
val height = (LocalConfiguration.current.screenHeightDp * 0.62f).dp
|
||||
LazyVerticalGrid(
|
||||
GridCells.Adaptive(libraryTileWidth() + 40.dp), Modifier.fillMaxWidth().height(height),
|
||||
horizontalArrangement = Arrangement.spacedBy(10.dp), verticalArrangement = Arrangement.spacedBy(10.dp),
|
||||
) {
|
||||
items(results.items, key = { it.id }) { addon ->
|
||||
AddonCard(addon, installing[installKey(addon, target)], installed[installKey(addon, target)] == true) { install(addon) }
|
||||
}
|
||||
item(key = "tail", span = { GridItemSpan(maxLineSpan) }) {
|
||||
Box(Modifier.fillMaxWidth().padding(vertical = 8.dp), contentAlignment = Alignment.Center) {
|
||||
when {
|
||||
results.loading -> LinearProgressIndicator(Modifier.fillMaxWidth())
|
||||
results.failed != null -> BrowseChip(stringResource(R.string.stores_dl_retry), false) { load(if (results.items.isEmpty()) 0 else results.page + 1) }
|
||||
results.more -> BrowseChip(stringResource(R.string.stores_itch_load_more), false) { load(results.page + 1) }
|
||||
results.items.isEmpty() -> Text(stringResource(R.string.addons_none_found), fontSize = 13.sp, color = MaterialTheme.colorScheme.onSurfaceVariant)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun AddonCard(addon: WowAddonCatalog.Addon, progress: Int?, done: Boolean, onInstall: () -> Unit) {
|
||||
val pal = LocalPalette.current
|
||||
val src = remember { androidx.compose.foundation.interaction.MutableInteractionSource() }
|
||||
val hot = rememberHot(src)
|
||||
val shape = androidx.compose.foundation.shape.RoundedCornerShape(10.dp)
|
||||
Column(
|
||||
Modifier.fillMaxWidth().clip(shape).glideBorder(hot, shape, pal.signal, pal.line)
|
||||
.hoverable(src)
|
||||
.clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onClick = onInstall)
|
||||
.controllerConfirm(onClick = onInstall),
|
||||
) {
|
||||
ArtCard(addon.name, addon.thumb, null, null, hot, capsule = false, chip = progress?.let { "$it%" }) {
|
||||
if (done) Icon(Icons.Filled.Check, stringResource(R.string.stores_installed_chip), tint = pal.good, modifier = Modifier.height(11.dp))
|
||||
else Text(stringResource(if (progress != null) R.string.store_installing else R.string.store_install), fontSize = 10.sp, color = pal.signal, maxLines = 1)
|
||||
}
|
||||
Text(
|
||||
listOf(addon.author, formatCount(addon.downloads)).filter { it.isNotEmpty() }.joinToString(" · "),
|
||||
fontSize = 11.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis,
|
||||
modifier = Modifier.padding(horizontal = 8.dp, vertical = 6.dp),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun sortLabel(sort: WowAddonCatalog.Sort): String = stringResource(
|
||||
when (sort) {
|
||||
WowAddonCatalog.Sort.POPULAR -> R.string.stores_itch_sort_popular
|
||||
WowAddonCatalog.Sort.UPDATED -> R.string.stores_itch_sort_new
|
||||
WowAddonCatalog.Sort.NAME -> R.string.addons_sort_name
|
||||
WowAddonCatalog.Sort.DOWNLOADS -> R.string.addons_sort_downloads
|
||||
},
|
||||
)
|
||||
|
||||
private fun formatCount(count: Long): String = when {
|
||||
count <= 0 -> ""
|
||||
count >= 1_000_000 -> String.format(java.util.Locale.getDefault(), "%.1fM", count / 1_000_000.0)
|
||||
count >= 1_000 -> String.format(java.util.Locale.getDefault(), "%.1fK", count / 1_000.0)
|
||||
else -> count.toString()
|
||||
}
|
||||
|
||||
private fun installAddon(context: Context, addon: WowAddonCatalog.Addon, target: WowAddons.Target, progress: (Int) -> Unit): Pair<String, Boolean> {
|
||||
val zip = File(File(context.cacheDir, "wowaddons"), "download-wowi-${addon.id.filter(Char::isLetterOrDigit)}-${java.util.UUID.randomUUID()}.zip")
|
||||
return try {
|
||||
WowAddonCatalog.download(context, addon, zip, progress)
|
||||
if (SessionState.running) return context.getString(R.string.main_addons_close_session) to false
|
||||
val names = WowAddons.import(zip, target)
|
||||
if (names.isEmpty()) context.getString(R.string.main_addons_none, addon.name) to false
|
||||
else context.resources.getQuantityString(R.plurals.main_addons_imported, names.size, names.size, target.flavor) to true
|
||||
} catch (_: WowAddons.TooLarge) {
|
||||
context.getString(R.string.main_addons_too_large, addon.name) to false
|
||||
} catch (e: Exception) {
|
||||
context.getString(R.string.stores_dl_failed_reason, e.message ?: e.javaClass.simpleName) to false
|
||||
} finally {
|
||||
zip.delete()
|
||||
}
|
||||
}
|
||||
|
||||
private fun installKey(addon: WowAddonCatalog.Addon, target: WowAddons.Target) = addon.id + "|" + target.addOns.path
|
||||
@@ -874,12 +874,15 @@ private fun SavesTab(g: Library.SteamGame, prefix: File, a: FrontEndActions) {
|
||||
|
||||
@Composable
|
||||
private fun AddonsTab(g: Library.SteamGame, targets: List<WowAddons.Target>, a: FrontEndActions) {
|
||||
var browsing by remember(g.gameId) { mutableStateOf<WowAddons.Target?>(null) }
|
||||
browsing?.let { AddonBrowserDialog(targets, it) { browsing = null } }
|
||||
Column(Modifier.fillMaxWidth().tabPanel(), verticalArrangement = Arrangement.spacedBy(2.dp)) {
|
||||
targets.forEach { target ->
|
||||
val names by produceState(emptyList<String>(), target.addOns, WowAddons.imports) {
|
||||
value = withContext(Dispatchers.IO) { WowAddons.installed(target) }
|
||||
}
|
||||
if (targets.size > 1) SectionLabel(target.flavor)
|
||||
MenuItem(stringResource(R.string.addons_download), checked = false) { browsing = target }
|
||||
MenuItem(
|
||||
stringResource(R.string.games_import_addons), checked = false,
|
||||
detail = pluralStringResource(R.plurals.games_addons_count, names.size, names.size),
|
||||
|
||||
Reference in new issue
Block a user