mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 12:28:40 +00:00
Xbox Cloud Gaming: stream from the store and Games tab, native player with DroidDeck frame generation (#1531)
Xbox Cloud Gaming: stream from the store and Games tab, native player with DroidDeck frame generation Stream Xbox games with Xbox Cloud Gaming (Game Pass) from DroidDeck, outside the Linux session. - Backend: `xodus-cli cloud-token` (tools/xbox/droiddeck-cloud-token.patch) gets the streaming tokens; they stay in memory. - Web player (default): the Greenlight player page (tools/xcloud-player, MIT) in a WebView, plus Microsoft's own xbox.com/play player. In-stream menu with screen effects (sharpen, colour, deband, FXAA, CRT, NTSC, Toon, fps cap), stream quality, performance overlay (level, layout, top right / top left) and rumble. - Native player (opt-in, Android 10+, Player engine: Native): Google's WebRTC (io.github.webrtc-sdk 125.6422.07, BSD) with the Greenlight protocol ported to Kotlin, in its own process (:xcloudnative) with its own instance of DroidDeck's compositor. Decoded frames reach the compositor as AHardwareBuffers (new stream mode, VK_ANDROID_external_memory_android_ hardware_buffer import), so DDFG 2x and LSFG 2x/3x/4x run on them. Live frame generation, frame-rate target (presets and a 10-165 fps slider, even pacing), zero-copy picture, small network buffer, fast decoder, instant controller input, overlay with engine and on-screen fps, background end, restart and web fallback. It takes the main process's tokens through XboxCloudTokenService; they are fetched ahead while a cloud game is shown. - The compositor requests the dma-buf import extensions only where the driver has them (the system driver has none). - Catalog: cloud availability, Game Pass plan CFQ7TTC0K6L8 counted, library filter All / Owned / Game Pass / Cloud, Stream and Add to Games on the store page, stream-only Games-tab entries (Stream + Download / Play + Stream). - Xbox games get VC++ 2015-2022 and the ARM64 runtime registry entries (vcredist2022_arm64, built in until the catalog has it) before each launch. - Controller focus reaches pickers opened from a game page (install location, uninstall); Add / Remove from Games keep the focus. Credits: Greenlight by UnknownSKL (Jim Kroon), MIT, player and protocol; Better xCloud for the resolution / OS mapping; MGamer404's Bannerlator #627 for the ARM64 runtime approach. Ported from the412banner's Bannerlator.
This commit is contained in:
1 parent
5ca1f610ab
commit
c5d7cdc058
78 files changed
+7835
-45
No files matched your search
@@ -25,6 +25,15 @@ class App : Application() {
|
||||
if (android.os.Build.VERSION.SDK_INT >= 28) android.webkit.WebView.setDataDirectorySuffix("xbox")
|
||||
return
|
||||
}
|
||||
if (process == "$packageName:xboxcloud") {
|
||||
if (android.os.Build.VERSION.SDK_INT >= 28) android.webkit.WebView.setDataDirectorySuffix("xboxcloud")
|
||||
return
|
||||
}
|
||||
if (process == "$packageName:xcloudnative") {
|
||||
// The native cloud player: the stores log and nothing that touches the Linux session.
|
||||
com.droiddeck.launcher.stores.StoresState.init(this)
|
||||
return
|
||||
}
|
||||
if (process == "$packageName:vr_recovery" || process == "$packageName:rgb_diagnostic") return
|
||||
CrashHandler.install(this)
|
||||
com.droiddeck.launcher.session.QuestExperimental.initialize(this)
|
||||
|
||||
@@ -27,6 +27,7 @@ object Library {
|
||||
const val ADDED = "added"
|
||||
const val EPIC_LAUNCHER = "epic-launcher"
|
||||
const val EPIC_LAUNCHER_NAME = "Epic Games Launcher"
|
||||
const val XBOX_CLOUD = "xbox-cloud"
|
||||
const val SOURCE_STEAM = "steam"
|
||||
|
||||
class Rom(val name: String, val hostPath: File, val guestPath: String, val emulatorId: String, val art: File? = null)
|
||||
|
||||
@@ -3,12 +3,13 @@ package com.droiddeck.launcher.frontend
|
||||
import android.content.Context
|
||||
import com.droiddeck.launcher.stores.Store
|
||||
import com.droiddeck.launcher.stores.StoreGameSidecar
|
||||
import com.droiddeck.launcher.session.WinComponents
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
import java.util.Locale
|
||||
|
||||
object WinCompSources {
|
||||
enum class Origin { STEAM, GOG, EPIC, AMAZON, STEAM_NAME, FOLDER }
|
||||
enum class Origin { STEAM, GOG, EPIC, AMAZON, STEAM_NAME, FOLDER, XBOX }
|
||||
|
||||
data class Finding(val component: String?, val original: String, val origin: Origin, val auto: Boolean, val args: List<String> = emptyList())
|
||||
|
||||
@@ -49,6 +50,17 @@ object WinCompSources {
|
||||
|
||||
fun installer(path: String): List<String> = if (UE_PREREQ.containsMatchIn(path)) listOf("vcredist2022", "d3dx9") else DependencyDetector.componentsFor(path)
|
||||
|
||||
private val XBOX_KNOWN = Regex("""<KnownDependency\s+Name="([A-Za-z0-9_.-]{1,40})"""")
|
||||
// VC14 also registers the ARM64 runtime: launchers running as ARM64EC look for it and stop when it is missing.
|
||||
private val XBOX_COMPONENTS = mapOf("VC14" to listOf("vcredist2022", WinComponents.VCREDIST_ARM64))
|
||||
|
||||
/** Microsoft installs a PC Game Pass game's declared runtimes with it; VC14 is wanted by nearly all and is always added. */
|
||||
fun xbox(folder: File?): List<Pair<String, String>> {
|
||||
val config = folder?.listFiles().orEmpty().firstOrNull { it.isFile && it.name.equals("MicrosoftGame.config", ignoreCase = true) && it.length() < 1L shl 20 }
|
||||
val declared = config?.let { file -> runCatching { XBOX_KNOWN.findAll(file.readText()).map { it.groupValues[1] }.toList() }.getOrNull() }.orEmpty()
|
||||
return (listOf("VC14") + declared).flatMap { name -> XBOX_COMPONENTS[name].orEmpty().map { it to name } }.distinctBy { it.first }
|
||||
}
|
||||
|
||||
fun steamDepots(ids: List<String>): List<Pair<String, String>> = ids.mapNotNull { SteamRedists.DEPOTS[it] }.distinctBy { it.first }
|
||||
|
||||
|
||||
@@ -94,6 +106,7 @@ object WinCompSources {
|
||||
parts.forEach { out += Finding(it, original, Origin.EPIC, true) }
|
||||
}
|
||||
}
|
||||
store == Store.XBOX -> xbox(folder).forEach { (component, original) -> out += Finding(component, original, Origin.XBOX, true) }
|
||||
store == Store.AMAZON -> folder?.let { amazonPostInstall(it) }?.forEach { command ->
|
||||
val parts = installer(command)
|
||||
val original = command.replace('\\', '/').substringAfterLast('/')
|
||||
|
||||
@@ -50,8 +50,10 @@ object FrameGen {
|
||||
else -> context.getString(R.string.frame_gen_off)
|
||||
}
|
||||
|
||||
fun apply(context: Context, refreshHz: Float): String? {
|
||||
val mode = mode(context)
|
||||
fun apply(context: Context, refreshHz: Float): String? = apply(context, mode(context), refreshHz)
|
||||
|
||||
/** Arms [mode] in this process's compositor; the cloud player passes its own mode and frame-rate cap. */
|
||||
fun apply(context: Context, mode: Mode, refreshHz: Float): String? {
|
||||
when (mode.engine) {
|
||||
ENGINE_LSFG -> {
|
||||
val status = Lossless.sync(context)
|
||||
|
||||
@@ -101,10 +101,28 @@ object WinComponents {
|
||||
fun cached(context: Context): List<Component>? =
|
||||
runCatching { parse(File(context.filesDir, CATALOG_CACHE).readText()) }.getOrNull()
|
||||
|
||||
const val VCREDIST_ARM64 = "vcredist2022_arm64"
|
||||
|
||||
/**
|
||||
* The ARM64 Visual C++ 2015-2022 runtime as registry values only (the version a 14.44.35211 installer writes, in both
|
||||
* registry views). Xbox games' launchers running as ARM64EC check for it; Wine's own CRT does the work. Same approach as
|
||||
* MGamer404's Bannerlator #627. Used until the catalog carries a component of this name.
|
||||
*/
|
||||
internal fun builtInArm64Runtime(): Component {
|
||||
fun value(view: String, name: String, type: String, data: String) = Step("set_register_key", JSONObject()
|
||||
.put("action", "set_register_key").put("key", "HKLM\\Software\\${view}Microsoft\\VisualStudio\\14.0\\VC\\Runtimes\\arm64")
|
||||
.put("value", name).put("type", type).put("data", data))
|
||||
val steps = listOf("", "Wow6432Node\\").flatMap { view ->
|
||||
listOf(value(view, "Installed", "REG_DWORD", "1"), value(view, "Major", "REG_DWORD", "14"), value(view, "Minor", "REG_DWORD", "44"),
|
||||
value(view, "Bld", "REG_DWORD", "35211"), value(view, "Rbld", "REG_DWORD", "0"), value(view, "Version", "REG_SZ", "v14.44.35211.00"))
|
||||
}
|
||||
return Component(VCREDIST_ARM64, "Microsoft Visual C++ 2015-2022 ARM64 runtime 14.44.35211 (registry entries only)", "Microsoft", "ready", emptyList(), steps)
|
||||
}
|
||||
|
||||
private fun parse(body: String): List<Component>? {
|
||||
return try {
|
||||
val arr = JSONObject(body).getJSONArray("components")
|
||||
(0 until arr.length()).mapNotNull { i ->
|
||||
val listed = (0 until arr.length()).mapNotNull { i ->
|
||||
val o = arr.getJSONObject(i)
|
||||
val name = o.optString("name")
|
||||
if (!validId(name)) return@mapNotNull null
|
||||
@@ -117,6 +135,7 @@ object WinComponents {
|
||||
o.optString("snapshot"),
|
||||
)
|
||||
}
|
||||
if (listed.any { it.name == VCREDIST_ARM64 }) listed else listed + builtInArm64Runtime()
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "catalog: $e"); null
|
||||
}
|
||||
|
||||
@@ -184,6 +184,8 @@ object StoresState {
|
||||
}
|
||||
|
||||
var openDownloads by mutableStateOf(false)
|
||||
/** A "store:id" key another page asks the Stores page to open. */
|
||||
var openGameRequest by mutableStateOf<String?>(null)
|
||||
|
||||
private fun askForNotifications(context: Context) {
|
||||
val activity = context as? android.app.Activity ?: return
|
||||
|
||||
@@ -26,6 +26,8 @@ object XboxBackend : StoreBackend {
|
||||
access = emptyMap()
|
||||
}
|
||||
XboxLibraryCache.clear(context)
|
||||
XboxCloudSession.clear()
|
||||
XboxCloudActivity.clearWebSignIn(context)
|
||||
XboxRuntime.stop()
|
||||
}
|
||||
StoresState.post { packageChoice = null; StoresState.shelves.remove(store); StoresState.found.remove(store) }
|
||||
@@ -57,9 +59,13 @@ object XboxBackend : StoreBackend {
|
||||
val response = Xodus.run(app, listOf("library", "--json", "--market", market))
|
||||
val licenses = XboxCatalog.access(response, account, market, report = { StoresState.logLine("Xbox: $it") })
|
||||
val products = XboxCatalog.rawProducts(licenses.keys.toList(), market)
|
||||
val games = products.mapNotNull { XboxCatalog.product(it, licenses) }.sortedBy { it.title.lowercase() }
|
||||
val cloud = runCatching { XboxCatalog.cloudCatalog(market) }
|
||||
.onFailure { StoresState.logLine("Xbox: cloud lists unavailable (${it.javaClass.simpleName})") }.getOrNull()
|
||||
val games = mergeEditions(products.mapNotNull { XboxCatalog.product(it, licenses, cloud) }).sortedBy { it.title.lowercase() }
|
||||
StoresState.logLine("Xbox: library catalog requested=${licenses.size} returned=${products.size} supported=${games.size} " +
|
||||
"filtered=${products.size - games.size} backend-skipped=${response.optInt("skippedEntitlements")}")
|
||||
"filtered=${products.size - games.size} backend-skipped=${response.optInt("skippedEntitlements")} " +
|
||||
"pc=${games.count { it.xboxPc }} cloud=${games.count { it.xboxCloud }} cloud-only=${games.count { !it.xboxPc }} " +
|
||||
"cloud-lists=${cloud?.gamePass?.size ?: -1}/${cloud?.all?.size ?: -1}")
|
||||
synchronized(this) {
|
||||
if (current != generation || StoreAccounts.signedInAs(app, store) != account) return@Thread
|
||||
access = licenses
|
||||
|
||||
@@ -10,7 +10,7 @@ import java.time.Instant
|
||||
internal object XboxCatalog {
|
||||
private val productId = Regex("[A-Z0-9]{12}")
|
||||
private val plans = setOf("CFQ7TTC0KGQ8", "CFQ7TTC0KHS0", "CFQ7TTC0P85B", "CFQ7TTC0K5DJ", "CFQ7TTC0K6L8", "CFQ7TTC10QFD")
|
||||
/** Plans that include PC games; the retired console-only plan must not offer a Windows install. */
|
||||
/** Plans whose store offers advertise PC games. Library entitlements under any active plan count, as the backend resolves a PC package for them. */
|
||||
private val pcPlans = mapOf(
|
||||
"CFQ7TTC0KGQ8" to "PC Game Pass",
|
||||
"CFQ7TTC0KHS0" to "Game Pass Ultimate",
|
||||
@@ -61,7 +61,7 @@ internal object XboxCatalog {
|
||||
val parent = row.optString("satisfiedByProductId").takeUnless { it.isBlank() || it == "null" }
|
||||
if (parent == null) return if (id in plans) null else "owned"
|
||||
if (parent in blocked) return null
|
||||
if (parent in plans) return if (parent in pcPlans && activePlan(parent)) "gamepass" else null
|
||||
if (parent in plans) return if (activePlan(parent)) "gamepass" else null
|
||||
return kind(parent, visited + id)
|
||||
}
|
||||
val result = rows.keys.mapNotNull { id -> kind(id)?.let { id to it } }.toMap()
|
||||
@@ -98,7 +98,7 @@ internal object XboxCatalog {
|
||||
return products(objects(body.optJSONArray("productsList")).map { it.optString("productId") }.take(24), access)
|
||||
}
|
||||
|
||||
internal fun product(json: JSONObject, access: Map<String, String>): CatalogItem? {
|
||||
internal fun product(json: JSONObject, access: Map<String, String>, cloud: XboxCloudCatalog? = null): CatalogItem? {
|
||||
val id = json.optString("ProductId").uppercase()
|
||||
if (!productId.matches(id) || json.optString("ProductType") != "Game") return null
|
||||
val localized = objects(json.optJSONArray("LocalizedProperties")).firstOrNull() ?: return null
|
||||
@@ -107,7 +107,9 @@ internal object XboxCatalog {
|
||||
objects(it.optJSONObject("Sku")?.optJSONObject("Properties")?.optJSONArray("Packages"))
|
||||
}
|
||||
val pc = packages.filter { pkg -> objects(pkg.optJSONArray("PlatformDependencies")).any { it.optString("PlatformName") == "Windows.Desktop" } }
|
||||
if (pc.none { it.optString("PackageFormat").equals("MSIXVC", true) }) return null
|
||||
val installable = pc.any { it.optString("PackageFormat").equals("MSIXVC", true) }
|
||||
val streams = cloud?.streams(id, access[id].orEmpty()) == true
|
||||
if (!installable && !streams) return null
|
||||
val images = objects(localized.optJSONArray("Images"))
|
||||
fun image(vararg kinds: String): String? = kinds.firstNotNullOfOrNull { purpose ->
|
||||
images.firstOrNull { it.optString("ImagePurpose") == purpose }?.optString("Uri")?.let { raw ->
|
||||
@@ -127,13 +129,57 @@ internal object XboxCatalog {
|
||||
storeUrl = "https://www.xbox.com/games/store/$id",
|
||||
publisher = localized.optString("PublisherName"), developer = localized.optString("DeveloperName"),
|
||||
description = localized.optString("ProductDescription"),
|
||||
sizeBytes = pc.maxOfOrNull { it.optLong("MaxDownloadSizeInBytes") } ?: 0L,
|
||||
extra = mapOf("market" to Xodus.market(), "access" to kind.orEmpty()),
|
||||
sizeBytes = if (installable) pc.maxOfOrNull { it.optLong("MaxDownloadSizeInBytes") } ?: 0L else 0L,
|
||||
extra = mapOf("market" to Xodus.market(), "access" to kind.orEmpty(), "pc" to flag(installable), "cloud" to flag(streams)),
|
||||
)
|
||||
}
|
||||
|
||||
private const val CLOUD_GAME_PASS = "29a81209-df6f-41fd-a528-2ae6b91f719c"
|
||||
private const val CLOUD_ALL = "ce573635-7c18-4d0c-9d68-90b932393470"
|
||||
|
||||
/** Microsoft's public cloud lists (catalog.gamepass.com "sigls"; ids as Better xCloud by redphx, MIT, uses them). */
|
||||
fun cloudCatalog(market: String = Xodus.market()): XboxCloudCatalog =
|
||||
XboxCloudCatalog(cloudList(CLOUD_GAME_PASS, market), cloudList(CLOUD_ALL, market))
|
||||
|
||||
private fun cloudList(id: String, market: String): Set<String> {
|
||||
val body = JSONArray(StoreNet.get("https://catalog.gamepass.com/sigls/v2?id=$id&language=en-us&market=$market") ?: error("Xbox cloud list unavailable"))
|
||||
return (0 until body.length()).mapNotNull { body.optJSONObject(it)?.optString("id")?.uppercase()?.takeIf(productId::matches) }.toSet()
|
||||
}
|
||||
|
||||
fun cloudUrl(id: String, title: String, cloudId: String = id): String =
|
||||
"https://www.xbox.com/play/launch/${title.lowercase().replace(Regex("[^a-z0-9]+"), "-").trim('-').ifEmpty { "game" }}/$cloudId"
|
||||
|
||||
internal fun flag(value: Boolean) = if (value) "1" else "0"
|
||||
|
||||
fun objects(array: JSONArray?): List<JSONObject> = if (array == null) emptyList() else
|
||||
(0 until array.length()).mapNotNull { array.optJSONObject(it) }
|
||||
|
||||
private fun get(url: String): JSONObject = JSONObject(StoreNet.get(url) ?: error("Microsoft Store could not be reached. Try again."))
|
||||
}
|
||||
|
||||
internal data class XboxCloudCatalog(val gamePass: Set<String>, val all: Set<String>) {
|
||||
fun streams(id: String, access: String): Boolean = when (access) {
|
||||
"gamepass" -> id in gamePass
|
||||
"owned" -> id in all || id in gamePass
|
||||
else -> false
|
||||
}
|
||||
}
|
||||
|
||||
val CatalogItem.xboxPc: Boolean get() = extra["pc"] != "0"
|
||||
val CatalogItem.xboxCloud: Boolean get() = extra["cloud"] == "1"
|
||||
val CatalogItem.xboxCloudId: String get() = extra["cloudId"]?.takeIf { it.isNotEmpty() } ?: id
|
||||
|
||||
/** Microsoft lists console and PC editions as separate products; a cloud-only one with a PC game's title folds into that card. */
|
||||
internal fun mergeEditions(games: List<CatalogItem>): List<CatalogItem> {
|
||||
fun key(title: String) = title.lowercase().replace(Regex("[^a-z0-9]+"), "")
|
||||
val cloudOnly = games.filter { !it.xboxPc && it.xboxCloud }.groupBy { key(it.title) }
|
||||
val folded = HashSet<String>()
|
||||
val merged = games.map { game ->
|
||||
if (!game.xboxPc || game.xboxCloud) game
|
||||
else cloudOnly[key(game.title)]?.firstOrNull()?.let { console ->
|
||||
folded.add(console.id)
|
||||
game.copy(extra = game.extra + mapOf("cloud" to "1", "cloudId" to console.id))
|
||||
} ?: game
|
||||
}
|
||||
return merged.filter { it.id !in folded }
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.annotation.SuppressLint
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.graphics.Color
|
||||
import android.os.Bundle
|
||||
import android.util.Log
|
||||
import android.view.InputDevice
|
||||
import android.view.KeyEvent
|
||||
import android.view.View
|
||||
import android.view.WindowManager
|
||||
import android.webkit.ConsoleMessage
|
||||
import android.webkit.CookieManager
|
||||
import android.webkit.PermissionRequest
|
||||
import android.webkit.WebChromeClient
|
||||
import android.webkit.WebResourceRequest
|
||||
import android.webkit.WebSettings
|
||||
import android.webkit.WebView
|
||||
import android.webkit.WebViewClient
|
||||
import android.widget.FrameLayout
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.core.view.WindowCompat
|
||||
import androidx.core.view.WindowInsetsCompat
|
||||
import androidx.core.view.WindowInsetsControllerCompat
|
||||
import androidx.webkit.WebSettingsCompat
|
||||
import androidx.webkit.WebViewCompat
|
||||
import androidx.webkit.WebViewFeature
|
||||
|
||||
/**
|
||||
* Microsoft's web player (xbox.com/play) in its own process and WebView data directory: the store sign-in
|
||||
* clears its own web data after each attempt, so the player keeps a separate Microsoft session. Signing out of
|
||||
* the store clears it ([clearWebSignIn]).
|
||||
*/
|
||||
class XboxCloudActivity : ComponentActivity() {
|
||||
private var web: WebView? = null
|
||||
private var custom: View? = null
|
||||
private var customCallback: WebChromeClient.CustomViewCallback? = null
|
||||
private lateinit var root: FrameLayout
|
||||
|
||||
@SuppressLint("SetJavaScriptEnabled")
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
|
||||
hideBars()
|
||||
root = FrameLayout(this).apply { setBackgroundColor(Color.BLACK) }
|
||||
setContentView(root)
|
||||
Log.i(TAG, "WebView ${WebViewCompat.getCurrentWebViewPackage(this)?.versionName}")
|
||||
|
||||
val view = WebView(this)
|
||||
web = view
|
||||
view.settings.apply {
|
||||
javaScriptEnabled = true
|
||||
domStorageEnabled = true
|
||||
databaseEnabled = true
|
||||
mediaPlaybackRequiresUserGesture = false
|
||||
allowFileAccess = false
|
||||
allowContentAccess = false
|
||||
mixedContentMode = WebSettings.MIXED_CONTENT_NEVER_ALLOW
|
||||
useWideViewPort = true
|
||||
loadWithOverviewMode = true
|
||||
userAgentString = chromeUserAgent(userAgentString)
|
||||
}
|
||||
// No "X-Requested-With: <package>" header: it marks the page as embedded in an app.
|
||||
if (WebViewFeature.isFeatureSupported(WebViewFeature.REQUESTED_WITH_HEADER_ALLOW_LIST))
|
||||
WebSettingsCompat.setRequestedWithHeaderOriginAllowList(view.settings, emptySet())
|
||||
Log.i(TAG, "UA ${view.settings.userAgentString}")
|
||||
CookieManager.getInstance().setAcceptCookie(true)
|
||||
CookieManager.getInstance().setAcceptThirdPartyCookies(view, true)
|
||||
view.webViewClient = object : WebViewClient() {
|
||||
override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest): Boolean =
|
||||
request.url.scheme != "https"
|
||||
override fun onPageFinished(view: WebView, url: String) { Log.i(TAG, "page ${url.substringBefore('?')}") }
|
||||
}
|
||||
view.webChromeClient = object : WebChromeClient() {
|
||||
override fun onConsoleMessage(message: ConsoleMessage): Boolean {
|
||||
Log.d(TAG, "console ${message.messageLevel()}: ${message.message().take(300)}")
|
||||
return true
|
||||
}
|
||||
override fun onPermissionRequest(request: PermissionRequest) {
|
||||
Log.i(TAG, "permission request ${request.resources.joinToString()} denied")
|
||||
request.deny()
|
||||
}
|
||||
override fun onShowCustomView(view: View, callback: CustomViewCallback) {
|
||||
custom?.let { root.removeView(it) }
|
||||
custom = view; customCallback = callback
|
||||
root.addView(view, FrameLayout.LayoutParams(-1, -1))
|
||||
hideBars()
|
||||
}
|
||||
override fun onHideCustomView() {
|
||||
custom?.let { root.removeView(it) }
|
||||
custom = null; customCallback = null
|
||||
}
|
||||
}
|
||||
root.addView(view, FrameLayout.LayoutParams(-1, -1))
|
||||
if (savedInstanceState != null) view.restoreState(savedInstanceState)
|
||||
else view.loadUrl(startUrl(intent))
|
||||
}
|
||||
|
||||
override fun onNewIntent(intent: Intent) {
|
||||
super.onNewIntent(intent)
|
||||
setIntent(intent)
|
||||
web?.loadUrl(startUrl(intent))
|
||||
}
|
||||
|
||||
private fun startUrl(intent: Intent): String =
|
||||
intent.getStringExtra("url")?.takeIf { url -> runCatching { java.net.URI(url) }.getOrNull()?.let {
|
||||
it.scheme == "https" && it.host == "www.xbox.com" && it.userInfo == null && it.port == -1 } == true } ?: START_URL
|
||||
|
||||
// Without the WebView markers the page treats this as Chrome for Android.
|
||||
private fun chromeUserAgent(default: String): String =
|
||||
default.replace("; wv)", ")").replace(Regex(" Version/\\d+(\\.\\d+)*"), "")
|
||||
|
||||
private fun hideBars() {
|
||||
WindowCompat.setDecorFitsSystemWindows(window, false)
|
||||
WindowInsetsControllerCompat(window, window.decorView).apply {
|
||||
hide(WindowInsetsCompat.Type.systemBars())
|
||||
systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
|
||||
}
|
||||
}
|
||||
|
||||
override fun onWindowFocusChanged(hasFocus: Boolean) {
|
||||
super.onWindowFocusChanged(hasFocus)
|
||||
if (hasFocus) hideBars()
|
||||
}
|
||||
|
||||
// A controller's unused B arrives as BACK; ask before leaving so a stray press never ends a stream.
|
||||
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
|
||||
if (event.keyCode == KeyEvent.KEYCODE_BACK && event.action == KeyEvent.ACTION_UP) {
|
||||
val fromController = event.source and InputDevice.SOURCE_GAMEPAD == InputDevice.SOURCE_GAMEPAD ||
|
||||
event.source and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK
|
||||
when {
|
||||
custom != null -> customCallback?.onCustomViewHidden()
|
||||
fromController -> confirmLeave()
|
||||
web?.canGoBack() == true -> web?.goBack()
|
||||
else -> finish()
|
||||
}
|
||||
return true
|
||||
}
|
||||
if (event.keyCode == KeyEvent.KEYCODE_BACK) return true
|
||||
return super.dispatchKeyEvent(event)
|
||||
}
|
||||
|
||||
private var leaving: android.app.AlertDialog? = null
|
||||
|
||||
private fun confirmLeave() {
|
||||
if (leaving?.isShowing == true) return
|
||||
leaving = android.app.AlertDialog.Builder(this, android.R.style.Theme_DeviceDefault_Dialog_Alert)
|
||||
.setTitle("Leave Xbox Cloud Gaming?")
|
||||
.setMessage("The stream ends when you leave.")
|
||||
.setPositiveButton("Leave") { _, _ -> finish() }
|
||||
.setNegativeButton("Stay", null)
|
||||
.show()
|
||||
}
|
||||
|
||||
override fun onSaveInstanceState(outState: Bundle) {
|
||||
super.onSaveInstanceState(outState)
|
||||
web?.saveState(outState)
|
||||
}
|
||||
|
||||
override fun onPause() { super.onPause(); CookieManager.getInstance().flush() }
|
||||
|
||||
override fun onDestroy() {
|
||||
web?.let { root.removeView(it); it.stopLoading(); it.destroy() }
|
||||
web = null
|
||||
super.onDestroy()
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val TAG = "XboxCloud"
|
||||
const val START_URL = "https://www.xbox.com/play"
|
||||
|
||||
fun intent(context: Context, url: String? = null): Intent = Intent(context, XboxCloudActivity::class.java)
|
||||
.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
|
||||
.apply { if (url != null) putExtra("url", url) }
|
||||
|
||||
const val PROCESS_SUFFIX = ":xboxcloud"
|
||||
const val WEBVIEW_SUFFIX = "xboxcloud"
|
||||
|
||||
fun clearWebSignIn(context: Context) {
|
||||
val am = context.getSystemService(Context.ACTIVITY_SERVICE) as android.app.ActivityManager
|
||||
am.runningAppProcesses.orEmpty().filter { it.processName.endsWith(PROCESS_SUFFIX) }
|
||||
.forEach { android.os.Process.killProcess(it.pid) }
|
||||
val suffix = WEBVIEW_SUFFIX
|
||||
listOf(java.io.File(context.applicationInfo.dataDir, "app_webview_$suffix"), java.io.File(context.cacheDir.parentFile, "cache/webview_$suffix"))
|
||||
.forEach { runCatching { it.deleteRecursively() } }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import androidx.compose.runtime.mutableStateListOf
|
||||
import com.droiddeck.launcher.frontend.Library
|
||||
import com.droiddeck.launcher.session.SessionState
|
||||
import com.droiddeck.launcher.stores.CatalogItem
|
||||
import com.droiddeck.launcher.stores.Store
|
||||
import com.droiddeck.launcher.stores.StoresState
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
import java.net.HttpURLConnection
|
||||
import java.net.URL
|
||||
|
||||
/** Xbox games added to the Games tab to stream before (or without) installing them. */
|
||||
object XboxCloudGames {
|
||||
class Entry(val id: String, val title: String, val poster: String?, val hero: String?)
|
||||
|
||||
private const val PREFS = "xbox_cloud_games"
|
||||
private val idPattern = Regex("[A-Z0-9]{12}")
|
||||
val entries = mutableStateListOf<Entry>()
|
||||
@Volatile private var loaded = false
|
||||
|
||||
fun load(context: Context) {
|
||||
if (loaded) return
|
||||
loaded = true
|
||||
val list = decode(context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getString("games", null))
|
||||
StoresState.post { entries.clear(); entries.addAll(list) }
|
||||
}
|
||||
|
||||
fun isAdded(id: String) = entries.any { it.id == id }
|
||||
|
||||
fun add(context: Context, item: CatalogItem) {
|
||||
val app = context.applicationContext
|
||||
if (isAdded(item.id)) return
|
||||
entries.add(Entry(item.id, item.title, item.tallImageUrl, item.imageUrl))
|
||||
save(app)
|
||||
Thread({
|
||||
fetch(item.tallImageUrl, File(artDir(app, item.id), "poster"))
|
||||
fetch(item.imageUrl, File(artDir(app, item.id), "hero"))
|
||||
StoresState.post { StoresState.notifyLibraryChanged(app) }
|
||||
}, "xbox-cloud-art").start()
|
||||
}
|
||||
|
||||
fun remove(context: Context, id: String) {
|
||||
val app = context.applicationContext
|
||||
entries.removeAll { it.id == id }
|
||||
save(app)
|
||||
artDir(app, id).deleteRecursively()
|
||||
}
|
||||
|
||||
private fun save(app: Context) {
|
||||
app.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit().putString("games", encode(entries.toList())).apply()
|
||||
}
|
||||
|
||||
internal fun encode(list: List<Entry>): String = JSONArray().apply {
|
||||
list.forEach { put(JSONObject().put("id", it.id).put("title", it.title).put("poster", it.poster.orEmpty()).put("hero", it.hero.orEmpty())) }
|
||||
}.toString()
|
||||
|
||||
internal fun decode(text: String?): List<Entry> = runCatching {
|
||||
val array = JSONArray(text ?: return emptyList())
|
||||
(0 until minOf(array.length(), 2000)).mapNotNull { array.optJSONObject(it) }.mapNotNull { o ->
|
||||
val id = o.optString("id")
|
||||
val title = o.optString("title")
|
||||
if (!idPattern.matches(id) || title.isBlank()) null
|
||||
else Entry(id, title.take(200), o.optString("poster").takeIf { it.isNotEmpty() }, o.optString("hero").takeIf { it.isNotEmpty() })
|
||||
}.distinctBy { it.id }
|
||||
}.getOrDefault(emptyList())
|
||||
|
||||
/** Games-tab rows for the added games that are not installed (an installed copy has its own row). */
|
||||
fun rows(context: Context, installedIds: Set<String>): List<Library.SteamGame> = entries.filter { it.id !in installedIds }.map { e ->
|
||||
val dir = artDir(context, e.id)
|
||||
val appId = rowId(e.id)
|
||||
Library.SteamGame(appId = appId, name = e.title, art = File(dir, "poster").takeIf { it.isFile }, library = Library.XBOX_CLOUD,
|
||||
hero = File(dir, "hero").takeIf { it.isFile }, source = Store.XBOX.id, storeId = e.id)
|
||||
}
|
||||
|
||||
internal fun rowId(id: String): Int = ("xbox-cloud:$id").hashCode() or Int.MIN_VALUE
|
||||
|
||||
private fun artDir(context: Context, id: String) = File(context.filesDir, "xbox-cloud-art/$id")
|
||||
|
||||
private fun fetch(url: String?, target: File) {
|
||||
if (url == null) return
|
||||
runCatching {
|
||||
val parsed = URL(url)
|
||||
require(parsed.protocol == "https" && parsed.host in setOf("store-images.s-microsoft.com", "store-images.microsoft.com"))
|
||||
val connection = parsed.openConnection() as HttpURLConnection
|
||||
try {
|
||||
connection.connectTimeout = 15_000; connection.readTimeout = 30_000
|
||||
check(connection.responseCode == 200)
|
||||
val bytes = connection.inputStream.use { it.readBytes() }
|
||||
require(bytes.size in 1..12_000_000)
|
||||
target.parentFile?.mkdirs()
|
||||
File(target.path + ".tmp").apply { writeBytes(bytes); check(renameTo(target)) }
|
||||
} finally { connection.disconnect() }
|
||||
}
|
||||
}
|
||||
|
||||
private val prefetching = java.util.concurrent.atomic.AtomicBoolean(false)
|
||||
|
||||
/**
|
||||
* Fetches the streaming tokens in the background while a cloud game is on screen (about 20 s), so Stream starts at
|
||||
* once; both players take them from this process (the native one through XboxCloudTokenService).
|
||||
*/
|
||||
fun prefetch(context: Context) {
|
||||
val app = context.applicationContext
|
||||
if (!prefetching.compareAndSet(false, true)) return
|
||||
Thread({
|
||||
try {
|
||||
val account = com.droiddeck.launcher.stores.StoreAccounts.signedInAs(app, Store.XBOX) ?: return@Thread
|
||||
runCatching { XboxCloudSession.get(app, account) }
|
||||
.onFailure { StoresState.logLine("Xbox: cloud tokens not fetched ahead: ${it.message?.take(160)}") }
|
||||
} finally { prefetching.set(false) }
|
||||
}, "xcloud-prefetch").start()
|
||||
}
|
||||
|
||||
/** Streaming runs outside the Linux session; the session owns the screen, audio and controllers while it runs. */
|
||||
fun stream(context: Context, id: String, title: String) {
|
||||
if (SessionState.running) {
|
||||
android.widget.Toast.makeText(context, "Close the Steam session to stream Xbox games.", android.widget.Toast.LENGTH_LONG).show()
|
||||
return
|
||||
}
|
||||
context.startActivity(XboxCloudPlayerActivity.playerIntent(context, id, title).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
|
||||
}
|
||||
|
||||
/** Whether the signed-in library says this game streams (cached library; reads disk). */
|
||||
fun streams(context: Context, id: String): Boolean = runCatching {
|
||||
StoresState.library[Store.XBOX]?.firstOrNull { it.id == id }?.let { return it.xboxCloud }
|
||||
val app = context.applicationContext
|
||||
val account = com.droiddeck.launcher.stores.StoreAccounts.signedInAs(app, Store.XBOX) ?: return false
|
||||
XboxLibraryCache.read(app, account, Xodus.market())?.games?.firstOrNull { it.id == id }?.xboxCloud == true
|
||||
}.getOrDefault(false)
|
||||
}
|
||||
@@ -0,0 +1,399 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.annotation.SuppressLint
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.graphics.Color
|
||||
import android.os.Bundle
|
||||
import android.view.Gravity
|
||||
import android.view.KeyEvent
|
||||
import android.view.WindowManager
|
||||
import android.webkit.JavascriptInterface
|
||||
import android.webkit.WebResourceRequest
|
||||
import android.webkit.WebResourceResponse
|
||||
import android.webkit.WebView
|
||||
import android.webkit.WebViewClient
|
||||
import android.widget.Button
|
||||
import android.widget.FrameLayout
|
||||
import android.widget.LinearLayout
|
||||
import android.widget.TextView
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.core.view.WindowCompat
|
||||
import androidx.core.view.WindowInsetsCompat
|
||||
import androidx.core.view.WindowInsetsControllerCompat
|
||||
import androidx.webkit.WebViewAssetLoader
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.layout.fillMaxHeight
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.width
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.focus.focusRequester
|
||||
import androidx.compose.ui.focus.onFocusChanged
|
||||
import androidx.compose.ui.input.key.key
|
||||
import androidx.compose.ui.input.key.onKeyEvent
|
||||
import androidx.compose.ui.input.key.type
|
||||
import androidx.compose.ui.unit.dp
|
||||
import com.droiddeck.launcher.stores.Store
|
||||
import com.droiddeck.launcher.stores.StoreAccounts
|
||||
import com.droiddeck.launcher.stores.StoresState
|
||||
import org.json.JSONObject
|
||||
import java.util.concurrent.Executors
|
||||
|
||||
/** Runs the WebRTC client page (tools/xcloud-player); signalling and tokens stay on this side of the bridge. */
|
||||
class XboxCloudPlayerActivity : ComponentActivity() {
|
||||
private lateinit var root: FrameLayout
|
||||
private var web: WebView? = null
|
||||
private var notice: LinearLayout? = null
|
||||
private val worker = Executors.newSingleThreadExecutor()
|
||||
private val signalling = Executors.newCachedThreadPool()
|
||||
@Volatile private var session: XboxCloudSession.Session? = null
|
||||
@Volatile private var sessionPath: String? = null
|
||||
@Volatile private var titleId: String? = null
|
||||
@Volatile private var closed = false
|
||||
@Volatile private var webUrl: String? = null
|
||||
@Volatile private var settings = XboxCloudSettings()
|
||||
@Volatile private var sessionSignals: XboxCloudSignalling? = null
|
||||
/** The settings this stream started with (stream-start settings changed since then need a restart). */
|
||||
@Volatile private var startedWith: XboxCloudSettings? = null
|
||||
private var menu: androidx.compose.ui.platform.ComposeView? = null
|
||||
|
||||
@SuppressLint("SetJavaScriptEnabled")
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
|
||||
hideBars()
|
||||
watchBars()
|
||||
root = FrameLayout(this).apply { setBackgroundColor(Color.BLACK) }
|
||||
setContentView(root)
|
||||
val requested = intent.getStringExtra("product").orEmpty()
|
||||
showNotice("Signing in to Xbox Cloud Gaming…", withButtons = false)
|
||||
worker.execute {
|
||||
val result = runCatching {
|
||||
val account = StoreAccounts.signedInAs(applicationContext, Store.XBOX) ?: error("Sign in to the Xbox store first.")
|
||||
val cached = XboxLibraryCache.read(applicationContext, account, Xodus.market())?.games?.firstOrNull { it.id == requested }
|
||||
val product = cached?.extra?.get("cloudId")?.takeIf { it.isNotEmpty() } ?: requested
|
||||
webUrl = XboxCatalog.cloudUrl(requested, cached?.title ?: intent.getStringExtra("title").orEmpty(), product)
|
||||
val active = XboxCloudSession.get(applicationContext, account)
|
||||
val title = XboxCloudSession.titles(active)[product] ?: error("This game can't be streamed with this account here.")
|
||||
settings = XboxCloudSettings.load(applicationContext)
|
||||
startedWith = settings
|
||||
session = active.forStream(settings.region, settings.osName); titleId = title
|
||||
diag("cloud player: $product -> title $title, region ${java.net.URI(session!!.baseUri).host}, transfer=${active.userToken != null}")
|
||||
}
|
||||
runOnUiThread {
|
||||
if (closed) return@runOnUiThread
|
||||
result.onSuccess { openPlayer() }.onFailure {
|
||||
diag("cloud player not started: ${it.javaClass.simpleName}: ${it.message?.take(160)}")
|
||||
showNotice(it.message ?: "Xbox Cloud Gaming could not start.", withButtons = true)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressLint("SetJavaScriptEnabled")
|
||||
private fun openPlayer() {
|
||||
val loader = WebViewAssetLoader.Builder().addPathHandler("/assets/", WebViewAssetLoader.AssetsPathHandler(this)).build()
|
||||
val view = WebView(this)
|
||||
web = view
|
||||
view.settings.apply {
|
||||
javaScriptEnabled = true
|
||||
mediaPlaybackRequiresUserGesture = false
|
||||
allowFileAccess = false
|
||||
allowContentAccess = false
|
||||
}
|
||||
view.setBackgroundColor(Color.BLACK)
|
||||
// The Gamepad API only sees controllers while the WebView has input focus.
|
||||
view.isFocusable = true
|
||||
view.isFocusableInTouchMode = true
|
||||
view.addJavascriptInterface(Bridge(), "DDCloud")
|
||||
view.webViewClient = object : WebViewClient() {
|
||||
override fun shouldInterceptRequest(view: WebView, request: WebResourceRequest): WebResourceResponse? =
|
||||
loader.shouldInterceptRequest(request.url)
|
||||
override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest): Boolean = true
|
||||
}
|
||||
view.webChromeClient = object : android.webkit.WebChromeClient() {
|
||||
override fun onConsoleMessage(message: android.webkit.ConsoleMessage): Boolean {
|
||||
android.util.Log.d("XboxCloudPlayer", "console ${message.messageLevel()}: ${message.message().take(300)}")
|
||||
return true
|
||||
}
|
||||
}
|
||||
root.addView(view, 0, FrameLayout.LayoutParams(-1, -1))
|
||||
notice?.let { root.removeView(it) }
|
||||
notice = null
|
||||
view.requestFocus()
|
||||
view.loadUrl("https://appassets.androidplatform.net/assets/xcloud/player.html")
|
||||
}
|
||||
|
||||
private inner class Bridge {
|
||||
@JavascriptInterface
|
||||
fun call(id: Int, op: String, arg: String) {
|
||||
signalling.execute {
|
||||
val reply = runCatching { handle(op, arg) }.getOrElse { XboxCloudSession.Reply(0, it.javaClass.simpleName) }
|
||||
if (reply.status !in 200..299) diag("cloud player $op: ${reply.status} ${reply.body.take(300)}")
|
||||
else if (op != "state" && op != "keepalive") diag("cloud player $op: ${reply.status}")
|
||||
runOnUiThread { web?.evaluateJavascript("window.__ddResolve($id, ${reply.status}, ${JSONObject.quote(reply.body)})", null) }
|
||||
}
|
||||
}
|
||||
|
||||
@JavascriptInterface
|
||||
fun status(text: String) { android.util.Log.i("XboxCloudPlayer", "status: ${text.take(120)}") }
|
||||
|
||||
@JavascriptInterface
|
||||
fun playing() {
|
||||
diag("cloud player streaming")
|
||||
runOnUiThread { web?.requestFocus() }
|
||||
}
|
||||
|
||||
@JavascriptInterface
|
||||
fun settings(): String = pageSettings(this@XboxCloudPlayerActivity.settings)
|
||||
|
||||
@JavascriptInterface
|
||||
fun log(text: String) { diag("cloud player page: ${text.take(240)}") }
|
||||
|
||||
@JavascriptInterface
|
||||
fun failed(stage: String, detail: String) {
|
||||
diag("cloud player failed at ${stage.take(40)}: ${detail.take(300)}")
|
||||
runOnUiThread { if (!closed) showNotice("The stream could not start ($stage).", withButtons = true) }
|
||||
}
|
||||
}
|
||||
|
||||
private fun handle(op: String, arg: String): XboxCloudSession.Reply {
|
||||
val active = session ?: error("no session")
|
||||
val signals = sessionSignals ?: XboxCloudSignalling(active, titleId ?: error("no title"), settings).also { sessionSignals = it }
|
||||
return signals.op(op, arg).also { sessionPath = signals.path }
|
||||
}
|
||||
|
||||
private fun showNotice(text: String, withButtons: Boolean) {
|
||||
notice?.let { root.removeView(it) }
|
||||
val box = LinearLayout(this).apply {
|
||||
orientation = LinearLayout.VERTICAL
|
||||
gravity = Gravity.CENTER
|
||||
setBackgroundColor(if (withButtons) Color.argb(230, 0, 0, 0) else Color.TRANSPARENT)
|
||||
}
|
||||
box.addView(TextView(this).apply { setTextColor(Color.WHITE); textSize = 18f; gravity = Gravity.CENTER; this.text = text; setPadding(32, 16, 32, 16) })
|
||||
if (withButtons) {
|
||||
val row = LinearLayout(this).apply { orientation = LinearLayout.HORIZONTAL; gravity = Gravity.CENTER }
|
||||
(webUrl ?: intent.getStringExtra("webUrl"))?.let { url ->
|
||||
row.addView(Button(this).apply { this.text = "Open in Microsoft's player"; setOnClickListener { startActivity(XboxCloudActivity.intent(this@XboxCloudPlayerActivity, url)); finish() } })
|
||||
}
|
||||
row.addView(Button(this).apply { this.text = "Close"; setOnClickListener { finish() } })
|
||||
box.addView(row)
|
||||
}
|
||||
notice = box
|
||||
root.addView(box, FrameLayout.LayoutParams(-1, -1))
|
||||
}
|
||||
|
||||
private val rehideBars = Runnable { if (window.decorView.hasWindowFocus()) hideBars() }
|
||||
|
||||
private fun watchBars() {
|
||||
androidx.core.view.ViewCompat.setOnApplyWindowInsetsListener(window.decorView) { v, insets ->
|
||||
if (insets.isVisible(WindowInsetsCompat.Type.navigationBars()) || insets.isVisible(WindowInsetsCompat.Type.statusBars())) {
|
||||
v.removeCallbacks(rehideBars)
|
||||
v.postDelayed(rehideBars, 1500)
|
||||
}
|
||||
androidx.core.view.ViewCompat.onApplyWindowInsets(v, insets)
|
||||
}
|
||||
}
|
||||
|
||||
override fun onResume() {
|
||||
super.onResume()
|
||||
hideBars()
|
||||
}
|
||||
|
||||
private fun hideBars() {
|
||||
WindowCompat.setDecorFitsSystemWindows(window, false)
|
||||
WindowInsetsControllerCompat(window, window.decorView).apply {
|
||||
hide(WindowInsetsCompat.Type.systemBars())
|
||||
systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
|
||||
}
|
||||
}
|
||||
|
||||
override fun onWindowFocusChanged(hasFocus: Boolean) {
|
||||
super.onWindowFocusChanged(hasFocus)
|
||||
if (hasFocus) hideBars()
|
||||
}
|
||||
|
||||
private var guideDown = false
|
||||
private var guideDownAt = 0L
|
||||
private var lastGuideUp = 0L
|
||||
private var pendingNexus: Runnable? = null
|
||||
private var swallowGuideUp = false
|
||||
|
||||
private fun isGuideKey(event: KeyEvent): Boolean = event.keyCode == KeyEvent.KEYCODE_BUTTON_MODE
|
||||
|
||||
/** One press is the stream's Xbox button; two quick presses or a hold open the player menu. */
|
||||
private fun guideKey(event: KeyEvent): Boolean {
|
||||
if (!isGuideKey(event)) return false
|
||||
if (event.action == KeyEvent.ACTION_DOWN) {
|
||||
if (event.repeatCount == 0) {
|
||||
guideDown = true; guideDownAt = event.eventTime
|
||||
val pending = pendingNexus
|
||||
if (pending != null && event.eventTime - lastGuideUp <= DOUBLE_PRESS_MS) {
|
||||
root.removeCallbacks(pending); pendingNexus = null; guideDown = false
|
||||
swallowGuideUp = true
|
||||
openMenu()
|
||||
}
|
||||
} else if (guideDown && event.eventTime - guideDownAt >= 600) {
|
||||
guideDown = false
|
||||
swallowGuideUp = true
|
||||
openMenu()
|
||||
}
|
||||
} else if (event.action == KeyEvent.ACTION_UP && guideDown) {
|
||||
guideDown = false
|
||||
lastGuideUp = event.eventTime
|
||||
val tap = Runnable { pendingNexus = null; pressNexus(1); root.postDelayed({ pressNexus(0) }, 150) }
|
||||
pendingNexus = tap
|
||||
root.postDelayed(tap, DOUBLE_PRESS_MS)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
private fun pressNexus(value: Int) {
|
||||
web?.evaluateJavascript("window.__ddButton && window.__ddButton('Nexus', $value)", null)
|
||||
}
|
||||
|
||||
// Back opens the player menu so a stray press never ends a stream.
|
||||
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
|
||||
if (menu != null) {
|
||||
if (isGuideKey(event)) {
|
||||
if (event.action == KeyEvent.ACTION_UP) { if (swallowGuideUp) swallowGuideUp = false else closeMenu() }
|
||||
return true
|
||||
}
|
||||
if (event.keyCode == KeyEvent.KEYCODE_BACK) {
|
||||
if (event.action == KeyEvent.ACTION_UP) { if (menuPage.isNotEmpty()) menuPage = "" else closeMenu() }
|
||||
return true
|
||||
}
|
||||
return super.dispatchKeyEvent(event)
|
||||
}
|
||||
if (notice == null && guideKey(event)) return true
|
||||
if (event.keyCode == KeyEvent.KEYCODE_BACK) {
|
||||
if (event.action == KeyEvent.ACTION_UP) { if (notice == null) openMenu() else finish() }
|
||||
return true
|
||||
}
|
||||
// Reporting controller buttons handled stops Android turning an unused one into a fallback key.
|
||||
val handled = super.dispatchKeyEvent(event)
|
||||
val fromController = event.source and android.view.InputDevice.SOURCE_GAMEPAD == android.view.InputDevice.SOURCE_GAMEPAD ||
|
||||
event.source and android.view.InputDevice.SOURCE_JOYSTICK == android.view.InputDevice.SOURCE_JOYSTICK
|
||||
return handled || (notice == null && web != null && fromController)
|
||||
}
|
||||
|
||||
private var menuPage by androidx.compose.runtime.mutableStateOf("")
|
||||
|
||||
private fun openMenu() {
|
||||
if (menu != null || web == null) return
|
||||
web?.evaluateJavascript("window.__ddInput && window.__ddInput(false)", null)
|
||||
menuPage = ""
|
||||
val regions = session?.regionList?.map { it.name }.orEmpty()
|
||||
val view = androidx.compose.ui.platform.ComposeView(this)
|
||||
view.setContent {
|
||||
com.droiddeck.launcher.ui.DroidDeckTheme {
|
||||
var current by androidx.compose.runtime.remember { androidx.compose.runtime.mutableStateOf(settings) }
|
||||
val entries = androidx.compose.runtime.remember { List(6) { androidx.compose.ui.focus.FocusRequester() } }
|
||||
androidx.compose.runtime.LaunchedEffect(menuPage) {
|
||||
if (menuPage.isEmpty()) runCatching { entries[lastMainEntry.coerceIn(0, 5)].requestFocus() }
|
||||
}
|
||||
val cs = androidx.compose.material3.MaterialTheme.colorScheme
|
||||
androidx.compose.foundation.layout.Box(androidx.compose.ui.Modifier.fillMaxSize()) {
|
||||
androidx.compose.foundation.layout.Column(
|
||||
androidx.compose.ui.Modifier.fillMaxHeight().width(400.dp).background(cs.surface.copy(alpha = 0.95f))
|
||||
.verticalScroll(androidx.compose.foundation.rememberScrollState()).padding(vertical = 12.dp),
|
||||
) {
|
||||
androidx.compose.material3.Text(intent.getStringExtra("title").orEmpty().ifEmpty { "Xbox Cloud Gaming" },
|
||||
style = androidx.compose.material3.MaterialTheme.typography.titleMedium, color = cs.onSurface,
|
||||
modifier = androidx.compose.ui.Modifier.padding(horizontal = 16.dp, vertical = 4.dp))
|
||||
if (menuPage.isEmpty()) {
|
||||
MenuEntry("Resume", "Back to the game", entries[0], 0) { closeMenu() }
|
||||
MenuEntry("Xbox menu", "The game's Xbox menu (also: Guide once, or View + Menu)", entries[1], 1) {
|
||||
closeMenu(); web?.evaluateJavascript("window.__ddNexus && window.__ddNexus()", null)
|
||||
}
|
||||
MenuEntry("Screen effects", "Sharpen, colour, deband, FXAA, CRT, NTSC, Toon, fps cap", entries[2], 2) { menuPage = "picture" }
|
||||
MenuEntry("Stream quality", "Resolution, region, language, codec, bitrate (next stream)", entries[3], 3) { menuPage = "stream" }
|
||||
MenuEntry("Performance overlay and sound", "Overlay level and layout, volume, controller rumble", entries[4], 4) { menuPage = "overlay" }
|
||||
MenuEntry("Leave", "End the stream", entries[5], 5) { finish() }
|
||||
androidx.compose.material3.Text("Guide twice opens this menu; Back or Guide closes it.",
|
||||
style = androidx.compose.material3.MaterialTheme.typography.bodySmall, color = cs.onSurfaceVariant,
|
||||
modifier = androidx.compose.ui.Modifier.padding(horizontal = 16.dp, vertical = 8.dp))
|
||||
} else {
|
||||
MenuEntry("‹ Back", null) { menuPage = "" }
|
||||
if (menuPage == "stream") MenuEntry("Restart the stream with these settings",
|
||||
"Ends this cloud session and starts a new one; the game restarts, unsaved progress is lost.") { restartStream() }
|
||||
val page = menuPage
|
||||
XboxCloudSettingsPanel(current, regions, live = true, section = page, restoreRow = lastRow[page] ?: 0,
|
||||
onRowFocused = { lastRow[page] = it }, startedWith = startedWith) { changed ->
|
||||
current = changed
|
||||
settings = changed
|
||||
XboxCloudSettings.save(this@XboxCloudPlayerActivity, changed)
|
||||
web?.evaluateJavascript("window.__ddApply && window.__ddApply(${JSONObject.quote(pageSettings(changed))})", null)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
menu = view
|
||||
root.addView(view, FrameLayout.LayoutParams(-1, -1))
|
||||
view.requestFocus()
|
||||
}
|
||||
|
||||
private fun pageSettings(s: XboxCloudSettings): String = JSONObject(s.toJson())
|
||||
.put("server", session?.let { active -> active.regionList.firstOrNull { it.baseUri == active.baseUri }?.name } ?: "").toString()
|
||||
|
||||
private var lastMainEntry = 0
|
||||
private val lastRow = mutableMapOf<String, Int>()
|
||||
|
||||
@androidx.compose.runtime.Composable
|
||||
private fun MenuEntry(title: String, note: String?, focus: androidx.compose.ui.focus.FocusRequester? = null, index: Int = -1, onClick: () -> Unit) =
|
||||
XboxMenuEntry(title, note, focus, { if (index >= 0) lastMainEntry = index }, onClick)
|
||||
|
||||
private fun restartStream() {
|
||||
val active = session; val path = sessionPath
|
||||
sessionPath = null
|
||||
closeMenu()
|
||||
showNotice("Restarting the stream…", withButtons = false)
|
||||
Thread({
|
||||
if (active != null && path != null) runCatching { XboxCloudSession.request(active, "DELETE", "/$path") }
|
||||
.onSuccess { diag("cloud player restart: session closed ${it.status}") }
|
||||
runOnUiThread { if (!isFinishing) { startActivity(playerIntent(this, intent.getStringExtra("product").orEmpty(), intent.getStringExtra("title").orEmpty())); finish() } }
|
||||
}, "xcloud-restart").start()
|
||||
}
|
||||
|
||||
private fun closeMenu() {
|
||||
menu?.let { root.removeView(it) }
|
||||
menu = null
|
||||
web?.evaluateJavascript("window.__ddInput && window.__ddInput(true)", null)
|
||||
web?.requestFocus()
|
||||
}
|
||||
|
||||
override fun onDestroy() {
|
||||
closed = true
|
||||
web?.let { it.evaluateJavascript("window.__ddStop && window.__ddStop()", null); root.removeView(it); it.destroy() }
|
||||
web = null
|
||||
val active = session; val path = sessionPath
|
||||
if (active != null && path != null) Thread({
|
||||
runCatching { XboxCloudSession.request(active, "DELETE", "/$path") }
|
||||
.onSuccess { diag("cloud player session closed: ${it.status}") }
|
||||
}, "xcloud-stop").start()
|
||||
worker.shutdownNow(); signalling.shutdownNow()
|
||||
super.onDestroy()
|
||||
}
|
||||
|
||||
private fun diag(text: String) = StoresState.logLine("Xbox: $text")
|
||||
|
||||
companion object {
|
||||
private const val DOUBLE_PRESS_MS = 350L
|
||||
|
||||
fun intent(context: Context, productId: String, title: String): Intent = Intent(context, XboxCloudPlayerActivity::class.java)
|
||||
.putExtra("product", productId.uppercase()).putExtra("title", title)
|
||||
|
||||
/** The player the settings pick: the native engine (frame generation) where it can run, else the web player. */
|
||||
fun playerIntent(context: Context, productId: String, title: String): Intent {
|
||||
val native = XboxNativePlayerActivity.supported() && XboxCloudSettings.load(context).playerEngine == "native"
|
||||
return if (!native) intent(context, productId, title) else Intent(context, XboxNativePlayerActivity::class.java)
|
||||
.putExtra("product", productId.uppercase()).putExtra("title", title)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.content.Context
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.net.HttpURLConnection
|
||||
import java.net.URL
|
||||
|
||||
/** Streaming-service tokens stay in memory only. Request shapes follow Greenlight / xal-node by unknownskl (MIT). */
|
||||
internal object XboxCloudSession {
|
||||
class Region(val name: String, val baseUri: String, val isDefault: Boolean)
|
||||
|
||||
class Session(val account: String, val token: String, val offering: String, val baseUri: String, val regionList: List<Region>,
|
||||
val userToken: String?, internal val expiresAt: Long,
|
||||
val osName: String = "windows") {
|
||||
val fresh get() = System.currentTimeMillis() < expiresAt - 5 * 60_000L
|
||||
val regions get() = regionList.size
|
||||
|
||||
fun forStream(regionName: String, os: String): Session = Session(account, token, offering,
|
||||
regionList.firstOrNull { it.name == regionName }?.baseUri ?: baseUri, regionList, userToken, expiresAt, os)
|
||||
}
|
||||
|
||||
@Volatile private var cached: Session? = null
|
||||
|
||||
/** One fetch at a time (about 20 s: two ticket exchanges); a second caller waits and gets the same tokens. */
|
||||
@Synchronized
|
||||
fun get(app: Context, account: String): Session {
|
||||
cached?.takeIf { it.account == account && it.fresh }?.let { return it }
|
||||
val json = Xodus.run(app, listOf("cloud-token"), timeout = 60)
|
||||
require(json.getInt("schema") == 1 && json.getString("account") == account)
|
||||
val array = json.getJSONArray("regions")
|
||||
val regions = (0 until array.length()).map { array.getJSONObject(it) }
|
||||
.map { Region(it.getString("name"), it.getString("baseUri"), it.optBoolean("isDefault")) }
|
||||
val default = regions.firstOrNull { it.isDefault } ?: regions.firstOrNull() ?: error("No Xbox Cloud Gaming region")
|
||||
val seconds = json.optLong("durationInSeconds").coerceIn(0, 24 * 3600)
|
||||
return Session(account, json.getString("gsToken"), json.getString("offering"), default.baseUri, regions,
|
||||
json.optString("userToken").takeIf { !json.isNull("userToken") && it.isNotEmpty() }, System.currentTimeMillis() + seconds * 1000).also { cached = it }
|
||||
}
|
||||
|
||||
fun clear() { cached = null; titleIds = null }
|
||||
|
||||
/**
|
||||
* For the native player's own process: the main process's tokens (it keeps them, and fetches them ahead while a
|
||||
* cloud game's page is open), handed over in memory through XboxCloudTokenService; null if that is not reachable.
|
||||
*/
|
||||
fun fromMainProcess(app: Context, account: String, timeoutSeconds: Long = 90): Session? {
|
||||
cached?.takeIf { it.account == account && it.fresh }?.let { return it }
|
||||
val reply = XboxCloudTokenService.request(app, account, timeoutSeconds) ?: return null
|
||||
reply.getString("error")?.let { error(it) }
|
||||
return fromBundle(reply).takeIf { it.account == account && it.fresh }?.also { cached = it }
|
||||
}
|
||||
|
||||
internal fun toBundle(s: Session) = android.os.Bundle().apply {
|
||||
putString("account", s.account); putString("token", s.token); putString("offering", s.offering)
|
||||
putString("baseUri", s.baseUri); putString("userToken", s.userToken); putLong("expiresAt", s.expiresAt)
|
||||
putStringArrayList("regionNames", ArrayList(s.regionList.map { it.name }))
|
||||
putStringArrayList("regionUris", ArrayList(s.regionList.map { it.baseUri }))
|
||||
putBooleanArray("regionDefaults", s.regionList.map { it.isDefault }.toBooleanArray())
|
||||
}
|
||||
|
||||
internal fun fromBundle(b: android.os.Bundle): Session {
|
||||
val names = b.getStringArrayList("regionNames").orEmpty()
|
||||
val uris = b.getStringArrayList("regionUris").orEmpty()
|
||||
val defaults = b.getBooleanArray("regionDefaults") ?: BooleanArray(0)
|
||||
val regions = names.indices.map { Region(names[it], uris.getOrElse(it) { "" }, defaults.getOrElse(it) { false }) }
|
||||
return Session(b.getString("account").orEmpty(), b.getString("token").orEmpty(), b.getString("offering").orEmpty(),
|
||||
b.getString("baseUri").orEmpty(), regions, b.getString("userToken"), b.getLong("expiresAt"))
|
||||
}
|
||||
|
||||
@Volatile private var titleIds: Pair<String, Map<String, String>>? = null
|
||||
|
||||
fun titles(session: Session): Map<String, String> {
|
||||
titleIds?.takeIf { it.first == session.account }?.let { return it.second }
|
||||
val reply = request(session, "GET", "/v2/titles")
|
||||
check(reply.status == 200) { "Xbox Cloud Gaming answered ${reply.status}" }
|
||||
val results = JSONObject(reply.body).optJSONArray("results") ?: JSONArray()
|
||||
val map = (0 until results.length()).mapNotNull { index ->
|
||||
val row = results.optJSONObject(index) ?: return@mapNotNull null
|
||||
val product = row.optJSONObject("details")?.optString("productId")?.uppercase().orEmpty()
|
||||
val title = row.optString("titleId")
|
||||
if (product.matches(Regex("[A-Z0-9]{12}")) && title.isNotBlank() && title.length <= 64) product to title else null
|
||||
}.toMap()
|
||||
titleIds = session.account to map
|
||||
return map
|
||||
}
|
||||
|
||||
class Reply(val status: Int, val body: String)
|
||||
|
||||
fun request(session: Session, method: String, path: String, body: String? = null): Reply {
|
||||
val connection = URL(session.baseUri + path).openConnection() as HttpURLConnection
|
||||
try {
|
||||
connection.connectTimeout = 15_000; connection.readTimeout = 30_000
|
||||
connection.requestMethod = method
|
||||
connection.setRequestProperty("Authorization", "Bearer ${session.token}")
|
||||
connection.setRequestProperty("Accept", "application/json")
|
||||
connection.setRequestProperty("Content-Type", "application/json")
|
||||
connection.setRequestProperty("X-Gssv-Client", "XboxComBrowser")
|
||||
connection.setRequestProperty("X-MS-Device-Info", deviceInfo(session.osName))
|
||||
if (body != null) {
|
||||
connection.doOutput = true
|
||||
connection.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
|
||||
}
|
||||
val status = connection.responseCode
|
||||
val stream = if (status in 200..299) connection.inputStream else connection.errorStream
|
||||
val text = stream?.use { it.readBytes() }?.also { require(it.size <= 16_000_000) } ?: ByteArray(0)
|
||||
return Reply(status, String(text, Charsets.UTF_8))
|
||||
} finally { connection.disconnect() }
|
||||
}
|
||||
|
||||
private fun deviceInfo(os: String) = JSONObject()
|
||||
.put("appInfo", JSONObject().put("env", JSONObject().put("clientAppId", "www.xbox.com").put("clientAppType", "browser")
|
||||
.put("clientAppVersion", "21.1.98").put("clientSdkVersion", "8.5.3").put("httpEnvironment", "prod").put("sdkInstallId", "")))
|
||||
.put("dev", JSONObject()
|
||||
.put("hw", JSONObject().put("make", "Microsoft").put("model", "unknown").put("sdktype", "web"))
|
||||
.put("os", JSONObject().put("name", os).put("ver", "22631.2715").put("platform", "desktop"))
|
||||
.put("displayInfo", JSONObject().put("dimensions", JSONObject().put("widthInPixels", 1920).put("heightInPixels", 1080))
|
||||
.put("pixelDensity", JSONObject().put("dpiX", 2).put("dpiY", 2)))
|
||||
.put("browser", JSONObject().put("browserName", "chrome").put("browserVersion", "119.0")))
|
||||
.toString()
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.content.Context
|
||||
import org.json.JSONObject
|
||||
|
||||
data class XboxCloudSettings(
|
||||
val resolution: String = "1080p", // 720p | 1080p | 1080p_hq
|
||||
val region: String = "", // "" = Microsoft's choice
|
||||
val language: String = "", // "" = the device's language
|
||||
val codec: String = "default", // default | high | normal | low
|
||||
val bitrateMbps: Int = 0, // 0 = no cap
|
||||
val preventDrops: Boolean = false,
|
||||
val statsLevel: Int = 0, // 0 off, 1 fps, 2 basic, 3 detailed, 4 full
|
||||
val statsLayout: String = "horizontal",
|
||||
val statsCorner: String = "right", // right | left
|
||||
val volume: Int = 100, // 100..300 %
|
||||
val rumble: Int = 100, // 0..100 %
|
||||
val maxFps: Int = 0,
|
||||
val brightness: Int = 0,
|
||||
val contrast: Int = 0,
|
||||
val gamma: Float = 1f,
|
||||
val saturation: Int = 100,
|
||||
val sharpen: Int = 0,
|
||||
val sharpenMode: String = "cas", // cas | usm
|
||||
val deband: Int = 0,
|
||||
val fxaa: Boolean = false,
|
||||
val toon: Boolean = false,
|
||||
val crt: Boolean = false,
|
||||
val ntsc: Boolean = false,
|
||||
val playerEngine: String = "web", // web | native (WebRTC library + DroidDeck's compositor, frame generation)
|
||||
val frameGen: String = "ddfg", // native engine: off | ddfg (2x) | lsfg | lsfg3 | lsfg4 (needs Lossless.dll)
|
||||
val fpsLimit: Int = 0, // native engine target: 0 = the screen's rate, else 30/45/60/120/144/165
|
||||
val fpsCustomOn: Boolean = false, // use fpsCustom instead of the presets
|
||||
val fpsCustom: Int = 60, // 10..165
|
||||
val instantInput: Boolean = true, // native: send controller changes at once (else every 16 ms)
|
||||
val smallBuffer: Boolean = false, // native: WebRTC shows frames as soon as decoded (no playout delay)
|
||||
val fastDecoder: Boolean = true, // native: the hardware decoder's low-latency mode
|
||||
val zeroCopy: Boolean = false, // native, frame generation off: decode straight onto the screen
|
||||
) {
|
||||
/** The native engine's frame-rate target (0 = the screen's own rate). */
|
||||
val fpsTarget get() = if (fpsCustomOn) fpsCustom else fpsLimit
|
||||
|
||||
/** The service picks the stream resolution from the reported OS (Better xCloud's mapping). */
|
||||
val osName get() = when (resolution) { "720p" -> "android"; "1080p_hq" -> "tizen"; else -> "windows" }
|
||||
|
||||
fun toJson(): String = JSONObject()
|
||||
.put("resolution", resolution).put("region", region).put("language", language).put("codec", codec)
|
||||
.put("bitrateMbps", bitrateMbps).put("preventDrops", preventDrops).put("statsLevel", statsLevel).put("statsLayout", statsLayout).put("statsCorner", statsCorner)
|
||||
.put("volume", volume).put("rumble", rumble).put("maxFps", maxFps).put("brightness", brightness).put("contrast", contrast)
|
||||
.put("gamma", gamma.toDouble()).put("saturation", saturation).put("sharpen", sharpen).put("sharpenMode", sharpenMode)
|
||||
.put("deband", deband).put("fxaa", fxaa).put("toon", toon).put("crt", crt).put("ntsc", ntsc)
|
||||
.put("playerEngine", playerEngine).put("frameGen", frameGen)
|
||||
.put("fpsLimit", fpsLimit).put("fpsCustomOn", fpsCustomOn).put("fpsCustom", fpsCustom)
|
||||
.put("instantInput", instantInput).put("smallBuffer", smallBuffer).put("fastDecoder", fastDecoder).put("zeroCopy", zeroCopy)
|
||||
.toString()
|
||||
|
||||
fun withoutEffects() = copy(brightness = 0, contrast = 0, gamma = 1f, saturation = 100, sharpen = 0, sharpenMode = "cas",
|
||||
deband = 0, fxaa = false, toon = false, crt = false, ntsc = false)
|
||||
|
||||
companion object {
|
||||
private const val PREFS = "xbox_cloud"
|
||||
private const val KEY = "settings"
|
||||
|
||||
fun load(context: Context): XboxCloudSettings =
|
||||
decode(context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getString(KEY, null))
|
||||
|
||||
internal fun decode(text: String?): XboxCloudSettings = runCatching {
|
||||
val json = JSONObject(text ?: return XboxCloudSettings())
|
||||
val d = XboxCloudSettings()
|
||||
XboxCloudSettings(
|
||||
resolution = json.optString("resolution", d.resolution).takeIf { it in setOf("720p", "1080p", "1080p_hq") } ?: d.resolution,
|
||||
region = json.optString("region", d.region).take(64), language = json.optString("language", d.language).take(16),
|
||||
codec = json.optString("codec", d.codec).takeIf { it in setOf("default", "high", "normal", "low") } ?: d.codec,
|
||||
bitrateMbps = json.optInt("bitrateMbps", d.bitrateMbps).coerceIn(0, 100),
|
||||
preventDrops = json.optBoolean("preventDrops", d.preventDrops),
|
||||
statsLevel = json.optInt("statsLevel", d.statsLevel).coerceIn(0, 4),
|
||||
statsLayout = json.optString("statsLayout", d.statsLayout).takeIf { it == "vertical" } ?: "horizontal",
|
||||
statsCorner = json.optString("statsCorner", d.statsCorner).takeIf { it == "left" } ?: "right",
|
||||
volume = json.optInt("volume", d.volume).coerceIn(100, 300), rumble = json.optInt("rumble", d.rumble).coerceIn(0, 100),
|
||||
maxFps = json.optInt("maxFps", d.maxFps).coerceIn(0, 120),
|
||||
brightness = json.optInt("brightness", d.brightness).coerceIn(-50, 50), contrast = json.optInt("contrast", d.contrast).coerceIn(-100, 100),
|
||||
gamma = json.optDouble("gamma", 1.0).toFloat().coerceIn(0.5f, 3f), saturation = json.optInt("saturation", d.saturation).coerceIn(0, 200),
|
||||
sharpen = json.optInt("sharpen", d.sharpen).coerceIn(0, 10),
|
||||
sharpenMode = json.optString("sharpenMode", d.sharpenMode).takeIf { it == "usm" } ?: "cas",
|
||||
deband = json.optInt("deband", d.deband).coerceIn(0, 8),
|
||||
fxaa = json.optBoolean("fxaa"), toon = json.optBoolean("toon"), crt = json.optBoolean("crt"), ntsc = json.optBoolean("ntsc"),
|
||||
playerEngine = json.optString("playerEngine", d.playerEngine).takeIf { it == "native" } ?: "web",
|
||||
frameGen = json.optString("frameGen", d.frameGen).let { if (it == "winfg") "ddfg" else it }
|
||||
.takeIf { it in setOf("off", "ddfg", "lsfg", "lsfg3", "lsfg4") } ?: d.frameGen,
|
||||
fpsLimit = json.optInt("fpsLimit", d.fpsLimit).takeIf { it in setOf(0, 30, 45, 60, 120, 144, 165) } ?: 0,
|
||||
fpsCustomOn = json.optBoolean("fpsCustomOn", d.fpsCustomOn),
|
||||
fpsCustom = json.optInt("fpsCustom", d.fpsCustom).coerceIn(10, 165),
|
||||
instantInput = json.optBoolean("instantInput", d.instantInput), smallBuffer = json.optBoolean("smallBuffer", d.smallBuffer),
|
||||
fastDecoder = json.optBoolean("fastDecoder", d.fastDecoder), zeroCopy = json.optBoolean("zeroCopy", d.zeroCopy),
|
||||
)
|
||||
}.getOrDefault(XboxCloudSettings())
|
||||
|
||||
fun save(context: Context, settings: XboxCloudSettings) {
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit().putString(KEY, settings.toJson()).apply()
|
||||
}
|
||||
|
||||
val LANGUAGES = listOf("" to "Device language", "en-US" to "English (US)", "en-GB" to "English (UK)", "de-DE" to "Deutsch",
|
||||
"es-ES" to "Español (España)", "es-MX" to "Español (México)", "fr-FR" to "Français", "it-IT" to "Italiano",
|
||||
"ja-JP" to "日本語", "ko-KR" to "한국어", "nl-NL" to "Nederlands", "pl-PL" to "Polski", "pt-BR" to "Português (Brasil)",
|
||||
"pt-PT" to "Português (Portugal)", "ru-RU" to "Русский", "sv-SE" to "Svenska", "tr-TR" to "Türkçe", "zh-CN" to "中文 (简体)",
|
||||
"zh-TW" to "中文 (繁體)")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.os.Bundle
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.activity.compose.setContent
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.rememberScrollState
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.OutlinedButton
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.unit.dp
|
||||
import com.droiddeck.launcher.stores.Store
|
||||
import com.droiddeck.launcher.stores.StoreAccounts
|
||||
import com.droiddeck.launcher.ui.DroidDeckTheme
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.withContext
|
||||
|
||||
class XboxCloudSettingsActivity : ComponentActivity() {
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
setContent {
|
||||
DroidDeckTheme {
|
||||
var settings by remember { mutableStateOf(XboxCloudSettings.load(this)) }
|
||||
var regions by remember { mutableStateOf(emptyList<String>()) }
|
||||
LaunchedEffect(Unit) {
|
||||
regions = withContext(Dispatchers.IO) {
|
||||
runCatching {
|
||||
val account = StoreAccounts.signedInAs(applicationContext, Store.XBOX) ?: return@runCatching emptyList()
|
||||
XboxCloudSession.get(applicationContext, account).regionList.map { it.name }
|
||||
}.getOrDefault(emptyList())
|
||||
}
|
||||
}
|
||||
Column(Modifier.fillMaxSize().background(MaterialTheme.colorScheme.background).verticalScroll(rememberScrollState())) {
|
||||
Row(Modifier.padding(16.dp), verticalAlignment = Alignment.CenterVertically) {
|
||||
OutlinedButton(onClick = { finish() }) { Text("Back") }
|
||||
Text("Xbox Cloud Gaming", style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold,
|
||||
color = MaterialTheme.colorScheme.onBackground, modifier = Modifier.padding(horizontal = 16.dp))
|
||||
}
|
||||
XboxCloudSettingsPanel(settings, regions, live = false) { changed ->
|
||||
settings = changed
|
||||
XboxCloudSettings.save(this@XboxCloudSettingsActivity, changed)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,313 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.ColumnScope
|
||||
import androidx.compose.foundation.layout.PaddingValues
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.Spacer
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.height
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.size
|
||||
import androidx.compose.foundation.layout.width
|
||||
import androidx.compose.foundation.layout.widthIn
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.OutlinedButton
|
||||
import androidx.compose.material3.Switch
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.foundation.border
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.focusable
|
||||
import androidx.compose.foundation.gestures.detectTapGestures
|
||||
import androidx.compose.runtime.rememberUpdatedState
|
||||
import androidx.compose.ui.input.pointer.pointerInput
|
||||
import androidx.compose.foundation.layout.RowScope
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.CompositionLocalProvider
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.compositionLocalOf
|
||||
import androidx.compose.ui.draw.clip
|
||||
import androidx.compose.ui.focus.FocusRequester
|
||||
import androidx.compose.ui.focus.focusProperties
|
||||
import androidx.compose.ui.focus.focusRequester
|
||||
import androidx.compose.ui.focus.onFocusChanged
|
||||
import androidx.compose.ui.graphics.Color
|
||||
import androidx.compose.ui.input.key.Key
|
||||
import androidx.compose.ui.input.key.KeyEventType
|
||||
import androidx.compose.ui.input.key.key
|
||||
import androidx.compose.ui.input.key.onKeyEvent
|
||||
import androidx.compose.ui.input.key.type
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.text.style.TextAlign
|
||||
import androidx.compose.ui.text.style.TextOverflow
|
||||
import androidx.compose.ui.unit.dp
|
||||
|
||||
/** Shared by the Xbox cloud settings page and the in-player menu; [live] changes reach the running stream. */
|
||||
@Composable
|
||||
fun XboxCloudSettingsPanel(
|
||||
settings: XboxCloudSettings,
|
||||
regions: List<String>,
|
||||
live: Boolean,
|
||||
/** "stream", "picture" or "overlay" shows that section only; null shows all. */
|
||||
section: String? = null,
|
||||
/** The row to select when the panel opens (the last one used), or null for no initial selection. */
|
||||
restoreRow: Int? = null,
|
||||
onRowFocused: (Int) -> Unit = {},
|
||||
/** The settings the running stream started with; rows that differ say they need a restart (null: no stream). */
|
||||
startedWith: XboxCloudSettings? = null,
|
||||
onChange: (XboxCloudSettings) -> Unit,
|
||||
) {
|
||||
val focus = remember(section) { PanelFocus() }
|
||||
focus.next = 0
|
||||
focus.onFocused = onRowFocused
|
||||
CompositionLocalProvider(LocalPanelFocus provides focus) {
|
||||
PanelContent(settings, regions, live, section, startedWith, onChange)
|
||||
}
|
||||
LaunchedEffect(section) {
|
||||
if (restoreRow != null) runCatching { focus.requester(restoreRow.coerceIn(0, (focus.count - 1).coerceAtLeast(0))).requestFocus() }
|
||||
}
|
||||
}
|
||||
|
||||
/** Gives each settings row its place in the page, so the last-used row can be selected again. */
|
||||
private class PanelFocus {
|
||||
var next = 0
|
||||
var count = 0
|
||||
var onFocused: (Int) -> Unit = {}
|
||||
private val requesters = mutableMapOf<Int, FocusRequester>()
|
||||
fun requester(index: Int) = requesters.getOrPut(index) { FocusRequester() }
|
||||
fun take(): Int = next++.also { count = maxOf(count, next) }
|
||||
}
|
||||
|
||||
private val LocalPanelFocus = compositionLocalOf<PanelFocus?> { null }
|
||||
|
||||
@Composable
|
||||
private fun PanelContent(
|
||||
settings: XboxCloudSettings,
|
||||
regions: List<String>,
|
||||
live: Boolean,
|
||||
section: String?,
|
||||
startedWith: XboxCloudSettings?,
|
||||
onChange: (XboxCloudSettings) -> Unit,
|
||||
) {
|
||||
// Stream-start settings changed during a stream wait for a restart; back at the starting value, no note.
|
||||
fun pending(differs: (XboxCloudSettings) -> Boolean) = startedWith != null && differs(startedWith)
|
||||
|
||||
if (section == null || section == "stream") Section("Stream", if (live) "Applies to the next stream." else "Applies when a stream starts.") {
|
||||
if (XboxNativePlayerActivity.supported()) {
|
||||
Choice("Player engine", listOf("web" to "Web", "native" to "Native (frame gen)"), settings.playerEngine,
|
||||
pending { it.playerEngine != settings.playerEngine }) { onChange(settings.copy(playerEngine = it)) }
|
||||
val ctx = androidx.compose.ui.platform.LocalContext.current
|
||||
val lsfg = androidx.compose.runtime.remember { XboxNativeVideo.lsfgReady(ctx) }
|
||||
Choice("Frame generation", XboxNativeVideo.modes(lsfg).map { it to XboxNativeVideo.modeName(it) }, settings.frameGen) {
|
||||
onChange(settings.copy(frameGen = it))
|
||||
}
|
||||
Text("Native engine (experimental): Google's WebRTC and DroidDeck's own compositor, so DroidDeck frame generation " +
|
||||
"(DDFG) or LSFG can add frames. LSFG uses the Lossless.dll DroidDeck already uses for games. Screen effects " +
|
||||
"apply to the web engine.", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.padding(start = 8.dp, bottom = 6.dp))
|
||||
}
|
||||
// The service picks the size from the reported device profile (the PC profile can send 1440p).
|
||||
Choice("Resolution", listOf("720p" to "720p (phone)", "1080p" to "Best (PC)", "1080p_hq" to "1080p HQ (TV)"),
|
||||
settings.resolution, pending { it.resolution != settings.resolution }) { onChange(settings.copy(resolution = it)) }
|
||||
Choice("Server region", listOf("" to "Automatic") + regions.map { it to it }, settings.region,
|
||||
pending { it.region != settings.region }) { onChange(settings.copy(region = it)) }
|
||||
Choice("Game language", XboxCloudSettings.LANGUAGES, settings.language,
|
||||
pending { it.language != settings.language }) { onChange(settings.copy(language = it)) }
|
||||
Choice("Video codec quality", listOf("default" to "Automatic", "high" to "High", "normal" to "Normal", "low" to "Low"), settings.codec,
|
||||
pending { it.codec != settings.codec }) { onChange(settings.copy(codec = it)) }
|
||||
Choice("Bitrate limit", listOf(0 to "No limit") + listOf(5, 8, 10, 12, 15, 20, 25, 30, 40, 50).map { it to "$it Mb/s" }, settings.bitrateMbps,
|
||||
pending { it.bitrateMbps != settings.bitrateMbps }) { onChange(settings.copy(bitrateMbps = it)) }
|
||||
Toggle("Stop quality drops", "Keeps the resolution up when this device decodes slowly.", settings.preventDrops) { onChange(settings.copy(preventDrops = it)) }
|
||||
}
|
||||
|
||||
if (section == null || section == "picture") Section("Picture", "Shader effects on the stream.") {
|
||||
Step("Brightness", "${settings.brightness}", { onChange(settings.copy(brightness = (settings.brightness - 5).coerceAtLeast(-50))) },
|
||||
{ onChange(settings.copy(brightness = (settings.brightness + 5).coerceAtMost(50))) })
|
||||
Step("Contrast", "${settings.contrast}", { onChange(settings.copy(contrast = (settings.contrast - 10).coerceAtLeast(-100))) },
|
||||
{ onChange(settings.copy(contrast = (settings.contrast + 10).coerceAtMost(100))) })
|
||||
Step("Gamma", String.format("%.1f", settings.gamma), { onChange(settings.copy(gamma = ((settings.gamma * 10).toInt() - 1).coerceAtLeast(5) / 10f)) },
|
||||
{ onChange(settings.copy(gamma = ((settings.gamma * 10).toInt() + 1).coerceAtMost(30) / 10f)) })
|
||||
Step("Saturation", "${settings.saturation}%", { onChange(settings.copy(saturation = (settings.saturation - 10).coerceAtLeast(0))) },
|
||||
{ onChange(settings.copy(saturation = (settings.saturation + 10).coerceAtMost(200))) })
|
||||
Step("Sharpen", if (settings.sharpen == 0) "Off" else "${settings.sharpen}", { onChange(settings.copy(sharpen = (settings.sharpen - 1).coerceAtLeast(0))) },
|
||||
{ onChange(settings.copy(sharpen = (settings.sharpen + 1).coerceAtMost(10))) })
|
||||
Choice("Sharpen type", listOf("cas" to "Contrast-adaptive", "usm" to "Unsharp mask"), settings.sharpenMode) { onChange(settings.copy(sharpenMode = it)) }
|
||||
Step("Deband", if (settings.deband == 0) "Off" else "${settings.deband}", { onChange(settings.copy(deband = (settings.deband - 1).coerceAtLeast(0))) },
|
||||
{ onChange(settings.copy(deband = (settings.deband + 1).coerceAtMost(8))) })
|
||||
Toggle("FXAA", "Smooths jagged edges.", settings.fxaa) { onChange(settings.copy(fxaa = it)) }
|
||||
Toggle("CRT", "Scanlines and colour fringes.", settings.crt) { onChange(settings.copy(crt = it)) }
|
||||
Toggle("NTSC", "Old TV signal look.", settings.ntsc) { onChange(settings.copy(ntsc = it)) }
|
||||
Toggle("Toon", "Cartoon outlines.", settings.toon) { onChange(settings.copy(toon = it)) }
|
||||
Choice("Frame-rate cap", listOf(0 to "Off", 30 to "30 fps", 45 to "45 fps", 60 to "60 fps"), settings.maxFps) { onChange(settings.copy(maxFps = it)) }
|
||||
Row(Modifier.fillMaxWidth().padding(top = 6.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||
OutlinedButton(onClick = { onChange(settings.withoutEffects()) }) { Text("Reset picture") }
|
||||
}
|
||||
Text("Effects cost a little GPU time; with none set the stream is shown directly.", style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(top = 4.dp))
|
||||
}
|
||||
|
||||
if ((section == null && XboxNativePlayerActivity.supported()) || section == "framerate") Section("Frame rate (native engine)",
|
||||
"With frame generation this is the rate shown; without it, only targets below the stream's 60 fps change anything.") {
|
||||
Choice("Target", listOf(0 to "Screen's rate", 30 to "30 fps", 45 to "45 fps", 60 to "60 fps", 120 to "120 fps", 144 to "144 fps", 165 to "165 fps"),
|
||||
settings.fpsLimit) { onChange(settings.copy(fpsLimit = it, fpsCustomOn = false)) }
|
||||
Toggle("Custom frame rate", "Set any rate from 10 to 165 fps with the slider.", settings.fpsCustomOn) { onChange(settings.copy(fpsCustomOn = it)) }
|
||||
if (settings.fpsCustomOn) SliderRow("Custom", settings.fpsCustom, 10, 165) { onChange(settings.copy(fpsCustom = it)) }
|
||||
}
|
||||
|
||||
if ((section == null && XboxNativePlayerActivity.supported()) || section == "latency") Section("Low latency (native engine)", null) {
|
||||
Toggle("Instant controller input", "Sends each press the moment it happens instead of every 16 ms.", settings.instantInput) {
|
||||
onChange(settings.copy(instantInput = it))
|
||||
}
|
||||
Toggle("Small network buffer", "Shows frames as soon as they are decoded. Less delay; may stutter on weak Wi-Fi.",
|
||||
settings.smallBuffer, pending { it.smallBuffer != settings.smallBuffer }) { onChange(settings.copy(smallBuffer = it)) }
|
||||
Toggle("Fast decoder", "The video chip's low-latency mode.", settings.fastDecoder,
|
||||
pending { it.fastDecoder != settings.fastDecoder }) { onChange(settings.copy(fastDecoder = it)) }
|
||||
Toggle("Zero-copy picture", "Frames go straight from the video chip to the screen: the lowest delay. Used while frame generation is off and no target below 60 fps is set; switches live.",
|
||||
settings.zeroCopy) { onChange(settings.copy(zeroCopy = it)) }
|
||||
}
|
||||
|
||||
// "overlay-native": the native player's page (its sound has no volume boost).
|
||||
if (section == null || section == "overlay" || section == "overlay-native") Section("Overlay and sound", null) {
|
||||
Choice("Performance overlay", listOf(0 to "Off", 1 to "FPS only", 2 to "Basic", 3 to "Detailed", 4 to "Full"), settings.statsLevel) {
|
||||
onChange(settings.copy(statsLevel = it))
|
||||
}
|
||||
Choice("Overlay layout", listOf("horizontal" to "Horizontal", "vertical" to "Vertical"), settings.statsLayout) { onChange(settings.copy(statsLayout = it)) }
|
||||
Choice("Overlay position", listOf("right" to "Top right", "left" to "Top left"), settings.statsCorner) { onChange(settings.copy(statsCorner = it)) }
|
||||
Text("Basic: fps, ping, resolution. Detailed: + bitrate, decode time, packet loss. Full: + codec, jitter, " +
|
||||
"dropped frames, server.", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
|
||||
if (section != "overlay-native") Step("Volume", "${settings.volume}%", { onChange(settings.copy(volume = (settings.volume - 25).coerceAtLeast(100))) },
|
||||
{ onChange(settings.copy(volume = (settings.volume + 25).coerceAtMost(300))) })
|
||||
Step("Controller rumble", if (settings.rumble == 0) "Off" else "${settings.rumble}%", { onChange(settings.copy(rumble = (settings.rumble - 25).coerceAtLeast(0))) },
|
||||
{ onChange(settings.copy(rumble = (settings.rumble + 25).coerceAtMost(100))) })
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun Section(title: String, note: String?, content: @Composable ColumnScope.() -> Unit) {
|
||||
Column(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp)) {
|
||||
Text(title, style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.Bold, color = MaterialTheme.colorScheme.primary)
|
||||
if (note != null) Text(note, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
|
||||
Spacer(Modifier.height(4.dp))
|
||||
content()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* One settings row, driven by a controller: it takes focus as a whole (highlighted), Left / Right change its
|
||||
* value, A / Enter selects; the − / + buttons and switches inside stay for touch only.
|
||||
*/
|
||||
@Composable
|
||||
private fun SettingRow(
|
||||
onLeft: (() -> Unit)?,
|
||||
onRight: (() -> Unit)?,
|
||||
onSelect: (() -> Unit)?,
|
||||
content: @Composable RowScope.() -> Unit,
|
||||
) {
|
||||
val panel = LocalPanelFocus.current
|
||||
val index = panel?.take() ?: -1
|
||||
var focused by remember { mutableStateOf(false) }
|
||||
val currentSelect by rememberUpdatedState(onSelect)
|
||||
val cs = MaterialTheme.colorScheme
|
||||
val shape = RoundedCornerShape(10.dp)
|
||||
Row(
|
||||
Modifier.fillMaxWidth().padding(vertical = 1.dp).clip(shape)
|
||||
.background(if (focused) cs.primary.copy(alpha = 0.16f) else Color.Transparent)
|
||||
.border(2.dp, if (focused) cs.primary else Color.Transparent, shape)
|
||||
.let { if (panel != null && index >= 0) it.focusRequester(panel.requester(index)) else it }
|
||||
.onFocusChanged { state -> focused = state.isFocused; if (state.isFocused && index >= 0) panel?.onFocused?.invoke(index) }
|
||||
.onKeyEvent { event ->
|
||||
if (event.type != KeyEventType.KeyDown) return@onKeyEvent false
|
||||
val action = when (event.key) {
|
||||
Key.DirectionLeft -> onLeft
|
||||
Key.DirectionRight -> onRight
|
||||
Key.Enter, Key.NumPadEnter, Key.DirectionCenter, Key.ButtonA -> onSelect
|
||||
else -> null
|
||||
}
|
||||
if (action != null) { action(); true } else false
|
||||
}
|
||||
.focusable()
|
||||
// A tap selects too, without a second focus stop (a clickable would be one).
|
||||
.pointerInput(Unit) { detectTapGestures { currentSelect?.invoke() } }
|
||||
.padding(horizontal = 8.dp, vertical = 4.dp),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
content = content,
|
||||
)
|
||||
}
|
||||
|
||||
private val noFocus = Modifier.focusProperties { canFocus = false }
|
||||
|
||||
@Composable
|
||||
private fun Step(label: String, value: String, onMinus: () -> Unit, onPlus: () -> Unit) {
|
||||
SettingRow(onLeft = onMinus, onRight = onPlus, onSelect = onPlus) {
|
||||
Text(label, Modifier.weight(1f), style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurface)
|
||||
OutlinedButton(onClick = onMinus, modifier = noFocus.size(40.dp), contentPadding = PaddingValues(0.dp)) { Text("−") }
|
||||
Text(value, Modifier.widthIn(min = 112.dp, max = 168.dp).padding(horizontal = 4.dp), textAlign = TextAlign.Center,
|
||||
style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurface, maxLines = 1, overflow = TextOverflow.Ellipsis)
|
||||
OutlinedButton(onClick = onPlus, modifier = noFocus.size(40.dp), contentPadding = PaddingValues(0.dp)) { Text("+") }
|
||||
}
|
||||
}
|
||||
|
||||
/** A value slider (touch) that a controller moves with Left / Right in steps of 1 (hold to repeat). */
|
||||
@Composable
|
||||
private fun SliderRow(label: String, value: Int, min: Int, max: Int, onValue: (Int) -> Unit) {
|
||||
SettingRow(onLeft = { onValue((value - 1).coerceAtLeast(min)) }, onRight = { onValue((value + 1).coerceAtMost(max)) }, onSelect = null) {
|
||||
Text(label, Modifier.width(72.dp), style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurface)
|
||||
androidx.compose.material3.Slider(value = value.toFloat(), onValueChange = { onValue(it.toInt().coerceIn(min, max)) },
|
||||
valueRange = min.toFloat()..max.toFloat(), modifier = noFocus.weight(1f))
|
||||
Text("$value fps", Modifier.width(72.dp), textAlign = TextAlign.End, style = MaterialTheme.typography.bodyMedium,
|
||||
color = MaterialTheme.colorScheme.onSurface)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun <T> Choice(label: String, options: List<Pair<T, String>>, selected: T, needsRestart: Boolean = false, onSelect: (T) -> Unit) {
|
||||
val index = options.indexOfFirst { it.first == selected }.coerceAtLeast(0)
|
||||
Step(label, options.getOrNull(index)?.second ?: "",
|
||||
{ if (options.isNotEmpty()) onSelect(options[(index - 1 + options.size) % options.size].first) },
|
||||
{ if (options.isNotEmpty()) onSelect(options[(index + 1) % options.size].first) })
|
||||
if (needsRestart) Text("Takes effect when you restart the stream.", style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.tertiary, modifier = Modifier.padding(start = 8.dp, bottom = 4.dp))
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun Toggle(label: String, note: String, checked: Boolean, needsRestart: Boolean = false, onToggle: (Boolean) -> Unit) {
|
||||
SettingRow(onLeft = { onToggle(false) }, onRight = { onToggle(true) }, onSelect = { onToggle(!checked) }) {
|
||||
Column(Modifier.weight(1f)) {
|
||||
Text(label, style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurface)
|
||||
Text(note, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
|
||||
}
|
||||
Spacer(Modifier.width(8.dp))
|
||||
Switch(checked = checked, onCheckedChange = onToggle, modifier = noFocus)
|
||||
}
|
||||
if (needsRestart) Text("Takes effect when you restart the stream.", style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.tertiary, modifier = Modifier.padding(start = 8.dp, bottom = 4.dp))
|
||||
}
|
||||
|
||||
/** One entry of the cloud players' menu list (highlighted when selected; A or a tap opens it). */
|
||||
@Composable
|
||||
internal fun XboxMenuEntry(title: String, note: String?, focus: FocusRequester? = null, onFocused: () -> Unit = {}, onClick: () -> Unit) {
|
||||
val cs = MaterialTheme.colorScheme
|
||||
var focused by remember { mutableStateOf(false) }
|
||||
val shape = RoundedCornerShape(10.dp)
|
||||
androidx.compose.material3.Surface(
|
||||
onClick = onClick, color = if (focused) cs.primary.copy(alpha = 0.2f) else cs.surfaceContainerHigh, shape = shape,
|
||||
border = if (focused) androidx.compose.foundation.BorderStroke(2.dp, cs.primary) else null,
|
||||
modifier = Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 3.dp)
|
||||
.let { if (focus != null) it.focusRequester(focus) else it }
|
||||
.onFocusChanged { state -> focused = state.isFocused; if (state.isFocused) onFocused() }
|
||||
.onKeyEvent { event -> if (event.type == KeyEventType.KeyDown && event.key == Key.ButtonA) { onClick(); true } else false },
|
||||
) {
|
||||
Column(Modifier.padding(horizontal = 14.dp, vertical = 10.dp)) {
|
||||
Text(title, style = MaterialTheme.typography.titleSmall, color = cs.onSurface)
|
||||
if (note != null) Text(note, style = MaterialTheme.typography.bodySmall, color = cs.onSurfaceVariant)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
|
||||
/** Request shapes follow Microsoft's web player as Greenlight (MIT) implements them. */
|
||||
internal class XboxCloudSignalling(
|
||||
private val session: XboxCloudSession.Session,
|
||||
private val titleId: String,
|
||||
private val settings: XboxCloudSettings,
|
||||
) {
|
||||
@Volatile var path: String? = null
|
||||
private set
|
||||
|
||||
fun op(op: String, arg: String = ""): XboxCloudSession.Reply = when (op) {
|
||||
"start" -> start()
|
||||
"state" -> XboxCloudSession.request(session, "GET", "/$path/state")
|
||||
"connect" -> connect()
|
||||
"sdp" -> sdp(arg)
|
||||
"ice" -> ice(arg)
|
||||
"keepalive" -> XboxCloudSession.request(session, "POST", "/$path/keepalive", "{}")
|
||||
else -> XboxCloudSession.Reply(0, "unknown request")
|
||||
}
|
||||
|
||||
fun start(): XboxCloudSession.Reply {
|
||||
val body = JSONObject().put("clientSessionId", "").put("titleId", titleId).put("systemUpdateGroup", "")
|
||||
.put("settings", JSONObject().put("nanoVersion", "V3;WebrtcTransport.dll").put("enableOptionalDataCollection", false)
|
||||
.put("enableTextToSpeech", false).put("highContrast", 0).put("locale", settings.language.ifEmpty { java.util.Locale.getDefault().toLanguageTag() })
|
||||
.put("useIceConnection", false).put("timezoneOffsetMinutes", java.util.TimeZone.getDefault().getOffset(System.currentTimeMillis()) / 60_000)
|
||||
.put("sdkType", "web").put("osName", settings.osName))
|
||||
.put("serverId", "").put("fallbackRegionNames", JSONArray())
|
||||
return XboxCloudSession.request(session, "POST", "/v5/sessions/cloud/play", body.toString()).also { reply ->
|
||||
if (reply.status in 200..299) path = JSONObject(reply.body).getString("sessionPath").trim('/')
|
||||
}
|
||||
}
|
||||
|
||||
fun connect(): XboxCloudSession.Reply {
|
||||
val token = session.userToken ?: return XboxCloudSession.Reply(0, "no cloud transfer token for this account")
|
||||
return XboxCloudSession.request(session, "POST", "/$path/connect", JSONObject().put("userToken", token).toString())
|
||||
}
|
||||
|
||||
fun sdp(offer: String): XboxCloudSession.Reply {
|
||||
val body = JSONObject().put("messageType", "offer").put("sdp", offer).put("requestId", "1").put("configuration", JSONObject()
|
||||
.put("chatConfiguration", JSONObject().put("bytesPerSample", 2).put("expectedClipDurationMs", 20)
|
||||
.put("format", JSONObject().put("codec", "opus").put("container", "webm")).put("numChannels", 1).put("sampleFrequencyHz", 24000))
|
||||
.put("chat", version(1, 1)).put("control", version(1, 3)).put("input", version(1, 9)).put("message", version(1, 1))
|
||||
.put("reliableinput", version(9, 9)).put("unreliableinput", version(9, 9)))
|
||||
val posted = XboxCloudSession.request(session, "POST", "/$path/sdp", body.toString())
|
||||
return if (posted.status !in 200..299) posted else poll("/$path/sdp")
|
||||
}
|
||||
|
||||
fun ice(candidates: String): XboxCloudSession.Reply {
|
||||
val posted = XboxCloudSession.request(session, "POST", "/$path/ice", JSONObject().put("candidates", JSONArray(candidates)).toString())
|
||||
return if (posted.status !in 200..299) posted else poll("/$path/ice")
|
||||
}
|
||||
|
||||
fun stop(): XboxCloudSession.Reply? {
|
||||
val current = path ?: return null
|
||||
path = null
|
||||
return runCatching { XboxCloudSession.request(session, "DELETE", "/$current") }.getOrNull()
|
||||
}
|
||||
|
||||
private fun version(min: Int, max: Int) = JSONObject().put("minVersion", min).put("maxVersion", max)
|
||||
|
||||
/** The exchange answers 204 until the console has replied. */
|
||||
private fun poll(path: String): XboxCloudSession.Reply {
|
||||
repeat(60) {
|
||||
val reply = XboxCloudSession.request(session, "GET", path)
|
||||
if (reply.status != 204) return reply
|
||||
Thread.sleep(500)
|
||||
}
|
||||
return XboxCloudSession.Reply(0, "no answer from the cloud console")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.app.Service
|
||||
import android.content.ComponentName
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.ServiceConnection
|
||||
import android.os.Bundle
|
||||
import android.os.Handler
|
||||
import android.os.HandlerThread
|
||||
import android.os.IBinder
|
||||
import android.os.Looper
|
||||
import android.os.Message
|
||||
import android.os.Messenger
|
||||
import java.util.concurrent.CountDownLatch
|
||||
import java.util.concurrent.Executors
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
/**
|
||||
* Hands the main process's Xbox Cloud Gaming tokens to the native player's process (:xcloudnative) over Binder, so
|
||||
* they stay in memory (not exported, same app only) and a stream does not wait for a second ~20 s token fetch.
|
||||
*/
|
||||
class XboxCloudTokenService : Service() {
|
||||
private val worker = Executors.newSingleThreadExecutor()
|
||||
private val messenger = Messenger(Handler(Looper.getMainLooper()) { message ->
|
||||
val replyTo = message.replyTo ?: return@Handler true
|
||||
val account = message.data?.getString("account").orEmpty()
|
||||
worker.execute {
|
||||
val reply = Message.obtain(null, REPLY)
|
||||
reply.data = runCatching { XboxCloudSession.toBundle(XboxCloudSession.get(applicationContext, account)) }
|
||||
.getOrElse { Bundle().apply { putString("error", it.message ?: it.javaClass.simpleName) } }
|
||||
runCatching { replyTo.send(reply) }
|
||||
}
|
||||
true
|
||||
})
|
||||
|
||||
override fun onBind(intent: Intent?): IBinder = messenger.binder
|
||||
|
||||
override fun onDestroy() { worker.shutdown(); super.onDestroy() }
|
||||
|
||||
companion object {
|
||||
private const val REQUEST = 1
|
||||
private const val REPLY = 2
|
||||
|
||||
/** Blocks until the main process answers (its tokens, or "error"), or returns null when it cannot be reached. */
|
||||
fun request(context: Context, account: String, timeoutSeconds: Long): Bundle? {
|
||||
val app = context.applicationContext
|
||||
val done = CountDownLatch(1)
|
||||
var answer: Bundle? = null
|
||||
val thread = HandlerThread("xcloud-token").apply { start() }
|
||||
val replies = Messenger(Handler(thread.looper) { message ->
|
||||
if (message.what == REPLY) { answer = message.data; done.countDown() }
|
||||
true
|
||||
})
|
||||
val connection = object : ServiceConnection {
|
||||
override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
|
||||
val ask = Message.obtain(null, REQUEST).apply { data = Bundle().apply { putString("account", account) }; replyTo = replies }
|
||||
if (binder == null || runCatching { Messenger(binder).send(ask) }.isFailure) done.countDown()
|
||||
}
|
||||
override fun onServiceDisconnected(name: ComponentName?) { done.countDown() }
|
||||
}
|
||||
val bound = runCatching { app.bindService(Intent(app, XboxCloudTokenService::class.java), connection, Context.BIND_AUTO_CREATE) }
|
||||
.getOrDefault(false)
|
||||
try {
|
||||
if (!bound) return null
|
||||
done.await(timeoutSeconds, TimeUnit.SECONDS)
|
||||
return answer
|
||||
} finally {
|
||||
if (bound) runCatching { app.unbindService(connection) }
|
||||
thread.quitSafely()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -23,18 +23,19 @@ internal object XboxLibraryCache {
|
||||
fun clear(app: Context) { prefs(app).edit().remove("library").commit() }
|
||||
|
||||
internal fun encode(account: String, market: String, games: List<CatalogItem>, now: Long = System.currentTimeMillis()): String =
|
||||
JSONObject().put("schema", 1).put("account", account).put("market", market).put("savedAt", now)
|
||||
JSONObject().put("schema", 2).put("account", account).put("market", market).put("savedAt", now)
|
||||
.put("games", JSONArray().apply {
|
||||
for (game in games) put(JSONObject().put("id", game.id).put("title", game.title)
|
||||
.put("image", game.imageUrl).put("poster", game.tallImageUrl).put("description", game.description)
|
||||
.put("developer", game.developer).put("publisher", game.publisher).put("size", game.sizeBytes)
|
||||
.put("access", if (game.subscription) "gamepass" else if (game.owned) "owned" else "none"))
|
||||
.put("access", if (game.subscription) "gamepass" else if (game.owned) "owned" else "none")
|
||||
.put("pc", game.xboxPc).put("cloud", game.xboxCloud).put("cloudId", game.extra["cloudId"].orEmpty()))
|
||||
}).toString()
|
||||
|
||||
internal fun decode(text: String?, account: String, market: String, now: Long = System.currentTimeMillis()): Snapshot? = runCatching {
|
||||
require(text != null && text.length <= 8_000_000)
|
||||
val json = JSONObject(text)
|
||||
require(json.getInt("schema") == 1 && json.getString("account") == account && json.getString("market") == market)
|
||||
require(json.getInt("schema") == 2 && json.getString("account") == account && json.getString("market") == market)
|
||||
val savedAt = json.getLong("savedAt")
|
||||
require(savedAt > 0 && savedAt <= now + 60_000)
|
||||
val rows = json.getJSONArray("games")
|
||||
@@ -44,12 +45,14 @@ internal object XboxLibraryCache {
|
||||
val id = row.getString("id")
|
||||
val title = row.getString("title")
|
||||
val access = row.getString("access")
|
||||
val cloudId = row.optString("cloudId").takeIf { it.matches(Regex("[A-Z0-9]{12}")) }.orEmpty()
|
||||
require(id.matches(Regex("[A-Z0-9]{12}")) && title.isNotBlank() && access in setOf("owned", "gamepass"))
|
||||
CatalogItem(Store.XBOX, id, title, row.optString("image").takeIf { it.isNotEmpty() },
|
||||
tallImageUrl = row.optString("poster").takeIf { it.isNotEmpty() },
|
||||
description = row.optString("description"), developer = row.optString("developer"), publisher = row.optString("publisher"),
|
||||
sizeBytes = row.optLong("size"), owned = access == "owned", subscription = access == "gamepass",
|
||||
storeUrl = "https://www.xbox.com/games/store/$id", extra = mapOf("market" to market, "access" to access))
|
||||
storeUrl = "https://www.xbox.com/games/store/$id", extra = mapOf("market" to market, "access" to access,
|
||||
"pc" to XboxCatalog.flag(row.getBoolean("pc")), "cloud" to XboxCatalog.flag(row.getBoolean("cloud")), "cloudId" to cloudId))
|
||||
}
|
||||
require(games.map { it.id }.distinct().size == games.size)
|
||||
Snapshot(games, savedAt)
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.content.Context
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.setValue
|
||||
import com.droiddeck.launcher.stores.CatalogItem
|
||||
|
||||
object XboxLibraryFilter {
|
||||
const val ALL = "all"
|
||||
const val OWNED = "owned"
|
||||
const val GAME_PASS = "gamepass"
|
||||
const val CLOUD = "cloud"
|
||||
val ALL_FILTERS = listOf(ALL, OWNED, GAME_PASS, CLOUD)
|
||||
|
||||
var current by mutableStateOf(ALL)
|
||||
private set
|
||||
|
||||
fun load(context: Context) {
|
||||
current = context.getSharedPreferences("xbox", Context.MODE_PRIVATE).getString("libraryFilter", ALL)?.takeIf { it in ALL_FILTERS } ?: ALL
|
||||
}
|
||||
|
||||
fun set(context: Context, filter: String) {
|
||||
current = filter
|
||||
context.getSharedPreferences("xbox", Context.MODE_PRIVATE).edit().putString("libraryFilter", filter).apply()
|
||||
}
|
||||
|
||||
fun keeps(filter: String, item: CatalogItem): Boolean = when (filter) {
|
||||
OWNED -> item.owned
|
||||
GAME_PASS -> item.subscription
|
||||
CLOUD -> item.xboxCloud
|
||||
else -> true
|
||||
}
|
||||
|
||||
fun label(filter: String): String = when (filter) {
|
||||
OWNED -> "Owned"
|
||||
GAME_PASS -> "Game Pass"
|
||||
CLOUD -> "Cloud"
|
||||
else -> "All"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.view.InputDevice
|
||||
import android.view.KeyEvent
|
||||
import android.view.MotionEvent
|
||||
|
||||
/**
|
||||
* Controller state for the native cloud player, from Android key and motion events (no Gamepad API). Button
|
||||
* bits follow the xCloud input report (Greenlight's packet.ts): Nexus 2, Menu 4, View 8, A 16, B 32, X 64,
|
||||
* Y 128, D-pad 256..2048, shoulders 4096 / 8192, stick clicks 16384 / 32768.
|
||||
*/
|
||||
internal class XboxNativePad {
|
||||
data class State(val buttons: Int, val lx: Float, val ly: Float, val rx: Float, val ry: Float, val lt: Float, val rt: Float) {
|
||||
/** Greenlight's rule: any button change, a stick moved past 0.08 or held past 0.15, a trigger past 0.01. */
|
||||
fun differsFrom(o: State): Boolean = buttons != o.buttons ||
|
||||
listOf(lx to o.lx, ly to o.ly, rx to o.rx, ry to o.ry).any { (a, b) -> Math.abs(a - b) > 0.08f || Math.abs(a) > 0.15f } ||
|
||||
Math.abs(lt - o.lt) > 0.01f || Math.abs(rt - o.rt) > 0.01f
|
||||
}
|
||||
|
||||
@Volatile private var buttons = 0
|
||||
@Volatile private var hatButtons = 0
|
||||
@Volatile private var lx = 0f; @Volatile private var ly = 0f
|
||||
@Volatile private var rx = 0f; @Volatile private var ry = 0f
|
||||
@Volatile private var lt = 0f; @Volatile private var rt = 0f
|
||||
/** Called after any change (instant controller input). */
|
||||
@Volatile var onChanged: (() -> Unit)? = null
|
||||
|
||||
/** Buttons pressed on behalf of the app (the menu's Xbox button), OR-ed in. */
|
||||
@Volatile var overrideButtons = 0
|
||||
|
||||
fun snapshot() = State(buttons or hatButtons or overrideButtons, lx, ly, rx, ry, lt, rt)
|
||||
|
||||
/** True when the event was a controller button this pad tracks. */
|
||||
fun onKey(event: KeyEvent): Boolean {
|
||||
val bit = when (event.keyCode) {
|
||||
KeyEvent.KEYCODE_BUTTON_A -> 16
|
||||
KeyEvent.KEYCODE_BUTTON_B -> 32
|
||||
KeyEvent.KEYCODE_BUTTON_X -> 64
|
||||
KeyEvent.KEYCODE_BUTTON_Y -> 128
|
||||
KeyEvent.KEYCODE_DPAD_UP -> 256
|
||||
KeyEvent.KEYCODE_DPAD_DOWN -> 512
|
||||
KeyEvent.KEYCODE_DPAD_LEFT -> 1024
|
||||
KeyEvent.KEYCODE_DPAD_RIGHT -> 2048
|
||||
KeyEvent.KEYCODE_BUTTON_L1 -> 4096
|
||||
KeyEvent.KEYCODE_BUTTON_R1 -> 8192
|
||||
KeyEvent.KEYCODE_BUTTON_THUMBL -> 16384
|
||||
KeyEvent.KEYCODE_BUTTON_THUMBR -> 32768
|
||||
KeyEvent.KEYCODE_BUTTON_START -> 4
|
||||
KeyEvent.KEYCODE_BUTTON_SELECT -> 8
|
||||
// Digital triggers on pads without analog axes.
|
||||
KeyEvent.KEYCODE_BUTTON_L2 -> { lt = if (event.action == KeyEvent.ACTION_DOWN) 1f else 0f; onChanged?.invoke(); return true }
|
||||
KeyEvent.KEYCODE_BUTTON_R2 -> { rt = if (event.action == KeyEvent.ACTION_DOWN) 1f else 0f; onChanged?.invoke(); return true }
|
||||
else -> return false
|
||||
}
|
||||
buttons = if (event.action == KeyEvent.ACTION_DOWN) buttons or bit else buttons and bit.inv()
|
||||
onChanged?.invoke()
|
||||
return true
|
||||
}
|
||||
|
||||
/** True when the event came from a joystick (sticks, triggers, hat). */
|
||||
fun onMotion(event: MotionEvent): Boolean {
|
||||
if (event.source and InputDevice.SOURCE_JOYSTICK != InputDevice.SOURCE_JOYSTICK || event.action != MotionEvent.ACTION_MOVE) return false
|
||||
val device = event.device
|
||||
fun axis(code: Int): Float {
|
||||
val value = event.getAxisValue(code)
|
||||
val flat = device?.getMotionRange(code, event.source)?.flat ?: 0f
|
||||
return if (Math.abs(value) > maxOf(flat, 0.08f)) value else 0f
|
||||
}
|
||||
lx = axis(MotionEvent.AXIS_X); ly = axis(MotionEvent.AXIS_Y)
|
||||
rx = axis(MotionEvent.AXIS_Z); ry = axis(MotionEvent.AXIS_RZ)
|
||||
lt = maxOf(axis(MotionEvent.AXIS_LTRIGGER), axis(MotionEvent.AXIS_BRAKE))
|
||||
rt = maxOf(axis(MotionEvent.AXIS_RTRIGGER), axis(MotionEvent.AXIS_GAS))
|
||||
val hx = event.getAxisValue(MotionEvent.AXIS_HAT_X); val hy = event.getAxisValue(MotionEvent.AXIS_HAT_Y)
|
||||
hatButtons = (if (hy < -0.5f) 256 else 0) or (if (hy > 0.5f) 512 else 0) or (if (hx < -0.5f) 1024 else 0) or (if (hx > 0.5f) 2048 else 0)
|
||||
onChanged?.invoke()
|
||||
return true
|
||||
}
|
||||
|
||||
fun reset() { buttons = 0; hatButtons = 0; overrideButtons = 0; lx = 0f; ly = 0f; rx = 0f; ry = 0f; lt = 0f; rt = 0f }
|
||||
}
|
||||
@@ -0,0 +1,852 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.graphics.Color
|
||||
import android.os.Build
|
||||
import android.os.Bundle
|
||||
import android.os.VibrationEffect
|
||||
import android.view.Gravity
|
||||
import android.view.KeyEvent
|
||||
import android.view.MotionEvent
|
||||
import android.view.SurfaceHolder
|
||||
import android.view.SurfaceView
|
||||
import android.view.WindowManager
|
||||
import android.widget.FrameLayout
|
||||
import android.widget.TextView
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.layout.fillMaxHeight
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.width
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.focus.focusRequester
|
||||
import androidx.compose.ui.input.key.Key
|
||||
import androidx.compose.ui.input.key.KeyEventType
|
||||
import androidx.compose.ui.input.key.key
|
||||
import androidx.compose.ui.input.key.onKeyEvent
|
||||
import androidx.compose.ui.input.key.type
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.core.view.WindowCompat
|
||||
import androidx.core.view.WindowInsetsCompat
|
||||
import androidx.core.view.WindowInsetsControllerCompat
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import org.webrtc.DataChannel
|
||||
import org.webrtc.DefaultVideoEncoderFactory
|
||||
import org.webrtc.EglBase
|
||||
import org.webrtc.IceCandidate
|
||||
import org.webrtc.MediaConstraints
|
||||
import org.webrtc.MediaStream
|
||||
import org.webrtc.MediaStreamTrack
|
||||
import org.webrtc.PeerConnection
|
||||
import org.webrtc.PeerConnectionFactory
|
||||
import org.webrtc.RtpReceiver
|
||||
import org.webrtc.RtpTransceiver
|
||||
import org.webrtc.SdpObserver
|
||||
import org.webrtc.SessionDescription
|
||||
import org.webrtc.VideoTrack
|
||||
import org.webrtc.audio.JavaAudioDeviceModule
|
||||
import java.util.concurrent.CountDownLatch
|
||||
import java.util.concurrent.Executors
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
/**
|
||||
* Native Xbox Cloud Gaming player (opt-in, Android 10+): Google's WebRTC library instead of the web page, the
|
||||
* xCloud channels ported from Greenlight (XboxNativeProtocol), controller from Android input events, and the
|
||||
* picture through DroidDeck's own compositor (XboxNativeVideo) so DDFG or LSFG can generate frames. Runs in
|
||||
* its own process (:xcloudnative): that compositor instance is never the Linux session's.
|
||||
* Sign-in and session requests are the web player's (XboxCloudSession, XboxCloudSignalling).
|
||||
*/
|
||||
class XboxNativePlayerActivity : ComponentActivity() {
|
||||
private lateinit var root: FrameLayout
|
||||
private lateinit var surfaceView: SurfaceView
|
||||
private lateinit var status: TextView
|
||||
private lateinit var overlay: TextView
|
||||
private val worker = Executors.newSingleThreadExecutor()
|
||||
private val ticker = Executors.newSingleThreadScheduledExecutor()
|
||||
private val pad = XboxNativePad()
|
||||
private var eglBase: EglBase? = null
|
||||
private var factory: PeerConnectionFactory? = null
|
||||
private var pc: PeerConnection? = null
|
||||
private var protocol: XboxNativeProtocol? = null
|
||||
private var video: XboxNativeVideo? = null
|
||||
@Volatile private var signalling: XboxCloudSignalling? = null
|
||||
@Volatile private var settings = XboxCloudSettings()
|
||||
@Volatile private var closed = false
|
||||
/** The stream reached the screen at least once (a later failure is a lost connection, not a failed start). */
|
||||
@Volatile private var connectedOnce = false
|
||||
/** The session was ended because the player stayed in the background (Android freezes the app soon after). */
|
||||
@Volatile private var endedInBackground = false
|
||||
private var backgroundEnd: Runnable? = null
|
||||
private var notice: androidx.compose.ui.platform.ComposeView? = null
|
||||
@Volatile private var regionNames = emptyList<String>()
|
||||
@Volatile private var serverName: String? = null
|
||||
private val candidates = mutableListOf<IceCandidate>()
|
||||
private val gathered = CountDownLatch(1)
|
||||
private var menu: androidx.compose.ui.platform.ComposeView? = null
|
||||
private var menuPage by androidx.compose.runtime.mutableStateOf("")
|
||||
private var lastMainEntry = 0
|
||||
private val lastRow = mutableMapOf<String, Int>()
|
||||
/** The settings this stream started with (stream-start settings changed since then need a restart). */
|
||||
private var startedWith: XboxCloudSettings? = null
|
||||
/**
|
||||
* The picture's route right now: true = zero-copy (decoder straight onto the screen), false = WebRTC's texture
|
||||
* through the Vulkan compositor. Zero-copy whenever it is chosen and frame generation is off; switched live.
|
||||
*/
|
||||
@Volatile private var zeroCopy = false
|
||||
/** The SurfaceView's surface while it exists (UI thread). */
|
||||
private var screen: android.view.Surface? = null
|
||||
private var screenW = 0
|
||||
private var screenH = 0
|
||||
@Volatile private var zeroCopyFrames = 0L
|
||||
@Volatile private var decoders: org.webrtc.DroidDeckLowLatencyDecoderFactory? = null
|
||||
private var lastZeroCopyFrames = 0L
|
||||
private var lastSubmitted = 0L
|
||||
/** The release of the Guide press that opened the menu must not close it again. */
|
||||
private var swallowGuideUp = false
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
|
||||
hideBars()
|
||||
watchBars()
|
||||
root = FrameLayout(this).apply { setBackgroundColor(Color.BLACK) }
|
||||
surfaceView = SurfaceView(this)
|
||||
root.addView(surfaceView, FrameLayout.LayoutParams(-1, -1))
|
||||
status = TextView(this).apply { setTextColor(Color.WHITE); textSize = 16f; gravity = Gravity.CENTER }
|
||||
root.addView(status, FrameLayout.LayoutParams(-1, -2, Gravity.BOTTOM).apply { bottomMargin = 120 })
|
||||
overlay = TextView(this).apply {
|
||||
setTextColor(Color.WHITE); textSize = 12f; typeface = android.graphics.Typeface.MONOSPACE
|
||||
setBackgroundColor(Color.argb(140, 0, 0, 0)); setPadding(12, 6, 12, 6); visibility = android.view.View.GONE
|
||||
}
|
||||
root.addView(overlay, FrameLayout.LayoutParams(-2, -2, Gravity.TOP or Gravity.END).apply { topMargin = 16; rightMargin = 16 })
|
||||
setContentView(root)
|
||||
settings = XboxCloudSettings.load(this)
|
||||
startedWith = settings
|
||||
applyDisplayRate(settings.fpsTarget)
|
||||
applyOverlay()
|
||||
|
||||
val egl = EglBase.create().also { eglBase = it }
|
||||
val nativeVideo = XboxNativeVideo(this, egl) { log(it) }.also { video = it }
|
||||
surfaceView.holder.addCallback(object : SurfaceHolder.Callback {
|
||||
override fun surfaceCreated(holder: SurfaceHolder) {}
|
||||
override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
|
||||
screen = holder.surface; screenW = width; screenH = height
|
||||
// Zero-copy: the decoder owns this surface (back on it after a stand-in); the Vulkan compositor must not connect to it.
|
||||
if (zeroCopy) { decoders?.setZeroCopySurface(holder.surface); return }
|
||||
@Suppress("DEPRECATION")
|
||||
nativeVideo.setSurface(holder.surface, width, height, windowManager.defaultDisplay.refreshRate)
|
||||
}
|
||||
override fun surfaceDestroyed(holder: SurfaceHolder) {
|
||||
screen = null
|
||||
if (zeroCopy) decoders?.setZeroCopySurface(null) else nativeVideo.setSurface(null, 0, 0, 60f)
|
||||
}
|
||||
})
|
||||
show("Signing in to Xbox Cloud Gaming…")
|
||||
worker.execute { runCatching { run() }.onFailure { fail("start", it.message ?: it.javaClass.simpleName) } }
|
||||
}
|
||||
|
||||
private fun log(text: String) = com.droiddeck.launcher.stores.StoresState.logLine("Xbox: native player: ${text.take(240)}")
|
||||
private fun show(text: String) = runOnUiThread { status.text = text; status.visibility = if (text.isEmpty()) android.view.View.GONE else android.view.View.VISIBLE }
|
||||
|
||||
private fun fail(stage: String, detail: String) {
|
||||
log("failed at $stage: $detail")
|
||||
if (closed) return
|
||||
if (connectedOnce) showNotice("The connection to the cloud console was lost",
|
||||
"The stream stopped reaching this device ($detail). Restart the stream to play again: the game starts over, " +
|
||||
"unsaved progress is lost.", webPlayer = false)
|
||||
else showNotice("The native stream could not start ($stage)",
|
||||
"$detail\n\nYou can try again, or use the web player instead (Stores › Xbox › Cloud settings › Player engine).",
|
||||
webPlayer = true)
|
||||
}
|
||||
|
||||
/** One popup at a time, in the app's dialog style; A or Enter picks the selected button, Back closes the player. */
|
||||
private fun showNotice(title: String, text: String, webPlayer: Boolean) = runOnUiThread {
|
||||
if (notice != null || isFinishing || isDestroyed) return@runOnUiThread
|
||||
closeMenu()
|
||||
show("")
|
||||
// The stream is over: stale numbers must not stay on screen.
|
||||
overlayOn = false
|
||||
overlay.visibility = android.view.View.GONE
|
||||
val view = androidx.compose.ui.platform.ComposeView(this)
|
||||
view.setContent {
|
||||
com.droiddeck.launcher.ui.DroidDeckTheme {
|
||||
val first = androidx.compose.runtime.remember { androidx.compose.ui.focus.FocusRequester() }
|
||||
androidx.compose.runtime.LaunchedEffect(Unit) { androidx.compose.runtime.withFrameNanos { }; runCatching { first.requestFocus() } }
|
||||
@androidx.compose.runtime.Composable
|
||||
fun NoticeButton(label: String, focus: androidx.compose.ui.focus.FocusRequester?, onClick: () -> Unit) =
|
||||
androidx.compose.material3.TextButton(onClick = onClick,
|
||||
modifier = androidx.compose.ui.Modifier.let { if (focus != null) it.focusRequester(focus) else it }
|
||||
.onKeyEvent { e -> if (e.type == KeyEventType.KeyDown && e.key == Key.ButtonA) { onClick(); true } else false }) {
|
||||
androidx.compose.material3.Text(label)
|
||||
}
|
||||
androidx.compose.material3.AlertDialog(
|
||||
onDismissRequest = { finish() },
|
||||
properties = androidx.compose.ui.window.DialogProperties(dismissOnClickOutside = false),
|
||||
title = { androidx.compose.material3.Text(title) },
|
||||
text = { androidx.compose.material3.Text(text) },
|
||||
confirmButton = {
|
||||
androidx.compose.foundation.layout.Row {
|
||||
NoticeButton(if (connectedOnce) "Restart the stream" else "Try again", first) { restartStream() }
|
||||
if (webPlayer) NoticeButton("Open the web player", null) {
|
||||
startActivity(Intent(this@XboxNativePlayerActivity, XboxCloudPlayerActivity::class.java).putExtras(intent)); finish()
|
||||
}
|
||||
}
|
||||
},
|
||||
dismissButton = { NoticeButton("Close", null) { finish() } },
|
||||
)
|
||||
}
|
||||
}
|
||||
notice = view
|
||||
root.addView(view, FrameLayout.LayoutParams(-1, -1))
|
||||
}
|
||||
|
||||
// ---- background ----
|
||||
|
||||
override fun onStop() {
|
||||
super.onStop()
|
||||
if (closed || isChangingConfigurations || signalling == null || endedInBackground) return
|
||||
// Android freezes a background app about a minute after it leaves the screen; the connection then dies
|
||||
// without a goodbye. End the session cleanly before that and offer a restart on return.
|
||||
log("in the background")
|
||||
val end = Runnable { backgroundEnd = null; endInBackground() }
|
||||
backgroundEnd = end
|
||||
root.postDelayed(end, BACKGROUND_GRACE_MS)
|
||||
}
|
||||
|
||||
override fun onStart() {
|
||||
super.onStart()
|
||||
backgroundEnd?.let { root.removeCallbacks(it); log("back before the stream was ended") }
|
||||
backgroundEnd = null
|
||||
if (endedInBackground && notice == null) showNotice("The stream ended while DroidDeck was in the background",
|
||||
"Cloud sessions are closed after ${BACKGROUND_GRACE_MS / 1000} s away, before Android pauses the app. Restart the " +
|
||||
"stream to play again: the game starts over, unsaved progress is lost.", webPlayer = false)
|
||||
}
|
||||
|
||||
private fun endInBackground() {
|
||||
if (closed || endedInBackground) return
|
||||
endedInBackground = true
|
||||
closed = true
|
||||
log("ending the session: ${BACKGROUND_GRACE_MS / 1000} s in the background")
|
||||
val signals = signalling
|
||||
signalling = null
|
||||
ticker.shutdownNow()
|
||||
runOnUiThread { overlayOn = false; overlay.visibility = android.view.View.GONE }
|
||||
Thread({ signals?.stop()?.let { log("session closed: ${it.status}") } }, "xcloud-native-stop").start()
|
||||
runCatching { protocol?.close() }
|
||||
runCatching { pc?.close() }
|
||||
}
|
||||
|
||||
// ---- session ----
|
||||
|
||||
private fun run() {
|
||||
val account = com.droiddeck.launcher.stores.StoreAccounts.signedInAs(applicationContext, com.droiddeck.launcher.stores.Store.XBOX)
|
||||
?: error("Sign in to the Xbox store first.")
|
||||
val requested = intent.getStringExtra("product").orEmpty()
|
||||
val cached = XboxLibraryCache.read(applicationContext, account, Xodus.market())?.games?.firstOrNull { it.id == requested }
|
||||
val product = cached?.extra?.get("cloudId")?.takeIf { it.isNotEmpty() } ?: requested
|
||||
// The main process's tokens when it has them (no second ~20 s fetch); else this process fetches its own.
|
||||
val shared = runCatching { XboxCloudSession.fromMainProcess(applicationContext, account) }
|
||||
.onFailure { log("tokens from the main process: ${it.message?.take(160)}") }.getOrNull()
|
||||
log(if (shared != null) "tokens from the main process" else "tokens fetched here")
|
||||
val active = (shared ?: XboxCloudSession.get(applicationContext, account)).forStream(settings.region, settings.osName)
|
||||
regionNames = active.regionList.map { it.name }
|
||||
serverName = active.regionList.firstOrNull { it.baseUri == active.baseUri }?.name
|
||||
val title = XboxCloudSession.titles(active)[product] ?: error("This game can't be streamed with this account here.")
|
||||
val signals = XboxCloudSignalling(active, title, settings).also { signalling = it }
|
||||
log("$product -> $title, region ${java.net.URI(active.baseUri).host}, frame gen ${settings.frameGen}")
|
||||
|
||||
show("Starting the game on Xbox Cloud Gaming…")
|
||||
expect("start", signals.start())
|
||||
var connected = false
|
||||
var waited = 0
|
||||
while (!closed) {
|
||||
val state = JSONObject(expect("state", signals.op("state")).body.ifEmpty { "{}" })
|
||||
when (state.optString("state")) {
|
||||
"Provisioned" -> break
|
||||
"Failed" -> error("provision: ${state.optJSONObject("errorDetails")}")
|
||||
"ReadyToConnect" -> if (!connected) { connected = true; show("Signing in to the cloud console…"); expect("connect", signals.connect()) }
|
||||
"WaitingForResources" -> show("In the queue for a cloud console… ${waited / 1000} s")
|
||||
else -> show("Getting a cloud console ready… ${waited / 1000} s")
|
||||
}
|
||||
Thread.sleep(1000); waited += 1000
|
||||
}
|
||||
if (closed) return
|
||||
|
||||
show("Connecting…")
|
||||
// Small network buffer: no playout delay, frames go to the decoder and screen as soon as they are complete.
|
||||
val trials = if (settings.smallBuffer) "WebRTC-ForcePlayoutDelay/min_ms:0,max_ms:0/WebRTC-ZeroPlayoutDelay/min_pacing:0ms,max_decode_queue_size:8/" else ""
|
||||
PeerConnectionFactory.initialize(PeerConnectionFactory.InitializationOptions.builder(applicationContext)
|
||||
.setFieldTrials(trials).createInitializationOptions())
|
||||
val egl = eglBase!!
|
||||
val zeroSurface = if (zeroCopyWanted(settings)) {
|
||||
repeat(40) { if (!surfaceView.holder.surface.isValid) Thread.sleep(50) }
|
||||
surfaceView.holder.surface.takeIf { it.isValid }
|
||||
} else null
|
||||
if (zeroSurface != null) {
|
||||
// The compositor may already hold the screen; it must let go before the decoder takes it.
|
||||
val ready = CountDownLatch(1)
|
||||
runOnUiThread { zeroCopy = true; video?.setSurface(null, 0, 0, 60f); ready.countDown() }
|
||||
ready.await(2, TimeUnit.SECONDS)
|
||||
}
|
||||
log("latency: instant input ${settings.instantInput}, small buffer ${settings.smallBuffer}, fast decoder ${settings.fastDecoder}, " +
|
||||
"zero-copy ${zeroSurface != null}")
|
||||
val f = PeerConnectionFactory.builder()
|
||||
.setAudioDeviceModule(JavaAudioDeviceModule.builder(applicationContext).createAudioDeviceModule())
|
||||
.setVideoDecoderFactory(org.webrtc.DroidDeckLowLatencyDecoderFactory(egl.eglBaseContext, settings.fastDecoder, zeroSurface) { zeroCopyFrames++ }
|
||||
.also { decoders = it })
|
||||
.setVideoEncoderFactory(DefaultVideoEncoderFactory(egl.eglBaseContext, true, true))
|
||||
.createPeerConnectionFactory().also { factory = it }
|
||||
val config = PeerConnection.RTCConfiguration(emptyList()).apply { sdpSemantics = PeerConnection.SdpSemantics.UNIFIED_PLAN }
|
||||
val peer = f.createPeerConnection(config, observer) ?: error("WebRTC unavailable")
|
||||
pc = peer
|
||||
peer.addTransceiver(MediaStreamTrack.MediaType.MEDIA_TYPE_AUDIO, RtpTransceiver.RtpTransceiverInit(RtpTransceiver.RtpTransceiverDirection.SEND_RECV))
|
||||
peer.addTransceiver(MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO, RtpTransceiver.RtpTransceiverInit(RtpTransceiver.RtpTransceiverDirection.RECV_ONLY))
|
||||
protocol = XboxNativeProtocol(peer, pad, { log(it) }, ::rumble) { runOnUiThread { finish() } }
|
||||
pad.onChanged = { if (settings.instantInput) protocol?.inputChanged() }
|
||||
|
||||
val offer = await<SessionDescription> { done -> peer.createOffer(sdpObserver(done), MediaConstraints()) }
|
||||
val local = SessionDescription(offer.type, tweakOffer(offer.description))
|
||||
await<Unit> { done -> peer.setLocalDescription(sdpObserver(done), local) }
|
||||
val sdpReply = expect("sdp", signals.sdp(local.description))
|
||||
val answer = JSONObject(JSONObject(sdpReply.body).getString("exchangeResponse"))
|
||||
if (answer.has("status") && answer.optString("status") != "success") error("sdp answer: $answer")
|
||||
await<Unit> { done -> peer.setRemoteDescription(sdpObserver(done), SessionDescription(SessionDescription.Type.ANSWER, answer.getString("sdp"))) }
|
||||
|
||||
gathered.await(3, TimeUnit.SECONDS)
|
||||
val local2 = synchronized(candidates) { candidates.toList() }.map { c ->
|
||||
JSONObject().put("candidate", c.sdp).put("sdpMid", c.sdpMid).put("sdpMLineIndex", c.sdpMLineIndex).put("usernameFragment", JSONObject.NULL).toString()
|
||||
}
|
||||
val iceReply = expect("ice", signals.ice(JSONArray(local2).toString()))
|
||||
val remote = JSONArray(JSONObject(iceReply.body).getString("exchangeResponse"))
|
||||
for (i in 0 until remote.length()) addRemoteCandidate(peer, remote.getJSONObject(i))
|
||||
log("signalling done: ${local2.size} local / ${remote.length()} remote candidates")
|
||||
ticker.scheduleWithFixedDelay({ runCatching { signals.op("keepalive") } }, 30, 30, TimeUnit.SECONDS)
|
||||
ticker.scheduleWithFixedDelay({ runCatching { updateOverlay() } }, 1, 1, TimeUnit.SECONDS)
|
||||
}
|
||||
|
||||
private fun expect(stage: String, reply: XboxCloudSession.Reply): XboxCloudSession.Reply {
|
||||
if (reply.status !in 200..299) error("$stage: ${reply.status} ${reply.body.take(200)}")
|
||||
return reply
|
||||
}
|
||||
|
||||
/** Opus stereo (Greenlight), H.264 profile order (Main first unless the user picked one) and the bitrate cap. */
|
||||
private fun tweakOffer(sdp: String): String {
|
||||
var out = sdp.replace("useinbandfec=1", "useinbandfec=1; stereo=1")
|
||||
val prefix = when (settings.codec) { "low" -> "420"; "normal" -> "42e"; else -> "4d" }
|
||||
val ids = Regex("a=fmtp:(\\d+).*profile-level-id=([0-9a-f]{6})").findAll(out).filter { it.groupValues[2].startsWith(prefix) }.map { it.groupValues[1] }.toList()
|
||||
if (ids.isNotEmpty()) out = out.split("\r\n").joinToString("\r\n") { line ->
|
||||
if (!line.startsWith("m=video")) line else {
|
||||
val parts = line.trim().split(" ")
|
||||
(parts.take(3) + ids + parts.drop(3).filter { it !in ids }).joinToString(" ")
|
||||
}
|
||||
}
|
||||
if (settings.bitrateMbps > 0) {
|
||||
val lines = out.split("\r\n").toMutableList()
|
||||
val start = lines.indexOfFirst { it.startsWith("m=video") }
|
||||
if (start >= 0) {
|
||||
var i = start + 1
|
||||
while (i < lines.size && (lines[i].startsWith("i=") || lines[i].startsWith("c="))) i++
|
||||
if (i < lines.size && lines[i].startsWith("b=AS:")) lines[i] = "b=AS:${settings.bitrateMbps * 1000}" else lines.add(i, "b=AS:${settings.bitrateMbps * 1000}")
|
||||
out = lines.joinToString("\r\n")
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
/** The server's candidates, plus the IPv4 behind a Teredo address (Greenlight's ice.ts / teredo.ts). */
|
||||
private fun addRemoteCandidate(peer: PeerConnection, c: JSONObject) {
|
||||
val line = c.optString("candidate").removePrefix("a=")
|
||||
if (line.isEmpty() || line == "end-of-candidates") return
|
||||
val mid = c.optString("sdpMid", "0"); val index = c.optString("sdpMLineIndex", "0").toIntOrNull() ?: 0
|
||||
val address = line.split(" ").getOrNull(4).orEmpty()
|
||||
if (address.startsWith("2001")) runCatching {
|
||||
val p = address.split(":")
|
||||
val hex = p[6].padStart(4, '0') + p[7].padStart(4, '0')
|
||||
val ip = (0 until 4).joinToString(".") { k -> ((hex.substring(k * 2, k * 2 + 2).toInt(16)).inv() and 0xFF).toString() }
|
||||
val port = p[5].toInt(16).inv() and 0xFFFF
|
||||
peer.addIceCandidate(IceCandidate(mid, index, "candidate:10 1 UDP 1 $ip 9002 typ host "))
|
||||
peer.addIceCandidate(IceCandidate(mid, index, "candidate:11 1 UDP 1 $ip $port typ host "))
|
||||
}
|
||||
peer.addIceCandidate(IceCandidate(mid, index, line))
|
||||
}
|
||||
|
||||
private val observer = object : PeerConnection.Observer {
|
||||
override fun onSignalingChange(state: PeerConnection.SignalingState) {}
|
||||
override fun onIceConnectionChange(state: PeerConnection.IceConnectionState) { log("ice $state") }
|
||||
override fun onIceConnectionReceivingChange(receiving: Boolean) {}
|
||||
override fun onIceGatheringChange(state: PeerConnection.IceGatheringState) { if (state == PeerConnection.IceGatheringState.COMPLETE) gathered.countDown() }
|
||||
override fun onIceCandidate(candidate: IceCandidate) { synchronized(candidates) { candidates.add(candidate) } }
|
||||
override fun onIceCandidatesRemoved(removed: Array<out IceCandidate>) {}
|
||||
override fun onAddStream(stream: MediaStream) {}
|
||||
override fun onRemoveStream(stream: MediaStream) {}
|
||||
override fun onDataChannel(channel: DataChannel) {}
|
||||
override fun onRenegotiationNeeded() {}
|
||||
override fun onAddTrack(receiver: RtpReceiver, streams: Array<out MediaStream>) { attach(receiver) }
|
||||
override fun onTrack(transceiver: RtpTransceiver) { attach(transceiver.receiver) }
|
||||
override fun onConnectionChange(state: PeerConnection.PeerConnectionState) {
|
||||
log("connection $state")
|
||||
when (state) {
|
||||
PeerConnection.PeerConnectionState.CONNECTED -> {
|
||||
connectedOnce = true
|
||||
show("")
|
||||
video?.setFpsTarget(settings.fpsTarget)
|
||||
video?.setFrameGeneration(effectiveFrameGen())
|
||||
}
|
||||
PeerConnection.PeerConnectionState.FAILED -> fail("webrtc", "connection failed")
|
||||
PeerConnection.PeerConnectionState.DISCONNECTED -> show("Connection lost…")
|
||||
else -> {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private var videoAttached = false
|
||||
|
||||
private fun attach(receiver: RtpReceiver) = synchronized(this) {
|
||||
val track = receiver.track()
|
||||
// Always attached: in zero-copy WebRTC delivers no frames, and after a live switch back they flow again.
|
||||
if (track is VideoTrack && !videoAttached) { videoAttached = true; video?.let { track.addSink(it) }; log("video track") }
|
||||
}
|
||||
|
||||
/** LSFG needs the Lossless.dll and its shader cache built; otherwise DDFG. */
|
||||
private fun effectiveFrameGen(): String {
|
||||
if (!XboxNativeVideo.isLsfg(settings.frameGen)) return settings.frameGen
|
||||
val status = com.droiddeck.launcher.gpu.Lossless.sync(applicationContext)
|
||||
if (status == 0) return settings.frameGen
|
||||
log("LSFG unavailable (status $status), using DDFG")
|
||||
return XboxNativeVideo.FG_DDFG
|
||||
}
|
||||
|
||||
private fun <T> await(start: (done: (Result<T>) -> Unit) -> Unit): T {
|
||||
val latch = CountDownLatch(1)
|
||||
var result: Result<T>? = null
|
||||
start { r -> result = r; latch.countDown() }
|
||||
check(latch.await(15, TimeUnit.SECONDS)) { "WebRTC timed out" }
|
||||
return result!!.getOrThrow()
|
||||
}
|
||||
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
private fun <T> sdpObserver(done: (Result<T>) -> Unit) = object : SdpObserver {
|
||||
override fun onCreateSuccess(description: SessionDescription) = done(Result.success(description as T))
|
||||
override fun onSetSuccess() = done(Result.success(Unit as T))
|
||||
override fun onCreateFailure(error: String) = done(Result.failure(IllegalStateException(error)))
|
||||
override fun onSetFailure(error: String) = done(Result.failure(IllegalStateException(error)))
|
||||
}
|
||||
|
||||
// ---- input, rumble, overlay ----
|
||||
|
||||
private var guideDown = false
|
||||
private var guideDownAt = 0L
|
||||
private var lastGuideUp = 0L
|
||||
private var pendingNexus: Runnable? = null
|
||||
private fun isGuide(event: KeyEvent) = event.keyCode == KeyEvent.KEYCODE_BUTTON_MODE
|
||||
|
||||
private fun pressNexus() {
|
||||
pad.overrideButtons = pad.overrideButtons or 2
|
||||
root.postDelayed({ pad.overrideButtons = pad.overrideButtons and 2.inv() }, 200)
|
||||
}
|
||||
|
||||
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
|
||||
if (menu != null) {
|
||||
// Guide closes the menu; Back goes up one page, then closes it.
|
||||
if (isGuide(event)) { if (event.action == KeyEvent.ACTION_UP) { if (swallowGuideUp) swallowGuideUp = false else closeMenu() }; return true }
|
||||
if (event.keyCode == KeyEvent.KEYCODE_BACK) {
|
||||
if (event.action == KeyEvent.ACTION_UP) { if (menuPage.isNotEmpty()) menuPage = "" else closeMenu() }
|
||||
return true
|
||||
}
|
||||
return super.dispatchKeyEvent(event)
|
||||
}
|
||||
// Guide / the Input Controls menu button: once = the Xbox button, twice or held = the player menu.
|
||||
if (isGuide(event)) {
|
||||
if (event.action == KeyEvent.ACTION_DOWN && event.repeatCount == 0) {
|
||||
val pending = pendingNexus
|
||||
if (pending != null && event.eventTime - lastGuideUp <= 350) { root.removeCallbacks(pending); pendingNexus = null; swallowGuideUp = true; openMenu() }
|
||||
else { guideDown = true; guideDownAt = event.eventTime }
|
||||
} else if (event.action == KeyEvent.ACTION_DOWN && guideDown && event.eventTime - guideDownAt >= 600) {
|
||||
guideDown = false; swallowGuideUp = true; openMenu()
|
||||
} else if (event.action == KeyEvent.ACTION_UP && guideDown) {
|
||||
guideDown = false; lastGuideUp = event.eventTime
|
||||
val tap = Runnable { pendingNexus = null; pressNexus() }
|
||||
pendingNexus = tap; root.postDelayed(tap, 350)
|
||||
}
|
||||
return true
|
||||
}
|
||||
if (event.keyCode == KeyEvent.KEYCODE_BACK) { if (event.action == KeyEvent.ACTION_UP) openMenu(); return true }
|
||||
if (pad.onKey(event)) return true
|
||||
return super.dispatchKeyEvent(event)
|
||||
}
|
||||
|
||||
// With the menu open, sticks and the hat go to Android unhandled, which turns them into D-pad keys for the menu.
|
||||
override fun dispatchGenericMotionEvent(event: MotionEvent): Boolean =
|
||||
(menu == null && pad.onMotion(event)) || super.dispatchGenericMotionEvent(event)
|
||||
|
||||
private fun rumble(strong: Float, weak: Float, durationMs: Int) {
|
||||
val scale = settings.rumble / 100f
|
||||
val amplitude = (maxOf(strong, weak) * scale * 255).toInt().coerceIn(0, 255)
|
||||
if (amplitude == 0 || durationMs <= 0) return
|
||||
val vibrator = (if (Build.VERSION.SDK_INT >= 31) getSystemService(android.os.VibratorManager::class.java)?.defaultVibrator
|
||||
else @Suppress("DEPRECATION") getSystemService(android.os.Vibrator::class.java)) ?: return
|
||||
runCatching { vibrator.vibrate(VibrationEffect.createOneShot(durationMs.coerceAtMost(1000).toLong(), amplitude)) }
|
||||
}
|
||||
|
||||
/** The overlay is remembered with the other cloud settings (on = overlay level above 0). */
|
||||
@Volatile private var overlayOn = false
|
||||
|
||||
private var lastJitterDelay = 0.0
|
||||
private var lastJitterCount = 0.0
|
||||
private var lastDecodeTime = 0.0
|
||||
private var lastDecoded = 0.0
|
||||
private var lastBytes = 0.0
|
||||
private var lastStatsMs = 0.0
|
||||
private var lastLost = 0.0
|
||||
private var lastReceived = 0.0
|
||||
|
||||
/**
|
||||
* The overlay, at the web player's levels and layout (settings statsLevel / statsLayout): 1 fps and frame
|
||||
* generation base -> shown; 2 + resolution, ping; 3 + bitrate, jitter buffer, decode time, packet loss; 4 + frame
|
||||
* generation's added delay, the estimated picture delay (one-way network + buffer + decode + frame generation +
|
||||
* one screen refresh), codec and server.
|
||||
*/
|
||||
private fun updateOverlay() {
|
||||
val level = settings.statsLevel
|
||||
if (!overlayOn || level <= 0) return
|
||||
val peer = pc ?: return
|
||||
peer.getStats { report ->
|
||||
var size = ""; var fps = 0; var codec = ""
|
||||
var rttMs = -1.0; var bufferMs = 0.0; var decodeMs = 0.0; var mbps = 0.0; var loss = 0.0
|
||||
val codecs = HashMap<String, String>()
|
||||
report.statsMap.values.forEach { s -> if (s.type == "codec") codecs[s.id] = (s.members["mimeType"] as? String).orEmpty().removePrefix("video/") }
|
||||
report.statsMap.values.forEach { s ->
|
||||
val m = s.members
|
||||
if (s.type == "inbound-rtp" && m["kind"] == "video") {
|
||||
size = "${m["frameWidth"]}x${m["frameHeight"]}"
|
||||
fps = (m["framesPerSecond"] as? Number)?.toInt() ?: 0
|
||||
codec = codecs[m["codecId"] as? String].orEmpty()
|
||||
val jd = (m["jitterBufferDelay"] as? Number)?.toDouble() ?: 0.0
|
||||
val jc = (m["jitterBufferEmittedCount"] as? Number)?.toDouble() ?: 0.0
|
||||
if (jc > lastJitterCount) bufferMs = (jd - lastJitterDelay) * 1000 / (jc - lastJitterCount)
|
||||
lastJitterDelay = jd; lastJitterCount = jc
|
||||
val dt = (m["totalDecodeTime"] as? Number)?.toDouble() ?: 0.0
|
||||
val df = (m["framesDecoded"] as? Number)?.toDouble() ?: 0.0
|
||||
if (df > lastDecoded) decodeMs = (dt - lastDecodeTime) * 1000 / (df - lastDecoded)
|
||||
lastDecodeTime = dt; lastDecoded = df
|
||||
val bytes = (m["bytesReceived"] as? Number)?.toDouble() ?: 0.0
|
||||
val now = s.timestampUs / 1000.0
|
||||
if (lastStatsMs > 0 && now > lastStatsMs) mbps = (bytes - lastBytes) * 8 / ((now - lastStatsMs) * 1000)
|
||||
lastBytes = bytes; lastStatsMs = now
|
||||
val lost = (m["packetsLost"] as? Number)?.toDouble() ?: 0.0
|
||||
val received = (m["packetsReceived"] as? Number)?.toDouble() ?: 0.0
|
||||
val dl = lost - lastLost; val dr = received - lastReceived
|
||||
if (dl + dr > 0) loss = dl * 100 / (dl + dr)
|
||||
lastLost = lost; lastReceived = received
|
||||
} else if (s.type == "candidate-pair" && m["state"] == "succeeded" && m["nominated"] == true) {
|
||||
(m["currentRoundTripTime"] as? Number)?.toDouble()?.let { rttMs = it * 1000 }
|
||||
}
|
||||
}
|
||||
// Zero-copy: WebRTC never sees a decoded frame, so size and decode time come from the decoder itself.
|
||||
if (zeroCopy) decoders?.let { d ->
|
||||
d.videoSize()?.let { size = it }
|
||||
val ms = d.takeDecodeMs()
|
||||
if (ms >= 0) decodeMs = ms
|
||||
}
|
||||
val fg = video?.stats()
|
||||
val fgOn = fg != null && settings.frameGen != XboxNativeVideo.FG_OFF && fg[2] > 1f
|
||||
val fgWaitMs = if (fgOn) 1000.0 / fg!![2] else 0.0
|
||||
val fgGpuMs = if (fgOn && fg!![5] > 0f) fg[5].toDouble() else 0.0
|
||||
@Suppress("DEPRECATION") val refreshMs = 1000.0 / windowManager.defaultDisplay.refreshRate
|
||||
val total = (if (rttMs >= 0) rttMs / 2 else 0.0) + bufferMs + decodeMs + fgWaitMs + fgGpuMs + refreshMs
|
||||
// What reaches the screen: the decoder's own count in zero-copy, the presented rate with frame generation,
|
||||
// else the frames handed to the compositor (a frame-rate target drops some of WebRTC's decoded frames).
|
||||
val submitted = video?.frames ?: 0L
|
||||
val handed = (submitted - lastSubmitted).toInt().also { lastSubmitted = submitted }
|
||||
val shownFps = when {
|
||||
zeroCopy -> (zeroCopyFrames - lastZeroCopyFrames).toInt().also { lastZeroCopyFrames = zeroCopyFrames }
|
||||
fgOn -> fg!![3].toInt()
|
||||
else -> handed
|
||||
}
|
||||
val items = buildList {
|
||||
add("native · " + if (settings.frameGen == XboxNativeVideo.FG_OFF) "no frame gen" else XboxNativeVideo.modeName(settings.frameGen))
|
||||
add("$shownFps fps" + if (zeroCopy) " zero-copy" else "")
|
||||
if (fgOn) add("${settings.frameGen} ${fg!![2].toInt()} → ${fg[3].toInt()}")
|
||||
if (level >= 2) { add(size); add(if (rttMs >= 0) "ping ${rttMs.toInt()} ms" else "ping –") }
|
||||
if (level >= 3) {
|
||||
add("${"%.1f".format(mbps)} Mb/s"); add("buffer ${"%.1f".format(bufferMs)} ms")
|
||||
add("decode ${"%.1f".format(decodeMs)} ms"); add("loss ${"%.1f".format(loss)}%")
|
||||
}
|
||||
if (level >= 4) {
|
||||
if (fgOn) add("frame gen +${"%.1f".format(fgWaitMs + fgGpuMs)} ms (gpu ${"%.1f".format(fgGpuMs)})")
|
||||
add("picture delay ≈ ${total.toInt()} ms (est.)")
|
||||
if (codec.isNotEmpty()) add(codec)
|
||||
serverName?.let { add(it) }
|
||||
}
|
||||
}
|
||||
val text = items.joinToString(if (settings.statsLayout == "vertical") "\n" else " · ")
|
||||
runOnUiThread { overlay.text = text }
|
||||
}
|
||||
}
|
||||
|
||||
// ---- menu ----
|
||||
|
||||
/** The player menu (as the web player's): Resume, Xbox menu, Frame generation, Stream quality, overlay, Leave. */
|
||||
private fun openMenu() {
|
||||
if (menu != null) return
|
||||
pad.reset()
|
||||
menuPage = ""
|
||||
val regions = regionNames
|
||||
val lsfg = XboxNativeVideo.lsfgReady(this)
|
||||
val view = androidx.compose.ui.platform.ComposeView(this)
|
||||
view.setContent {
|
||||
com.droiddeck.launcher.ui.DroidDeckTheme {
|
||||
var current by androidx.compose.runtime.remember { androidx.compose.runtime.mutableStateOf(settings) }
|
||||
val entries = androidx.compose.runtime.remember { List(7) { androidx.compose.ui.focus.FocusRequester() } }
|
||||
val choices = androidx.compose.runtime.remember { List(5) { androidx.compose.ui.focus.FocusRequester() } }
|
||||
androidx.compose.runtime.LaunchedEffect(menuPage) {
|
||||
// Wait a frame so the entries are attached before one of them takes the selection.
|
||||
androidx.compose.runtime.withFrameNanos { }
|
||||
runCatching {
|
||||
if (menuPage.isEmpty()) entries[lastMainEntry.coerceIn(0, 6)].requestFocus()
|
||||
else if (menuPage == "framegen") choices[FG_MODES.indexOf(current.frameGen).coerceIn(0, if (lsfg) 4 else 1)].requestFocus()
|
||||
}
|
||||
}
|
||||
val cs = androidx.compose.material3.MaterialTheme.colorScheme
|
||||
// A full-size box first: the root of a ComposeView gets fixed full-screen constraints, so the panel's
|
||||
// width only holds inside it (as the web player's menu does).
|
||||
androidx.compose.foundation.layout.Box(androidx.compose.ui.Modifier.fillMaxSize()) {
|
||||
androidx.compose.foundation.layout.Column(
|
||||
androidx.compose.ui.Modifier.fillMaxHeight().width(400.dp).background(cs.surface.copy(alpha = 0.95f))
|
||||
.verticalScroll(androidx.compose.foundation.rememberScrollState()).padding(vertical = 12.dp),
|
||||
) {
|
||||
androidx.compose.material3.Text("${intent.getStringExtra("title").orEmpty()} · native",
|
||||
style = androidx.compose.material3.MaterialTheme.typography.titleMedium, color = cs.onSurface,
|
||||
modifier = androidx.compose.ui.Modifier.padding(horizontal = 16.dp, vertical = 4.dp))
|
||||
fun fgName(mode: String) = when (mode) {
|
||||
XboxNativeVideo.FG_DDFG -> "DDFG 2×"; XboxNativeVideo.FG_LSFG -> "LSFG 2×"
|
||||
XboxNativeVideo.FG_LSFG3 -> "LSFG 3×"; XboxNativeVideo.FG_LSFG4 -> "LSFG 4×"; else -> "Off"
|
||||
}
|
||||
fun fpsName(s: XboxCloudSettings) = if (s.fpsTarget == 0) "the screen's rate" else "${s.fpsTarget} fps"
|
||||
when (menuPage) {
|
||||
"" -> {
|
||||
XboxMenuEntry("Resume", "Back to the game", entries[0], { lastMainEntry = 0 }) { closeMenu() }
|
||||
XboxMenuEntry("Xbox menu", "The game's Xbox menu (also: Guide once)", entries[1], { lastMainEntry = 1 }) { closeMenu(); pressNexus() }
|
||||
XboxMenuEntry("Frame generation & low latency", "Now: ${fgName(current.frameGen)}" + if (zeroCopy) " · zero-copy" else "",
|
||||
entries[2], { lastMainEntry = 2 }) { menuPage = "framegen" }
|
||||
XboxMenuEntry("Frame rate", "Target: ${fpsName(current)}", entries[3], { lastMainEntry = 3 }) { menuPage = "framerate" }
|
||||
XboxMenuEntry("Stream quality", "Engine, resolution, region, codec, bitrate (next stream)", entries[4], { lastMainEntry = 4 }) { menuPage = "stream" }
|
||||
XboxMenuEntry("Performance overlay and rumble", if (current.statsLevel == 0) "Overlay off"
|
||||
else "Overlay: " + listOf("", "FPS only", "Basic", "Detailed", "Full")[current.statsLevel] + ", " + current.statsLayout,
|
||||
entries[5], { lastMainEntry = 5 }) { menuPage = "overlay-native" }
|
||||
XboxMenuEntry("Leave", "End the stream", entries[6], { lastMainEntry = 6 }) { finish() }
|
||||
androidx.compose.material3.Text("Guide twice opens this menu; Back or Guide closes it.",
|
||||
style = androidx.compose.material3.MaterialTheme.typography.bodySmall, color = cs.onSurfaceVariant,
|
||||
modifier = androidx.compose.ui.Modifier.padding(horizontal = 16.dp, vertical = 8.dp))
|
||||
}
|
||||
"framegen" -> {
|
||||
XboxMenuEntry("‹ Back", null) { menuPage = "" }
|
||||
val modes = if (lsfg) FG_MODES else FG_MODES.take(2)
|
||||
modes.forEachIndexed { i, mode ->
|
||||
XboxMenuEntry((if (current.frameGen == mode) "✓ " else "") + fgName(mode), when (mode) {
|
||||
XboxNativeVideo.FG_DDFG -> "DroidDeck's own frame generation (DDFG); doubles the shown frame rate"
|
||||
XboxNativeVideo.FG_LSFG, XboxNativeVideo.FG_LSFG3, XboxNativeVideo.FG_LSFG4 ->
|
||||
"Lossless Scaling frame generation (the Lossless.dll DroidDeck uses for games); the frame-rate target caps the output"
|
||||
else -> "Show the stream's own frames only"
|
||||
}, choices[i]) { current = current.copy(frameGen = mode); setFrameGen(mode) }
|
||||
}
|
||||
if (!lsfg) androidx.compose.material3.Text("LSFG appears here once DroidDeck has the Lossless.dll (frame generation settings).",
|
||||
style = androidx.compose.material3.MaterialTheme.typography.bodySmall, color = cs.onSurfaceVariant,
|
||||
modifier = androidx.compose.ui.Modifier.padding(horizontal = 16.dp, vertical = 8.dp))
|
||||
if (current.zeroCopy) androidx.compose.material3.Text(
|
||||
"Zero-copy is used while frame generation is Off; picking a frame generation mode switches to the compositor live.",
|
||||
style = androidx.compose.material3.MaterialTheme.typography.bodySmall, color = cs.onSurfaceVariant,
|
||||
modifier = androidx.compose.ui.Modifier.padding(horizontal = 16.dp, vertical = 8.dp))
|
||||
XboxCloudSettingsPanel(current, regionNames, live = true, section = "latency", restoreRow = null,
|
||||
startedWith = startedWith) { changed ->
|
||||
val before = current
|
||||
current = changed
|
||||
applyLive(before, changed)
|
||||
}
|
||||
XboxMenuEntry("Restart the stream with these settings",
|
||||
"Ends this cloud session and starts a new one; the game restarts, unsaved progress is lost.") { restartStream() }
|
||||
}
|
||||
else -> {
|
||||
XboxMenuEntry("‹ Back", null) { menuPage = "" }
|
||||
if (menuPage == "stream") XboxMenuEntry("Restart the stream with these settings",
|
||||
"Ends this cloud session and starts a new one; the game restarts, unsaved progress is lost.") { restartStream() }
|
||||
val page = menuPage
|
||||
XboxCloudSettingsPanel(current, regions, live = true, section = page, restoreRow = lastRow[page] ?: 0,
|
||||
onRowFocused = { lastRow[page] = it }, startedWith = startedWith) { changed ->
|
||||
val before = current
|
||||
current = changed
|
||||
applyLive(before, changed)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
menu = view
|
||||
root.addView(view, FrameLayout.LayoutParams(-1, -1))
|
||||
view.requestFocus()
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies a settings change from any menu page at once: frame generation, the frame-rate target, zero-copy, instant
|
||||
* input and the overlay. Resolution, region, language, codec, bitrate, the network buffer, the decoder mode and the
|
||||
* engine belong to the cloud session and need a restart (the page says so).
|
||||
*/
|
||||
private fun applyLive(before: XboxCloudSettings, changed: XboxCloudSettings) {
|
||||
settings = changed
|
||||
XboxCloudSettings.save(this, changed)
|
||||
if (changed.frameGen != before.frameGen) setFrameGen(changed.frameGen)
|
||||
else if (changed.zeroCopy != before.zeroCopy) applyRoute()
|
||||
if (changed.fpsTarget != before.fpsTarget) { applyDisplayRate(changed.fpsTarget); video?.setFpsTarget(changed.fpsTarget); applyRoute() }
|
||||
applyOverlay()
|
||||
}
|
||||
|
||||
/**
|
||||
* Zero-copy draws every decoded frame straight onto the screen, so it is used only when nothing has to touch the
|
||||
* frames: frame generation off and no frame-rate target below the stream's 60 fps (the compositor drops frames for that).
|
||||
*/
|
||||
private fun zeroCopyWanted(s: XboxCloudSettings) =
|
||||
s.zeroCopy && s.frameGen == XboxNativeVideo.FG_OFF && (s.fpsTarget == 0 || s.fpsTarget >= 60)
|
||||
|
||||
private fun applyOverlay() {
|
||||
overlayOn = settings.statsLevel > 0
|
||||
overlay.visibility = if (overlayOn) android.view.View.VISIBLE else android.view.View.GONE
|
||||
overlay.textSize = 12f
|
||||
// Top left keeps clear of the clock Xbox draws top right while its guide is open.
|
||||
val left = settings.statsCorner == "left"
|
||||
overlay.layoutParams = (overlay.layoutParams as FrameLayout.LayoutParams).apply {
|
||||
gravity = Gravity.TOP or (if (left) Gravity.START else Gravity.END)
|
||||
leftMargin = if (left) 16 else 0; rightMargin = if (left) 0 else 16
|
||||
}
|
||||
overlay.gravity = if (left) Gravity.START else Gravity.END
|
||||
}
|
||||
|
||||
/** Stream-start settings need a new cloud session: end this one, then open the player again. */
|
||||
private fun restartStream() {
|
||||
val signals = signalling
|
||||
closed = true
|
||||
closeMenu()
|
||||
notice?.let { root.removeView(it) }
|
||||
notice = null
|
||||
show("Restarting the stream…")
|
||||
Thread({
|
||||
signals?.stop()?.let { log("restart: session closed ${it.status}") }
|
||||
runOnUiThread { if (!isFinishing) { startActivity(XboxCloudPlayerActivity.playerIntent(this, intent.getStringExtra("product").orEmpty(), intent.getStringExtra("title").orEmpty())); finish() } }
|
||||
}, "xcloud-native-restart").start()
|
||||
}
|
||||
|
||||
private fun closeMenu() {
|
||||
menu?.let { root.removeView(it) }
|
||||
menu = null
|
||||
pad.reset()
|
||||
}
|
||||
|
||||
private fun setFrameGen(mode: String) {
|
||||
settings = settings.copy(frameGen = mode)
|
||||
XboxCloudSettings.save(this, settings)
|
||||
applyRoute()
|
||||
worker.execute { video?.setFrameGeneration(effectiveFrameGen()) }
|
||||
}
|
||||
|
||||
/**
|
||||
* Live route switch (UI thread): zero-copy when chosen and frame generation is off, else the compositor.
|
||||
* The screen surface takes one producer at a time, so the old one lets go before the new one connects.
|
||||
*/
|
||||
private fun applyRoute() {
|
||||
val d = decoders ?: return
|
||||
val want = zeroCopyWanted(settings)
|
||||
if (want == zeroCopy) return
|
||||
val target = screen
|
||||
if (want) {
|
||||
if (target == null) return
|
||||
video?.setSurface(null, 0, 0, 60f)
|
||||
if (d.useScreen(target)) { lastZeroCopyFrames = zeroCopyFrames; zeroCopy = true; log("route: zero-copy") }
|
||||
else { attachCompositor(target); log("route: zero-copy refused by the decoder, compositor kept") }
|
||||
} else {
|
||||
if (!d.useScreen(null)) { log("route: decoder could not leave the screen, zero-copy kept"); return }
|
||||
zeroCopy = false
|
||||
target?.let { attachCompositor(it) }
|
||||
log("route: compositor")
|
||||
}
|
||||
}
|
||||
|
||||
private fun attachCompositor(target: android.view.Surface) {
|
||||
@Suppress("DEPRECATION")
|
||||
video?.setSurface(target, screenW, screenH, windowManager.defaultDisplay.refreshRate)
|
||||
}
|
||||
|
||||
/**
|
||||
* Ask Android for the display mode whose refresh rate fits the target (at least the target when possible,
|
||||
* else the fastest; the fastest for "the screen's rate"), so generated frames are not held back at 60 Hz.
|
||||
*/
|
||||
private fun applyDisplayRate(target: Int) {
|
||||
@Suppress("DEPRECATION") val display = windowManager.defaultDisplay
|
||||
val current = display.mode
|
||||
val modes = display.supportedModes.filter { it.physicalWidth == current.physicalWidth && it.physicalHeight == current.physicalHeight }
|
||||
val pick = (if (target > 0) modes.filter { it.refreshRate >= target - 0.5f }.minByOrNull { it.refreshRate } else null)
|
||||
?: modes.maxByOrNull { it.refreshRate } ?: return
|
||||
window.attributes = window.attributes.apply { preferredDisplayModeId = pick.modeId }
|
||||
log("display mode ${pick.refreshRate.toInt()} Hz for target ${if (target > 0) target else "screen"}")
|
||||
}
|
||||
|
||||
private val rehideBars = Runnable { if (window.decorView.hasWindowFocus()) hideBars() }
|
||||
|
||||
/**
|
||||
* Bars that come back while the player has focus (return from recents or another app, a swipe) are hidden
|
||||
* again after a moment; focus alone missed the return from the background (10-24).
|
||||
*/
|
||||
private fun watchBars() {
|
||||
androidx.core.view.ViewCompat.setOnApplyWindowInsetsListener(window.decorView) { v, insets ->
|
||||
if (insets.isVisible(WindowInsetsCompat.Type.navigationBars()) || insets.isVisible(WindowInsetsCompat.Type.statusBars())) {
|
||||
v.removeCallbacks(rehideBars)
|
||||
v.postDelayed(rehideBars, 1500)
|
||||
}
|
||||
androidx.core.view.ViewCompat.onApplyWindowInsets(v, insets)
|
||||
}
|
||||
}
|
||||
|
||||
override fun onResume() {
|
||||
super.onResume()
|
||||
hideBars()
|
||||
}
|
||||
|
||||
private fun hideBars() {
|
||||
WindowCompat.setDecorFitsSystemWindows(window, false)
|
||||
WindowInsetsControllerCompat(window, window.decorView).apply {
|
||||
hide(WindowInsetsCompat.Type.systemBars())
|
||||
systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
|
||||
}
|
||||
}
|
||||
|
||||
override fun onWindowFocusChanged(hasFocus: Boolean) { super.onWindowFocusChanged(hasFocus); if (hasFocus) hideBars() }
|
||||
|
||||
override fun onDestroy() {
|
||||
closed = true
|
||||
ticker.shutdownNow()
|
||||
val signals = signalling
|
||||
Thread({ signals?.stop()?.let { log("session closed: ${it.status}") } }, "xcloud-native-stop").start()
|
||||
runCatching { protocol?.close() }
|
||||
runCatching { pc?.close(); pc?.dispose() }
|
||||
runCatching { video?.release() }
|
||||
runCatching { factory?.dispose() }
|
||||
runCatching { decoders?.release() }
|
||||
runCatching { eglBase?.release() }
|
||||
worker.shutdownNow()
|
||||
super.onDestroy()
|
||||
}
|
||||
|
||||
companion object {
|
||||
/** How long a stream may stay in the background (Android froze the app ~70 s after it left the screen, 10-24). */
|
||||
private const val BACKGROUND_GRACE_MS = 45_000L
|
||||
private val FG_MODES = listOf(XboxNativeVideo.FG_OFF, XboxNativeVideo.FG_DDFG, XboxNativeVideo.FG_LSFG, XboxNativeVideo.FG_LSFG3, XboxNativeVideo.FG_LSFG4)
|
||||
|
||||
/** True when the native engine can run here (ImageReader GPU buffers need Android 10). */
|
||||
fun supported(): Boolean = Build.VERSION.SDK_INT >= 29
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,186 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import org.json.JSONObject
|
||||
import org.webrtc.DataChannel
|
||||
import org.webrtc.PeerConnection
|
||||
import java.nio.ByteBuffer
|
||||
import java.nio.ByteOrder
|
||||
import java.nio.charset.StandardCharsets
|
||||
import java.util.UUID
|
||||
import java.util.concurrent.Executors
|
||||
import java.util.concurrent.ScheduledFuture
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
/**
|
||||
* The xCloud data-channel protocol for the native player, ported from Greenlight's player (UnknownSKL, MIT;
|
||||
* tools/xcloud-player/greenlight/lib/channel): chat / control / input / message channels, the message
|
||||
* handshake, authorization and gamepad announcements, and the binary input reports. The controller state
|
||||
* comes from Android input events ([pad]); rumble reports come back through [onRumble].
|
||||
*/
|
||||
internal class XboxNativeProtocol(
|
||||
pc: PeerConnection,
|
||||
private val pad: XboxNativePad,
|
||||
private val log: (String) -> Unit,
|
||||
private val onRumble: (strong: Float, weak: Float, durationMs: Int) -> Unit,
|
||||
private val onServerDisconnect: () -> Unit,
|
||||
) {
|
||||
private val chat = pc.createDataChannel("chat", init("chatV1"))
|
||||
private val control = pc.createDataChannel("control", init("controlV1"))
|
||||
private val input = pc.createDataChannel("input", init("1.0"))
|
||||
private val message = pc.createDataChannel("message", init("messageV1"))
|
||||
private val timer = Executors.newSingleThreadScheduledExecutor { r -> Thread(r, "xcloud-input") }
|
||||
private var loop: ScheduledFuture<*>? = null
|
||||
private var sequence = 0
|
||||
private var lastSent: XboxNativePad.State? = null
|
||||
private var lastSentAt = 0L
|
||||
@Volatile var handshakeDone = false
|
||||
private set
|
||||
|
||||
init {
|
||||
message.registerObserver(ChannelObserver(message, ::onMessageOpen, ::onMessageData))
|
||||
control.registerObserver(ChannelObserver(control, {}, {}))
|
||||
input.registerObserver(ChannelObserver(input, {}, ::onInputData))
|
||||
chat.registerObserver(ChannelObserver(chat, {}, {}))
|
||||
}
|
||||
|
||||
private fun init(protocol: String) = DataChannel.Init().apply { ordered = true; this.protocol = protocol }
|
||||
|
||||
private inner class ChannelObserver(
|
||||
private val channel: DataChannel,
|
||||
private val onOpen: () -> Unit,
|
||||
private val onData: (DataChannel.Buffer) -> Unit,
|
||||
) : DataChannel.Observer {
|
||||
private var opened = false
|
||||
override fun onBufferedAmountChange(previous: Long) {}
|
||||
override fun onStateChange() {
|
||||
if (!opened && channel.state() == DataChannel.State.OPEN) { opened = true; runCatching(onOpen).onFailure { log("channel open failed: ${it.message}") } }
|
||||
}
|
||||
override fun onMessage(buffer: DataChannel.Buffer) { runCatching { onData(buffer) }.onFailure { log("channel message failed: ${it.message}") } }
|
||||
}
|
||||
|
||||
private fun send(channel: DataChannel, text: String) {
|
||||
if (channel.state() != DataChannel.State.OPEN) return
|
||||
channel.send(DataChannel.Buffer(ByteBuffer.wrap(text.toByteArray(StandardCharsets.UTF_8)), false))
|
||||
}
|
||||
|
||||
private fun send(channel: DataChannel, bytes: ByteBuffer) {
|
||||
if (channel.state() != DataChannel.State.OPEN) return
|
||||
channel.send(DataChannel.Buffer(bytes, true))
|
||||
}
|
||||
|
||||
private fun onMessageOpen() {
|
||||
log("message channel open, handshake")
|
||||
send(message, JSONObject().put("type", "Handshake").put("version", "messageV1")
|
||||
.put("id", "be0bfc6d-1e83-4c8a-90ed-fa8601c5a179").put("cv", "0").toString())
|
||||
}
|
||||
|
||||
private fun onMessageData(buffer: DataChannel.Buffer) {
|
||||
val bytes = ByteArray(buffer.data.remaining()).also { buffer.data.get(it) }
|
||||
val data = JSONObject(String(bytes, StandardCharsets.UTF_8))
|
||||
when (data.optString("type")) {
|
||||
"HandshakeAck" -> {
|
||||
handshakeDone = true
|
||||
log("handshake done")
|
||||
// Greenlight's order: authorization (announces controller 0 and removes it), input start, config.
|
||||
send(control, JSONObject().put("message", "authorizationRequest").put("accessKey", "4BDB3609-C1F1-4195-9B37-FEFF45DA8B8E").toString())
|
||||
gamepadChanged(0, true); gamepadChanged(0, false)
|
||||
startInput()
|
||||
sendConfig()
|
||||
// Our controller, after the authorization's add/remove.
|
||||
gamepadChanged(0, true)
|
||||
send(control, JSONObject().put("message", "videoKeyframeRequested").put("ifrRequested", true).toString())
|
||||
}
|
||||
"TransactionStart", "Message" -> handleTransaction(data)
|
||||
else -> {}
|
||||
}
|
||||
}
|
||||
|
||||
private fun handleTransaction(data: JSONObject) {
|
||||
when (data.optString("target")) {
|
||||
"/streaming/sessionLifetimeManagement/serverInitiatedDisconnect" -> {
|
||||
complete(data.optString("id"), "")
|
||||
onServerDisconnect()
|
||||
}
|
||||
// The game's own dialogs: accept (Greenlight shows a confirm; the native player has no page).
|
||||
"/streaming/systemUi/messages/ShowMessageDialog" -> complete(data.optString("id"), JSONObject().put("Result", 0))
|
||||
else -> {}
|
||||
}
|
||||
}
|
||||
|
||||
private fun complete(id: String, content: Any) {
|
||||
send(message, JSONObject().put("type", "TransactionComplete").put("content", content.toString().let { if (content is String) JSONObject.quote(it) else it })
|
||||
.put("id", id).put("cv", "").toString())
|
||||
}
|
||||
|
||||
private fun gamepadChanged(index: Int, added: Boolean) {
|
||||
send(control, JSONObject().put("message", "gamepadChanged").put("gamepadIndex", index).put("wasAdded", added).toString())
|
||||
}
|
||||
|
||||
private fun sendConfig() {
|
||||
fun msg(path: String, content: JSONObject) = JSONObject().put("type", "Message").put("content", content.toString())
|
||||
.put("id", UUID.randomUUID().toString()).put("target", path).put("cv", "").toString()
|
||||
send(message, msg("/streaming/systemUi/configuration", JSONObject().put("version", org.json.JSONArray(listOf(0, 2, 0))).put("systemUis", org.json.JSONArray())))
|
||||
send(message, msg("/streaming/properties/clientappinstallidchanged", JSONObject().put("clientAppInstallId", "c97d7ee0-73b2-4239-bf1d-9d805a338429")))
|
||||
send(message, msg("/streaming/characteristics/orientationchanged", JSONObject().put("orientation", 0)))
|
||||
send(message, msg("/streaming/characteristics/touchinputenabledchanged", JSONObject().put("touchInputEnabled", false)))
|
||||
send(message, msg("/streaming/characteristics/clientdevicecapabilities", JSONObject()))
|
||||
send(message, msg("/streaming/characteristics/dimensionschanged", JSONObject().put("horizontal", 1920).put("vertical", 1080)
|
||||
.put("preferredWidth", 1920).put("preferredHeight", 1080).put("safeAreaLeft", 0).put("safeAreaTop", 0)
|
||||
.put("safeAreaRight", 1920).put("safeAreaBottom", 1080).put("supportsCustomResolution", true)))
|
||||
}
|
||||
|
||||
private fun header(type: Int, size: Int): ByteBuffer = ByteBuffer.allocateDirect(size).order(ByteOrder.LITTLE_ENDIAN).apply {
|
||||
putShort(type.toShort()); putInt(sequence++); putDouble(System.nanoTime() / 1e6)
|
||||
}
|
||||
|
||||
private fun startInput() {
|
||||
// Client metadata: max touch points.
|
||||
send(input, header(8, 15).apply { put(1.toByte()); flip() })
|
||||
loop = timer.scheduleWithFixedDelay({ runCatching { tick() } }, 16, 16, TimeUnit.MILLISECONDS)
|
||||
}
|
||||
|
||||
/** Instant controller input: send a report now if the state changed (the 16 ms loop stays as the heartbeat). */
|
||||
fun inputChanged() {
|
||||
// At most one extra report every 4 ms (stick motion arrives far faster than that).
|
||||
if (handshakeDone && loop != null && System.nanoTime() - lastSentAt > 4_000_000L) timer.execute { runCatching { tick() } }
|
||||
}
|
||||
|
||||
/** Greenlight's queue: a gamepad frame when the state changed (sticks past a small threshold) or every 33 ms. */
|
||||
@Synchronized
|
||||
private fun tick() {
|
||||
val state = pad.snapshot()
|
||||
val now = System.nanoTime()
|
||||
val changed = lastSent?.let { state.differsFrom(it) } ?: true
|
||||
if (!changed && now - lastSentAt < 33_000_000L) return
|
||||
lastSent = state; lastSentAt = now
|
||||
val packet = header(2, 14 + 1 + 23).apply {
|
||||
put(1.toByte()) // one frame
|
||||
put(0.toByte()) // gamepad index
|
||||
putShort(state.buttons.toShort())
|
||||
putShort(axis(state.lx)); putShort(axis(-state.ly)); putShort(axis(state.rx)); putShort(axis(-state.ry))
|
||||
putShort(trigger(state.lt)); putShort(trigger(state.rt))
|
||||
putInt(1) // physical physicality
|
||||
order(ByteOrder.BIG_ENDIAN); putInt(1); order(ByteOrder.LITTLE_ENDIAN) // virtual physicality (Greenlight writes it big-endian)
|
||||
flip()
|
||||
}
|
||||
send(input, packet)
|
||||
}
|
||||
|
||||
private fun axis(value: Float): Short = (value * 32767).toInt().coerceIn(-32767, 32767).toShort()
|
||||
private fun trigger(value: Float): Short = if (value <= 0f) 0 else if (value >= 1f) 65535.toShort() else (value * 65535).toInt().toShort()
|
||||
|
||||
private fun onInputData(buffer: DataChannel.Buffer) {
|
||||
val data = buffer.data.order(ByteOrder.LITTLE_ENDIAN)
|
||||
if (data.remaining() < 13 || (data.get(0).toInt() and 0xFF) != 128) return // vibration report
|
||||
val strong = (data.get(4).toInt() and 0xFF) / 100f
|
||||
val weak = (data.get(5).toInt() and 0xFF) / 100f
|
||||
val duration = data.getShort(8).toInt() and 0xFFFF
|
||||
onRumble(strong, weak, duration)
|
||||
}
|
||||
|
||||
fun close() {
|
||||
loop?.cancel(false)
|
||||
timer.shutdownNow()
|
||||
listOf(chat, control, input, message).forEach { runCatching { it.unregisterObserver(); it.close(); it.dispose() } }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,183 @@
|
||||
package com.droiddeck.launcher.stores.xbox
|
||||
|
||||
import android.content.Context
|
||||
import android.graphics.PixelFormat
|
||||
import android.hardware.HardwareBuffer
|
||||
import android.media.Image
|
||||
import android.media.ImageReader
|
||||
import android.os.Handler
|
||||
import android.os.HandlerThread
|
||||
import android.view.Surface
|
||||
import com.droiddeck.launcher.gpu.FrameGen
|
||||
import com.droiddeck.launcher.gpu.Lossless
|
||||
import com.droiddeck.launcher.wayland.CompositorHost
|
||||
import com.droiddeck.launcher.wayland.WaylandCompositor
|
||||
import org.webrtc.EglBase
|
||||
import org.webrtc.EglRenderer
|
||||
import org.webrtc.GlRectDrawer
|
||||
import org.webrtc.VideoFrame
|
||||
import org.webrtc.VideoSink
|
||||
import java.io.File
|
||||
import java.util.ArrayDeque
|
||||
|
||||
/**
|
||||
* The native player's picture: WebRTC's hardware-decoded frames are drawn (GL, WebRTC's EglRenderer) into an
|
||||
* ImageReader whose images are GPU-shareable HardwareBuffers, and each one goes to DroidDeck's own compositor in
|
||||
* stream mode (WaylandCompositor.nativeStreamFrame) as the whole scene, where DroidDeck's frame generation (DDFG,
|
||||
* or LSFG with the Lossless.dll) multiplies it. The player runs in its own process (:xcloudnative), so this
|
||||
* compositor is never the one a Linux session uses. Android 10+ (ImageReader usage flags).
|
||||
*/
|
||||
internal class XboxNativeVideo(private val context: Context, eglBase: EglBase, private val log: (String) -> Unit) : VideoSink {
|
||||
companion object {
|
||||
const val FG_OFF = "off"
|
||||
const val FG_DDFG = "ddfg"
|
||||
const val FG_LSFG = "lsfg"
|
||||
const val FG_LSFG3 = "lsfg3"
|
||||
const val FG_LSFG4 = "lsfg4"
|
||||
fun isLsfg(mode: String) = mode == FG_LSFG || mode == FG_LSFG3 || mode == FG_LSFG4
|
||||
fun multiplier(mode: String) = when (mode) { FG_LSFG3 -> 3; FG_LSFG4 -> 4; FG_OFF -> 0; else -> 2 }
|
||||
fun modes(lsfg: Boolean) = if (lsfg) listOf(FG_OFF, FG_DDFG, FG_LSFG, FG_LSFG3, FG_LSFG4) else listOf(FG_OFF, FG_DDFG)
|
||||
fun modeName(mode: String) = when (mode) {
|
||||
FG_DDFG -> "DDFG 2×"; FG_LSFG -> "LSFG 2×"; FG_LSFG3 -> "LSFG 3×"; FG_LSFG4 -> "LSFG 4×"; else -> "Off"
|
||||
}
|
||||
/** LSFG can run: the Lossless.dll was imported (or found in Steam) and its shader cache built. */
|
||||
fun lsfgReady(context: Context) = Lossless.state(context).ready
|
||||
private const val SCALE_FIT = 1
|
||||
private const val ALIGN_CENTER = 0
|
||||
}
|
||||
|
||||
private val lock = Any()
|
||||
private val egl = EglRenderer("xcloud-native").apply { init(eglBase.eglBaseContext, EglBase.CONFIG_RGBA, GlRectDrawer()) }
|
||||
private val readerThread = HandlerThread("xcloud-frames").apply { start() }
|
||||
private val readerHandler = Handler(readerThread.looper)
|
||||
private var reader: ImageReader? = null
|
||||
private var readerW = 0
|
||||
private var readerH = 0
|
||||
/** Images the compositor may still read: the oldest goes back to the reader once two newer ones arrived. */
|
||||
private val held = ArrayDeque<Image>()
|
||||
private var surface: Surface? = null
|
||||
private var attached = false
|
||||
@Volatile private var frameGen = FG_OFF
|
||||
@Volatile private var refreshHz = 60f
|
||||
/** The frame-rate target (0 = the screen's rate): the frame-gen pacer's cap, or a limit on stream frames without it. */
|
||||
@Volatile private var fpsTarget = 0
|
||||
private var nextDueNs = 0L
|
||||
@Volatile var frames = 0L
|
||||
private set
|
||||
|
||||
/** The screen: the compositor presents to it (null detaches, e.g. for zero-copy or when the surface goes). */
|
||||
fun setSurface(target: Surface?, width: Int, height: Int, displayRefreshHz: Float) = synchronized(lock) {
|
||||
refreshHz = displayRefreshHz
|
||||
if (target == null) {
|
||||
if (attached) letGo()
|
||||
attached = false; surface = null
|
||||
return@synchronized
|
||||
}
|
||||
surface = target
|
||||
val runtime = File(context.cacheDir, "xcloud-wayland").apply { mkdirs() }
|
||||
// System Vulkan driver; this process's compositor shows only the stream.
|
||||
val started = CompositorHost.startOrAttach(context, target, runtime.path, null, null, context.applicationInfo.nativeLibraryDir,
|
||||
width, height, displayRefreshHz, 0)
|
||||
if (started) {
|
||||
WaylandCompositor.nativeSetScaleMode(SCALE_FIT, ALIGN_CENTER)
|
||||
log("compositor started on ${width}x$height at ${displayRefreshHz.toInt()} Hz")
|
||||
} else {
|
||||
WaylandCompositor.nativeResizeOutput(width, height)
|
||||
}
|
||||
WaylandCompositor.nativeStreamMode(true)
|
||||
attached = true
|
||||
applyFrameGen()
|
||||
}
|
||||
|
||||
/**
|
||||
* Gives the screen surface up and waits until the compositor has really disconnected from it: the window request
|
||||
* is applied on the compositor thread at its next tick, and the decoder (zero-copy) can only connect after that.
|
||||
*/
|
||||
private fun letGo() {
|
||||
WaylandCompositor.nativeSetFrameGenArmed(false, 0, 0)
|
||||
CompositorHost.detach(surface)
|
||||
WaylandCompositor.nativeVsync(System.nanoTime())
|
||||
if (!WaylandCompositor.nativeWaitSurface(1000)) log("compositor did not let go of the screen within 1 s")
|
||||
}
|
||||
|
||||
/** Frame-rate target, 0 = the screen's rate. Live. */
|
||||
fun setFpsTarget(fps: Int) {
|
||||
fpsTarget = fps
|
||||
synchronized(lock) { if (attached) applyFrameGen() }
|
||||
}
|
||||
|
||||
/** off, ddfg (2x) or lsfg / lsfg3 / lsfg4 (needs the Lossless.dll). Live. */
|
||||
fun setFrameGeneration(mode: String) {
|
||||
frameGen = mode
|
||||
synchronized(lock) { if (attached) applyFrameGen() }
|
||||
}
|
||||
|
||||
override fun onFrame(frame: VideoFrame) {
|
||||
val w = frame.rotatedWidth; val h = frame.rotatedHeight
|
||||
synchronized(lock) { if (w != readerW || h != readerH) startReader(w, h) }
|
||||
egl.onFrame(frame)
|
||||
}
|
||||
|
||||
private fun startReader(w: Int, h: Int) {
|
||||
val old = reader
|
||||
if (old != null) egl.releaseEglSurface { }
|
||||
held.forEach { runCatching { it.close() } }; held.clear()
|
||||
old?.close()
|
||||
readerW = w; readerH = h
|
||||
val next = ImageReader.newInstance(w, h, PixelFormat.RGBA_8888, 4,
|
||||
HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE or HardwareBuffer.USAGE_GPU_COLOR_OUTPUT)
|
||||
next.setOnImageAvailableListener({ r -> onImage(r) }, readerHandler)
|
||||
reader = next
|
||||
egl.createEglSurface(next.surface)
|
||||
log("native video ${w}x$h")
|
||||
}
|
||||
|
||||
private fun onImage(r: ImageReader) {
|
||||
val image = runCatching { r.acquireLatestImage() }.getOrNull() ?: return
|
||||
synchronized(lock) {
|
||||
if (r !== reader) { image.close(); return }
|
||||
val buffer = image.hardwareBuffer
|
||||
// Without frame generation a target below the stream's rate drops stream frames evenly: each frame has a
|
||||
// due time one interval after the last one's, so 30 of 60 frames (or 45: three of four) reach the screen.
|
||||
val now = System.nanoTime()
|
||||
val target = fpsTarget
|
||||
val skip = frameGen == FG_OFF && target in 1 until 60 && run {
|
||||
val interval = 1_000_000_000L / target
|
||||
if (nextDueNs == 0L || now - nextDueNs > interval) nextDueNs = now
|
||||
if (now + 4_000_000L < nextDueNs) true else { nextDueNs += interval; false }
|
||||
}
|
||||
if (attached && buffer != null && !skip) { WaylandCompositor.nativeStreamFrame(buffer); frames++ }
|
||||
buffer?.close()
|
||||
held.addLast(image)
|
||||
while (held.size > 2) held.removeFirst().close()
|
||||
}
|
||||
}
|
||||
|
||||
private fun applyFrameGen() {
|
||||
// The pacer caps generated output at this rate: the user's target, else the screen's.
|
||||
val cap = if (fpsTarget > 0) fpsTarget.toFloat() else refreshHz
|
||||
val mode = when {
|
||||
frameGen == FG_DDFG -> FrameGen.Mode(FrameGen.ENGINE_DDFG, 2)
|
||||
isLsfg(frameGen) -> FrameGen.Mode(FrameGen.ENGINE_LSFG, multiplier(frameGen))
|
||||
else -> FrameGen.Mode.OFF
|
||||
}
|
||||
val problem = FrameGen.apply(context, mode, cap)
|
||||
log("native frame generation: $frameGen, target ${if (fpsTarget > 0) fpsTarget else "screen"} fps" + (problem?.let { " ($it)" } ?: ""))
|
||||
}
|
||||
|
||||
/** {planned, planned, sourceFps, presentedFps, thermal, -1}, or null while nothing is shown. */
|
||||
fun stats(): FloatArray? = synchronized(lock) { if (attached) WaylandCompositor.nativeFrameGenStats() else null }
|
||||
|
||||
fun frameGenProblem(): Int = synchronized(lock) { if (attached) WaylandCompositor.nativeFrameGenProblem() else -1 }
|
||||
|
||||
fun release() {
|
||||
egl.release()
|
||||
synchronized(lock) {
|
||||
if (attached) { WaylandCompositor.nativeStreamMode(false); letGo() }
|
||||
attached = false; surface = null
|
||||
held.forEach { runCatching { it.close() } }; held.clear()
|
||||
reader?.close(); reader = null
|
||||
}
|
||||
readerThread.quitSafely()
|
||||
}
|
||||
}
|
||||
@@ -75,16 +75,28 @@ internal fun GamesPage(s: FrontEndState, a: FrontEndActions, selected: String, o
|
||||
val launcherArt by androidx.compose.runtime.produceState<java.io.File?>(null, epic.version) {
|
||||
value = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { EpicClient.icon(pageContext, epic.version) }
|
||||
}
|
||||
val games = remember(s.steamGames, s.shortcutPicker, epic, launcherName, launcherArt) {
|
||||
LaunchedEffect(Unit) { com.droiddeck.launcher.stores.xbox.XboxCloudGames.load(pageContext) }
|
||||
val cloudGames = com.droiddeck.launcher.stores.xbox.XboxCloudGames.entries.toList()
|
||||
val games = remember(s.steamGames, s.shortcutPicker, epic, launcherName, launcherArt, cloudGames) {
|
||||
val sorted = s.steamGames.sortedByDescending { it.lastPlayed }
|
||||
if (s.shortcutPicker) sorted else EpicClient.withLauncher(sorted, EpicClient.launcherEntry(pageContext, launcherName, epic, launcherArt))
|
||||
if (s.shortcutPicker) sorted else {
|
||||
val installedXbox = s.steamGames.filter { it.source == com.droiddeck.launcher.stores.Store.XBOX.id }.mapNotNull { it.storeId }.toSet()
|
||||
EpicClient.withLauncher(sorted, EpicClient.launcherEntry(pageContext, launcherName, epic, launcherArt)) +
|
||||
com.droiddeck.launcher.stores.xbox.XboxCloudGames.rows(pageContext, installedXbox)
|
||||
}
|
||||
}
|
||||
val gameCount = games.count { it.library != Library.EPIC_LAUNCHER }
|
||||
val narrow = LocalNarrowPane.current
|
||||
val current = games.firstOrNull { "app:${it.appId}" == selected } ?: games.firstOrNull()
|
||||
GamesDialogs(a, s.steamGames)
|
||||
val onAdd: (() -> Unit)? = if (s.shortcutPicker) null else ({ GamesDialogState.adding = true })
|
||||
val launch: (Library.SteamGame) -> Unit = { g -> if (g.library == Library.EPIC_LAUNCHER) a.onEpicLauncher() else a.onSteamGame(g) }
|
||||
val launch: (Library.SteamGame) -> Unit = { g ->
|
||||
when (g.library) {
|
||||
Library.EPIC_LAUNCHER -> a.onEpicLauncher()
|
||||
Library.XBOX_CLOUD -> com.droiddeck.launcher.stores.xbox.XboxCloudGames.stream(pageContext, g.storeId.orEmpty(), g.name)
|
||||
else -> a.onSteamGame(g)
|
||||
}
|
||||
}
|
||||
val onEdit: (Library.SteamGame) -> Unit = { g ->
|
||||
g.gameFiles?.let { GamesDialogState.editing = EditRequest(it.path, openTarget = false, fromSummary = false, preview = EditPreview.of(pageContext, g, it.path)) }
|
||||
}
|
||||
@@ -120,8 +132,10 @@ internal fun GamesPage(s: FrontEndState, a: FrontEndActions, selected: String, o
|
||||
if (!narrow) Poster(current.art, current.name, Modifier.width(168.dp))
|
||||
}
|
||||
}
|
||||
Rise(1) { SectionTitle(stringResource(R.string.games_launch_settings), null) }
|
||||
Rise(2) { LaunchSettings(s, a, host, current) }
|
||||
if (current.library != Library.XBOX_CLOUD) {
|
||||
Rise(1) { SectionTitle(stringResource(R.string.games_launch_settings), null) }
|
||||
Rise(2) { LaunchSettings(s, a, host, current) }
|
||||
}
|
||||
Rise(3) { GameFileFolderActions(s, a) }
|
||||
}
|
||||
return
|
||||
@@ -139,8 +153,10 @@ internal fun GamesPage(s: FrontEndState, a: FrontEndActions, selected: String, o
|
||||
GameHeroCopy(current, if (narrow) 24.sp else 32.sp)
|
||||
GameActions(current, s, a, onEdit, launch)
|
||||
}
|
||||
SectionTitle(stringResource(R.string.games_launch_settings), null)
|
||||
LaunchSettings(s, a, host, current)
|
||||
if (current.library != Library.XBOX_CLOUD) {
|
||||
SectionTitle(stringResource(R.string.games_launch_settings), null)
|
||||
LaunchSettings(s, a, host, current)
|
||||
}
|
||||
GameFileFolderActions(s, a)
|
||||
}
|
||||
}
|
||||
@@ -166,8 +182,25 @@ private fun GameFileFolderActions(s: FrontEndState, a: FrontEndActions) {
|
||||
|
||||
@Composable
|
||||
private fun GameActions(g: Library.SteamGame, s: FrontEndState, a: FrontEndActions, onEdit: (Library.SteamGame) -> Unit, launch: (Library.SteamGame) -> Unit) {
|
||||
val context = androidx.compose.ui.platform.LocalContext.current
|
||||
if (g.library == Library.XBOX_CLOUD) {
|
||||
androidx.compose.runtime.LaunchedEffect(g.gameId) { com.droiddeck.launcher.stores.xbox.XboxCloudGames.prefetch(context) }
|
||||
Actions {
|
||||
PrimaryButton("Stream", enabled = !s.busy, main = true, icon = Icons.Filled.PlayArrow) { launch(g) }
|
||||
SecondaryButton("Download") { com.droiddeck.launcher.stores.StoresState.openGameRequest = "${com.droiddeck.launcher.stores.Store.XBOX.id}:${g.storeId}" }
|
||||
SecondaryButton("Remove from Games", compact = true) { com.droiddeck.launcher.stores.xbox.XboxCloudGames.remove(context, g.storeId.orEmpty()) }
|
||||
BusyChip(s)
|
||||
}
|
||||
return
|
||||
}
|
||||
val xboxStream by androidx.compose.runtime.produceState(false, g.gameId) {
|
||||
value = g.source == com.droiddeck.launcher.stores.Store.XBOX.id && !g.storeId.isNullOrEmpty() && !s.shortcutPicker &&
|
||||
kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { com.droiddeck.launcher.stores.xbox.XboxCloudGames.streams(context, g.storeId!!) }
|
||||
}
|
||||
androidx.compose.runtime.LaunchedEffect(xboxStream) { if (xboxStream) com.droiddeck.launcher.stores.xbox.XboxCloudGames.prefetch(context) }
|
||||
Actions {
|
||||
PrimaryButton(stringResource(if (s.shortcutPicker) R.string.game_shortcut_choose else R.string.games_launch), enabled = !s.busy, main = true, icon = Icons.Filled.PlayArrow) { launch(g) }
|
||||
if (xboxStream) SecondaryButton("Stream") { com.droiddeck.launcher.stores.xbox.XboxCloudGames.stream(context, g.storeId.orEmpty(), g.name) }
|
||||
if (g.library == Library.EPIC_LAUNCHER) {
|
||||
if (!s.shortcutPicker) UninstallEpicLauncher(s, a)
|
||||
BusyChip(s)
|
||||
@@ -637,6 +670,7 @@ private fun playedSpan(lastPlayed: Long): String? {
|
||||
@Composable
|
||||
private fun libraryLabel(g: Library.SteamGame): String = when {
|
||||
g.library == Library.EPIC_LAUNCHER -> EpicClient.status.version?.substringBefore('+')?.let { stringResource(R.string.epic_client_version, it) } ?: ""
|
||||
g.library == Library.XBOX_CLOUD -> "Xbox Cloud Gaming"
|
||||
g.library != Library.ADDED -> if (g.library == "internal") stringResource(R.string.games_internal) else g.library
|
||||
g.source != Library.ADDED -> stringResource(R.string.games_store_storage)
|
||||
else -> ""
|
||||
|
||||
@@ -395,6 +395,9 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com
|
||||
}
|
||||
a.onNavigated()
|
||||
}
|
||||
LaunchedEffect(com.droiddeck.launcher.stores.StoresState.openGameRequest) {
|
||||
if (com.droiddeck.launcher.stores.StoresState.openGameRequest != null) selected = "stores"
|
||||
}
|
||||
var showWirelessAdbFix by rememberSaveable { mutableStateOf(false) }
|
||||
var showDeveloperDisplayChoice by rememberSaveable { mutableStateOf(false) }
|
||||
var wirelessAdbDesiredEnabled by rememberSaveable { mutableStateOf(false) }
|
||||
|
||||
@@ -51,6 +51,8 @@ import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.unit.sp
|
||||
import coil.compose.AsyncImage
|
||||
import com.droiddeck.launcher.R
|
||||
import com.droiddeck.launcher.stores.xbox.xboxCloud
|
||||
import com.droiddeck.launcher.stores.xbox.xboxPc
|
||||
import com.droiddeck.launcher.stores.Store
|
||||
import com.droiddeck.launcher.stores.StoreAchievements
|
||||
import com.droiddeck.launcher.stores.StoresState
|
||||
@@ -127,6 +129,7 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro
|
||||
launchStoreGame(ctx, store, id, s, a)
|
||||
}
|
||||
ActionChip(stringResource(R.string.stores_in_steam), ok = true)
|
||||
if (store == Store.XBOX && item?.xboxCloud == true) XboxStreamButton(item)
|
||||
if (store == Store.XBOX) {
|
||||
SecondaryButton("Update / verify", enabled = download == null && !com.droiddeck.launcher.stores.xbox.XboxRuntime.isActive(id)) {
|
||||
runCatching { com.droiddeck.launcher.stores.xbox.XboxBackend.update(ctx, installed) }
|
||||
@@ -157,6 +160,10 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro
|
||||
com.droiddeck.launcher.stores.download.DownloadQueue.clear(ctx, failedDownload.key)
|
||||
}
|
||||
}
|
||||
store == Store.XBOX && item != null && !item.xboxPc && item.xboxCloud -> {
|
||||
XboxStreamButton(item, main = true, modifier = leadOn)
|
||||
XboxAddToGamesButton(item)
|
||||
}
|
||||
item?.installable == true && StoresState.isUnfinished(item) -> {
|
||||
InstallButton(stringResource(R.string.stores_resume_install), leadOn) { StoresState.requestInstall(ctx, item) }
|
||||
ConfirmButton(stringResource(R.string.stores_dl_clear), stringResource(R.string.stores_dl_cancel_confirm), compact = true) { StoresState.clearUnfinished(ctx, item) }
|
||||
@@ -166,6 +173,10 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro
|
||||
if (item.sizeBytes > 0) stringResource(R.string.stores_install_size, formatBytes(item.sizeBytes)) else stringResource(R.string.stores_install),
|
||||
leadOn,
|
||||
) { StoresState.requestInstall(ctx, item) }
|
||||
if (store == Store.XBOX && item.xboxCloud) {
|
||||
XboxStreamButton(item)
|
||||
XboxAddToGamesButton(item)
|
||||
}
|
||||
if (!item.accessible) {
|
||||
SecondaryButton(
|
||||
when {
|
||||
@@ -290,3 +301,29 @@ private fun InstallButton(label: String, modifier: Modifier = Modifier, onInstal
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun XboxStreamButton(item: com.droiddeck.launcher.stores.CatalogItem, main: Boolean = false, modifier: Modifier = Modifier) {
|
||||
val ctx = LocalContext.current
|
||||
androidx.compose.runtime.LaunchedEffect(Unit) { com.droiddeck.launcher.stores.xbox.XboxCloudGames.prefetch(ctx) }
|
||||
val stream = { com.droiddeck.launcher.stores.xbox.XboxCloudGames.stream(ctx, item.id, item.title) }
|
||||
if (main) PrimaryButton("Stream", main = true, icon = Icons.Filled.PlayArrow, modifier = modifier) { stream() }
|
||||
else SecondaryButton("Stream", modifier = modifier) { stream() }
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun XboxAddToGamesButton(item: com.droiddeck.launcher.stores.CatalogItem) {
|
||||
val ctx = LocalContext.current
|
||||
androidx.compose.runtime.LaunchedEffect(Unit) { com.droiddeck.launcher.stores.xbox.XboxCloudGames.load(ctx) }
|
||||
// Add and Remove replace each other; the controller focus moves to the new button instead of getting lost.
|
||||
val slot = remember { androidx.compose.ui.focus.FocusRequester() }
|
||||
val inputMode = androidx.compose.ui.platform.LocalInputModeManager.current
|
||||
val scope = rememberCoroutineScope()
|
||||
fun refocus() { if (inputMode.inputMode == androidx.compose.ui.input.InputMode.Keyboard) scope.launch { focusSoon { slot } } }
|
||||
if (com.droiddeck.launcher.stores.xbox.XboxCloudGames.isAdded(item.id)) {
|
||||
ActionChip("In Games", ok = true)
|
||||
SecondaryButton("Remove from Games", compact = true, modifier = Modifier.focusRequester(slot)) {
|
||||
com.droiddeck.launcher.stores.xbox.XboxCloudGames.remove(ctx, item.id); refocus()
|
||||
}
|
||||
} else SecondaryButton("Add to Games", modifier = Modifier.focusRequester(slot)) { com.droiddeck.launcher.stores.xbox.XboxCloudGames.add(ctx, item); refocus() }
|
||||
}
|
||||
@@ -97,6 +97,8 @@ import androidx.compose.material.icons.filled.Search
|
||||
import androidx.compose.material.icons.automirrored.filled.Login
|
||||
import androidx.compose.material.icons.filled.GridView
|
||||
import androidx.compose.material.icons.filled.Sort
|
||||
import androidx.compose.material.icons.filled.FilterList
|
||||
import com.droiddeck.launcher.stores.xbox.XboxLibraryFilter
|
||||
import androidx.compose.material.icons.filled.ViewList
|
||||
import androidx.compose.material.icons.filled.ViewModule
|
||||
import com.droiddeck.launcher.stores.sortCatalogItems
|
||||
@@ -290,6 +292,11 @@ internal fun StoresPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier
|
||||
if (id != DOWNLOADS) tab = tabFor(Store.byId(id), if (s.storesOpenTab == SessionPrefs.STORES_OPEN_STORE) "store" else "library")
|
||||
move("first")
|
||||
}
|
||||
LaunchedEffect(StoresState.openGameRequest) {
|
||||
val key = StoresState.openGameRequest ?: return@LaunchedEffect
|
||||
StoresState.openGameRequest = null
|
||||
Store.byId(key.substringBefore(':'))?.let { store -> chip = store.id; tab = tabFor(store, "library"); query = ""; open(key) }
|
||||
}
|
||||
var focusedChip by remember { mutableStateOf<String?>(null) }
|
||||
LaunchedEffect(focusedChip) {
|
||||
val id = focusedChip ?: return@LaunchedEffect
|
||||
@@ -503,7 +510,8 @@ internal fun StoresPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier
|
||||
if (detailStore != null) Column(
|
||||
Modifier.fillMaxWidth()
|
||||
.onFocusChanged { detailFocused = it.hasFocus }
|
||||
.focusProperties { exit = { if (coveringNow.value) androidx.compose.ui.focus.FocusRequester.Cancel else androidx.compose.ui.focus.FocusRequester.Default } }
|
||||
// A step opened from the page (install location, uninstall) sits outside it and has to receive the focus.
|
||||
.focusProperties { exit = { if (coveringNow.value && !StoresMotion.stepOpen) androidx.compose.ui.focus.FocusRequester.Cancel else androidx.compose.ui.focus.FocusRequester.Default } }
|
||||
.focusGroup(),
|
||||
) { StoreGameDetail(detailStore, key, s, a, heroFocus, onBack = { closeGame() }) }
|
||||
}
|
||||
@@ -977,8 +985,10 @@ private fun Storefront(
|
||||
}
|
||||
val isSizeSort = tab == "library" && (sort == "sizeAsc" || sort == "sizeDesc")
|
||||
val browseItems = if (browsing) ItchBrowseState.items else emptyList()
|
||||
val candidates = remember(library, everything, tab, q, s.storesShowMature, browsing, browseItems) {
|
||||
if (tab == "library") library.filter(::matches)
|
||||
LaunchedEffect(Unit) { XboxLibraryFilter.load(ctx) }
|
||||
val xboxFilter = if (store == Store.XBOX) XboxLibraryFilter.current else XboxLibraryFilter.ALL
|
||||
val candidates = remember(library, everything, tab, q, s.storesShowMature, browsing, browseItems, xboxFilter) {
|
||||
if (tab == "library") library.filter { matches(it) && XboxLibraryFilter.keeps(xboxFilter, it) }
|
||||
else if (browsing) {
|
||||
val owned = library.associateBy { it.id }
|
||||
browseItems.map { owned[it.id] ?: it }.filter(::shown)
|
||||
@@ -1083,8 +1093,10 @@ private fun Storefront(
|
||||
item(key = "header", span = { GridItemSpan(maxLineSpan) }) {
|
||||
Rise(1) {
|
||||
val tabs = tabsFor(store)
|
||||
val libraryLabel = if (loaded) stringResource(R.string.stores_tab_count, stringResource(R.string.stores_tab_library), library.size)
|
||||
else stringResource(R.string.stores_tab_library)
|
||||
val libraryName = if (xboxFilter == XboxLibraryFilter.ALL) stringResource(R.string.stores_tab_library)
|
||||
else stringResource(R.string.stores_tab_library) + " · " + XboxLibraryFilter.label(xboxFilter)
|
||||
val libraryLabel = if (loaded) stringResource(R.string.stores_tab_count, libraryName, library.count { XboxLibraryFilter.keeps(xboxFilter, it) })
|
||||
else libraryName
|
||||
ModeHeader(
|
||||
libraryLabel,
|
||||
query, onQuery,
|
||||
@@ -1096,6 +1108,7 @@ private fun Storefront(
|
||||
} },
|
||||
) {
|
||||
if (tab == "library") {
|
||||
if (store == Store.XBOX) XboxFilterButton()
|
||||
SortButton(s, a)
|
||||
ViewButton(s, a)
|
||||
}
|
||||
@@ -1104,6 +1117,9 @@ private fun Storefront(
|
||||
else { EpicClient.install(ctx); StoresState.openDownloads = true }
|
||||
}
|
||||
SmallTextButton(stringResource(R.string.stores_refresh)) { StoresState.open(ctx, store, force = true) }
|
||||
if (store == Store.XBOX) SmallTextButton("Cloud settings") {
|
||||
ctx.startActivity(android.content.Intent(ctx, com.droiddeck.launcher.stores.xbox.XboxCloudSettingsActivity::class.java))
|
||||
}
|
||||
val name = StoresState.accounts[store] ?: ""
|
||||
SignOutButton(store, name)
|
||||
}
|
||||
@@ -1335,6 +1351,38 @@ private fun SortButton(s: FrontEndState, a: FrontEndActions) {
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun XboxFilterButton() {
|
||||
val pal = LocalPalette.current
|
||||
val ctx = LocalContext.current
|
||||
val title = "Show"
|
||||
var at by remember { mutableStateOf<Rect?>(null) }
|
||||
Box(Modifier.onGloballyPositioned { at = it.boundsInRoot() }) {
|
||||
HeaderIconButton(title, Icons.Filled.FilterList, "xbox-filter") {
|
||||
val from = at ?: return@HeaderIconButton
|
||||
StoresMotion.ask(StepAsk(
|
||||
anchor = from, side = StepSide.Left, accent = pal.signal, pillCorner = 8.dp, items = XboxLibraryFilter.ALL_FILTERS.size,
|
||||
onDismiss = {},
|
||||
handle = { Text(title, fontSize = 12.sp, fontWeight = FontWeight.SemiBold, color = pal.signal, maxLines = 1, overflow = TextOverflow.Ellipsis) },
|
||||
) {
|
||||
StepTitle(title)
|
||||
StepList {
|
||||
XboxLibraryFilter.ALL_FILTERS.forEachIndexed { i, filter ->
|
||||
StepChoice(
|
||||
XboxLibraryFilter.label(filter), selected = filter == XboxLibraryFilter.current, enabled = open,
|
||||
modifier = Modifier.fillMaxWidth().stepItem(i)
|
||||
.then(if (filter == XboxLibraryFilter.current) Modifier.focusRequester(first) else Modifier),
|
||||
) {
|
||||
XboxLibraryFilter.set(ctx, filter)
|
||||
StoresMotion.fold()
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun ViewButton(s: FrontEndState, a: FrontEndActions) {
|
||||
val views = SessionPrefs.STORES_VIEWS
|
||||
|
||||
@@ -56,7 +56,7 @@ import java.io.File
|
||||
private fun installable(name: String, all: Map<String, WinComponents.Component>): String = WinComponents.installable(name, all)
|
||||
|
||||
@Composable
|
||||
private fun originName(origin: String): String = stringResource(
|
||||
private fun originName(origin: String): String = if (origin == WinCompSources.Origin.XBOX.name) "Xbox" else stringResource(
|
||||
when (origin) {
|
||||
WinCompSources.Origin.GOG.name -> R.string.wincomp_src_gog
|
||||
WinCompSources.Origin.EPIC.name -> R.string.wincomp_src_epic
|
||||
@@ -71,6 +71,7 @@ private fun autoReason(r: WinComponents.AutoReason): String = when (r.kind) {
|
||||
WinCompSources.Origin.GOG.name -> stringResource(R.string.wincomp_auto_gog)
|
||||
WinCompSources.Origin.EPIC.name -> stringResource(R.string.wincomp_auto_epic)
|
||||
WinCompSources.Origin.AMAZON.name -> stringResource(R.string.wincomp_auto_amazon)
|
||||
WinCompSources.Origin.XBOX.name -> "Xbox games install it with the game (${r.args.getOrElse(0) { "VC14" }})"
|
||||
else -> ""
|
||||
}
|
||||
|
||||
|
||||
@@ -307,6 +307,13 @@ public final class WaylandCompositor {
|
||||
|
||||
public static native float[] nativeFrameGenStats();
|
||||
|
||||
/** Stream mode: the scene is the Xbox Cloud Gaming native player's picture, handed over frame by frame. */
|
||||
public static native void nativeStreamMode(boolean on);
|
||||
|
||||
public static native void nativeStreamFrame(android.hardware.HardwareBuffer buffer);
|
||||
|
||||
public static native int nativeStreamFrames();
|
||||
|
||||
public static void sendPointerDelta(int dx, int dy) {
|
||||
if (dx == 0 && dy == 0) return;
|
||||
nativeSendSceneInput(6, dx * 256, dy * 256);
|
||||
|
||||
@@ -0,0 +1,257 @@
|
||||
package org.webrtc;
|
||||
|
||||
import android.graphics.ImageFormat;
|
||||
import android.media.Image;
|
||||
import android.media.ImageReader;
|
||||
import android.media.MediaCodec;
|
||||
import android.media.MediaCodecInfo;
|
||||
import android.media.MediaCodecList;
|
||||
import android.media.MediaCrypto;
|
||||
import android.media.MediaFormat;
|
||||
import android.os.Build;
|
||||
import android.os.Bundle;
|
||||
import android.os.Handler;
|
||||
import android.os.HandlerThread;
|
||||
import android.os.SystemClock;
|
||||
import android.view.Surface;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.HashMap;
|
||||
|
||||
/**
|
||||
* DroidDeck's hardware video decoder factory for the native Xbox Cloud Gaming player. It builds WebRTC's own
|
||||
* AndroidVideoDecoder (hence this package) around a MediaCodec wrapper that can:
|
||||
* - ask the decoder for low-latency output (Android's KEY_LOW_LATENCY and Qualcomm's low-latency / picture-order
|
||||
* vendor keys; unknown keys are ignored, and a decoder that refuses them is configured without them);
|
||||
* - for zero-copy, decode straight onto the player's SurfaceView instead of WebRTC's texture, rendering every
|
||||
* output buffer there (no GL copy, no compositor; WebRTC then gets no decoded frames to draw).
|
||||
* Without either option it behaves like WebRTC's HardwareVideoDecoderFactory.
|
||||
* The route is switchable while the decoder runs (setOutputSurface): {@link #useScreen} sends frames straight to the
|
||||
* screen (zero-copy) or, with null, back to WebRTC's texture (for the Vulkan compositor and frame generation);
|
||||
* {@link #setZeroCopySurface} moves a zero-copy decoder to a stand-in surface while the screen surface is gone.
|
||||
* The factory also reports the decoded size and the decode time (input queued to output ready), which WebRTC's
|
||||
* stats lack in zero-copy.
|
||||
*/
|
||||
public class DroidDeckLowLatencyDecoderFactory implements VideoDecoderFactory {
|
||||
/** Counts frames sent to the display in zero-copy mode (WebRTC's own stats see none). */
|
||||
public interface FrameCounter { void onFrameShown(); }
|
||||
|
||||
private final HardwareVideoDecoderFactory hardware;
|
||||
private final EglBase.Context sharedContext;
|
||||
private final boolean lowLatency;
|
||||
/** Frames go to {@link #zeroCopySurface} (the screen or the stand-in), not WebRTC's texture. */
|
||||
private volatile boolean zeroCopy;
|
||||
private volatile Surface zeroCopySurface;
|
||||
/** Back on WebRTC's texture: render the next buffer there, so WebRTC's pending texture frame completes. */
|
||||
private volatile boolean renderNext;
|
||||
private final FrameCounter counter;
|
||||
private volatile Wrapper live;
|
||||
private ImageReader standIn;
|
||||
private HandlerThread standInThread;
|
||||
private volatile int width, height;
|
||||
private final Object decodeLock = new Object();
|
||||
private final HashMap<Long, Long> queuedAt = new HashMap<>();
|
||||
private double decodeSumMs;
|
||||
private int decodeCount;
|
||||
|
||||
public DroidDeckLowLatencyDecoderFactory(EglBase.Context sharedContext, boolean lowLatency, Surface zeroCopySurface, FrameCounter counter) {
|
||||
this.hardware = new HardwareVideoDecoderFactory(sharedContext);
|
||||
this.sharedContext = sharedContext;
|
||||
this.lowLatency = lowLatency;
|
||||
this.zeroCopy = zeroCopySurface != null;
|
||||
this.zeroCopySurface = zeroCopySurface;
|
||||
this.counter = counter;
|
||||
}
|
||||
|
||||
/**
|
||||
* Zero-copy: the surface to decode onto from now on; null = a stand-in that drops every frame (the screen
|
||||
* surface is being destroyed). Must be called before a destroyed surface's callback returns.
|
||||
*/
|
||||
public synchronized void setZeroCopySurface(Surface surface) {
|
||||
if (!zeroCopy) return;
|
||||
moveTo(surface != null ? surface : standInSurface(), surface != null ? "the screen" : "a stand-in");
|
||||
}
|
||||
|
||||
/**
|
||||
* Switch the route live: a surface = zero-copy onto it; null = WebRTC's texture again. Returns false when the
|
||||
* decoder refused the new surface (the route is then unchanged).
|
||||
*/
|
||||
public synchronized boolean useScreen(Surface screen) {
|
||||
if (screen != null) {
|
||||
Wrapper w = live;
|
||||
if (w != null && !moveTo(screen, "the screen")) return false;
|
||||
zeroCopySurface = screen;
|
||||
zeroCopy = true;
|
||||
return true;
|
||||
}
|
||||
if (!zeroCopy) return true;
|
||||
Wrapper w = live;
|
||||
if (w != null && w.texture != null && !moveTo(w.texture, "WebRTC's texture")) return false;
|
||||
zeroCopy = false;
|
||||
renderNext = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
private boolean moveTo(Surface target, String what) {
|
||||
Wrapper w = live;
|
||||
if (w == null || target == null) { if (zeroCopy) zeroCopySurface = target; return true; }
|
||||
try {
|
||||
w.raw.setOutputSurface(target);
|
||||
if (zeroCopy) zeroCopySurface = target;
|
||||
Logging.d("DroidDeckDecoder", "decoder output moved to " + what);
|
||||
return true;
|
||||
} catch (RuntimeException e) {
|
||||
Logging.w("DroidDeckDecoder", "decoder output change to " + what + " failed: " + e);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private Surface standInSurface() {
|
||||
if (standIn == null) {
|
||||
standInThread = new HandlerThread("bl-decoder-standin");
|
||||
standInThread.start();
|
||||
standIn = ImageReader.newInstance(Math.max(width, 16), Math.max(height, 16), ImageFormat.PRIVATE, 3);
|
||||
standIn.setOnImageAvailableListener(reader -> {
|
||||
Image image = reader.acquireLatestImage();
|
||||
if (image != null) image.close();
|
||||
}, new Handler(standInThread.getLooper()));
|
||||
}
|
||||
return standIn.getSurface();
|
||||
}
|
||||
|
||||
/** The decoder's picture size, or null before the first decoder is configured. */
|
||||
public String videoSize() {
|
||||
return width > 0 ? width + "x" + height : null;
|
||||
}
|
||||
|
||||
/** Average decode time since the last call, in ms (-1 when no frame was decoded in between). */
|
||||
public double takeDecodeMs() {
|
||||
synchronized (decodeLock) {
|
||||
double avg = decodeCount > 0 ? decodeSumMs / decodeCount : -1;
|
||||
decodeSumMs = 0; decodeCount = 0;
|
||||
return avg;
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized void release() {
|
||||
if (standIn != null) { standIn.close(); standIn = null; }
|
||||
if (standInThread != null) { standInThread.quitSafely(); standInThread = null; }
|
||||
}
|
||||
|
||||
@Override
|
||||
public VideoCodecInfo[] getSupportedCodecs() {
|
||||
return hardware.getSupportedCodecs();
|
||||
}
|
||||
|
||||
@Override
|
||||
public VideoDecoder createDecoder(VideoCodecInfo info) {
|
||||
VideoCodecMimeType type;
|
||||
try { type = VideoCodecMimeType.valueOf(info.getName()); } catch (IllegalArgumentException e) { return hardware.createDecoder(info); }
|
||||
MediaCodecInfo codec = findHardwareDecoder(type);
|
||||
if (codec == null) return hardware.createDecoder(info);
|
||||
Integer color = MediaCodecUtils.selectColorFormat(MediaCodecUtils.DECODER_COLOR_FORMATS, codec.getCapabilitiesForType(type.mimeType()));
|
||||
if (color == null) return hardware.createDecoder(info);
|
||||
return new AndroidVideoDecoder(new WrapperFactory(), codec.getName(), type, color, sharedContext);
|
||||
}
|
||||
|
||||
private static MediaCodecInfo findHardwareDecoder(VideoCodecMimeType type) {
|
||||
for (MediaCodecInfo info : new MediaCodecList(MediaCodecList.REGULAR_CODECS).getCodecInfos()) {
|
||||
if (info.isEncoder()) continue;
|
||||
if (MediaCodecUtils.codecSupportsType(info, type) && MediaCodecUtils.isHardwareAccelerated(info)) return info;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private class WrapperFactory implements MediaCodecWrapperFactory {
|
||||
@Override
|
||||
public MediaCodecWrapper createByCodecName(String name) throws IOException {
|
||||
return new Wrapper(MediaCodec.createByCodecName(name));
|
||||
}
|
||||
}
|
||||
|
||||
/** MediaCodec itself (not WebRTC's wrapper) so the output surface can be changed while it runs. */
|
||||
private class Wrapper implements MediaCodecWrapper {
|
||||
final MediaCodec raw;
|
||||
/** WebRTC's texture surface, the route back from zero-copy. */
|
||||
Surface texture;
|
||||
Wrapper(MediaCodec raw) { this.raw = raw; }
|
||||
|
||||
@Override
|
||||
public void configure(MediaFormat format, Surface surface, MediaCrypto crypto, int flags) {
|
||||
width = format.getInteger(MediaFormat.KEY_WIDTH);
|
||||
height = format.getInteger(MediaFormat.KEY_HEIGHT);
|
||||
texture = surface;
|
||||
live = this;
|
||||
Surface target = surface;
|
||||
if (zeroCopy) { synchronized (DroidDeckLowLatencyDecoderFactory.this) { target = zeroCopySurface != null ? zeroCopySurface : standInSurface(); } }
|
||||
if (lowLatency) {
|
||||
MediaFormat fast = MediaFormat.createVideoFormat(format.getString(MediaFormat.KEY_MIME), width, height);
|
||||
copyInt(format, fast, MediaFormat.KEY_COLOR_FORMAT);
|
||||
if (Build.VERSION.SDK_INT >= 30) fast.setInteger(MediaFormat.KEY_LOW_LATENCY, 1);
|
||||
fast.setInteger(MediaFormat.KEY_PRIORITY, 0);
|
||||
fast.setInteger("vendor.qti-ext-dec-low-latency.enable", 1);
|
||||
fast.setInteger("vendor.qti-ext-dec-picture-order.enable", 1);
|
||||
try {
|
||||
raw.configure(fast, target, crypto, flags);
|
||||
Logging.d("DroidDeckDecoder", "low-latency decoder configured" + (zeroCopy ? " (zero-copy)" : ""));
|
||||
return;
|
||||
} catch (RuntimeException e) {
|
||||
Logging.w("DroidDeckDecoder", "decoder refused low-latency keys: " + e);
|
||||
}
|
||||
}
|
||||
raw.configure(format, target, crypto, flags);
|
||||
}
|
||||
|
||||
private void copyInt(MediaFormat from, MediaFormat to, String key) {
|
||||
if (from.containsKey(key)) to.setInteger(key, from.getInteger(key));
|
||||
}
|
||||
|
||||
// Zero-copy: AndroidVideoDecoder renders one buffer to its texture and drops the rest until the texture
|
||||
// hands the frame back, which never happens with the display surface; show every buffer instead.
|
||||
@Override public void releaseOutputBuffer(int index, boolean render) {
|
||||
if (zeroCopy) { raw.releaseOutputBuffer(index, true); if (counter != null) counter.onFrameShown(); }
|
||||
else if (renderNext) { renderNext = false; raw.releaseOutputBuffer(index, true); }
|
||||
else raw.releaseOutputBuffer(index, render);
|
||||
}
|
||||
|
||||
@Override public void queueInputBuffer(int index, int offset, int size, long presentationTimeUs, int flags) {
|
||||
synchronized (decodeLock) {
|
||||
if (queuedAt.size() > 64) queuedAt.clear();
|
||||
queuedAt.put(presentationTimeUs, SystemClock.elapsedRealtimeNanos());
|
||||
}
|
||||
raw.queueInputBuffer(index, offset, size, presentationTimeUs, flags);
|
||||
}
|
||||
|
||||
@Override public int dequeueOutputBuffer(MediaCodec.BufferInfo info, long timeoutUs) {
|
||||
int index = raw.dequeueOutputBuffer(info, timeoutUs);
|
||||
if (index >= 0) synchronized (decodeLock) {
|
||||
Long at = queuedAt.remove(info.presentationTimeUs);
|
||||
if (at != null) { decodeSumMs += (SystemClock.elapsedRealtimeNanos() - at) / 1e6; decodeCount++; }
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
@Override public MediaFormat getOutputFormat() {
|
||||
MediaFormat f = raw.getOutputFormat();
|
||||
if (f.containsKey(MediaFormat.KEY_WIDTH) && f.containsKey(MediaFormat.KEY_HEIGHT)) {
|
||||
width = f.containsKey("crop-right") ? f.getInteger("crop-right") - f.getInteger("crop-left") + 1 : f.getInteger(MediaFormat.KEY_WIDTH);
|
||||
height = f.containsKey("crop-bottom") ? f.getInteger("crop-bottom") - f.getInteger("crop-top") + 1 : f.getInteger(MediaFormat.KEY_HEIGHT);
|
||||
}
|
||||
return f;
|
||||
}
|
||||
|
||||
@Override public void start() { raw.start(); }
|
||||
@Override public void flush() { synchronized (decodeLock) { queuedAt.clear(); } raw.flush(); }
|
||||
@Override public void stop() { raw.stop(); }
|
||||
@Override public void release() { if (live == this) live = null; raw.release(); }
|
||||
@Override public int dequeueInputBuffer(long timeoutUs) { return raw.dequeueInputBuffer(timeoutUs); }
|
||||
@Override public MediaFormat getInputFormat() { return raw.getInputFormat(); }
|
||||
@Override public MediaFormat getOutputFormat(int index) { return raw.getOutputFormat(index); }
|
||||
@Override public ByteBuffer getInputBuffer(int index) { return raw.getInputBuffer(index); }
|
||||
@Override public ByteBuffer getOutputBuffer(int index) { return raw.getOutputBuffer(index); }
|
||||
@Override public Surface createInputSurface() { return raw.createInputSurface(); }
|
||||
@Override public void setParameters(Bundle params) { raw.setParameters(params); }
|
||||
@Override public MediaCodecInfo getCodecInfo() { return raw.getCodecInfo(); }
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user