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:
The412Banner authored and GitHub committed 2026-10-24 23:17:57 -04:00
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(); }
}
}