mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 12:56:06 +00:00
GeForce NOW store: sign-in, game list and native player
- GfnCore: OpenNOW's core service as a child process (newline-delimited JSON); turns OpenNOW's analytics and crash reports off. - GfnStreamer: the JNI streamer engine with a polling thread for answers and events. - GfnActivity: NVIDIA device sign-in (code + link), NVIDIA's full game list with search, games in the account's library marked. - GfnPlayerActivity: catalog.launch.inspect -> session.create -> queue polling -> streamer.prepare -> start, onto a SurfaceView; controllers mapped to XInput like OpenNOW; leaving asks first and ends the session. - Stores page: a GeForce NOW chip opens it. Both screens run in their own :gfn process. Not compiled locally (no Android SDK here); CI is the first compile.
This commit is contained in:
1 parent
6f5db08efb
commit
53b5fde2ff
6 files changed
+743
No files matched your search
@@ -180,6 +180,17 @@
|
||||
android:configChanges="keyboard|keyboardHidden|orientation|screenSize|screenLayout|smallestScreenSize|density|navigation|uiMode"
|
||||
android:theme="@style/AppTheme" />
|
||||
|
||||
<!-- GeForce NOW (OpenNOW's core and streamer): both screens share the :gfn process with the core child. -->
|
||||
<activity android:name=".stores.gfn.GfnActivity" android:exported="false"
|
||||
android:process=":gfn" android:launchMode="singleTop"
|
||||
android:configChanges="keyboard|keyboardHidden|orientation|screenSize|screenLayout|smallestScreenSize|density|navigation|uiMode"
|
||||
android:theme="@style/AppTheme" />
|
||||
|
||||
<activity android:name=".stores.gfn.GfnPlayerActivity" android:exported="false"
|
||||
android:process=":gfn" android:screenOrientation="sensorLandscape" android:hardwareAccelerated="true"
|
||||
android:configChanges="keyboard|keyboardHidden|orientation|screenSize|screenLayout|smallestScreenSize|density|navigation|uiMode"
|
||||
android:theme="@style/AppTheme" />
|
||||
|
||||
<activity android:name=".stores.xbox.XboxCloudSettingsActivity" android:exported="false"
|
||||
android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize|density"
|
||||
android:theme="@style/AppTheme" />
|
||||
|
||||
@@ -0,0 +1,251 @@
|
||||
package com.droiddeck.launcher.stores.gfn
|
||||
|
||||
import android.content.Intent
|
||||
import android.net.Uri
|
||||
import android.os.Bundle
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.activity.compose.setContent
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Box
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.Spacer
|
||||
import androidx.compose.foundation.layout.aspectRatio
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.height
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.width
|
||||
import androidx.compose.foundation.lazy.grid.GridCells
|
||||
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
|
||||
import androidx.compose.foundation.lazy.grid.items
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material3.Button
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.OutlinedButton
|
||||
import androidx.compose.material3.OutlinedTextField
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.rememberCoroutineScope
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.draw.clip
|
||||
import androidx.compose.ui.layout.ContentScale
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.text.style.TextOverflow
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.unit.sp
|
||||
import coil.compose.AsyncImage
|
||||
import com.droiddeck.launcher.ui.DroidDeckTheme
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withContext
|
||||
import org.json.JSONObject
|
||||
|
||||
/** GeForce NOW: sign in with an NVIDIA account, browse the games GeForce NOW offers, and play one. */
|
||||
class GfnActivity : ComponentActivity() {
|
||||
data class Game(val id: String, val variantId: String, val title: String, val store: String,
|
||||
val imageUrl: String, val inLibrary: Boolean, val search: String)
|
||||
|
||||
private sealed interface Screen {
|
||||
data object Loading : Screen
|
||||
data class SignedOut(val error: String? = null) : Screen
|
||||
data class Code(val userCode: String, val url: String, val attemptId: String, val intervalMs: Long) : Screen
|
||||
data class Games(val user: String, val games: List<Game>) : Screen
|
||||
data class Failed(val message: String) : Screen
|
||||
}
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
setContent { DroidDeckTheme { Content() } }
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun Content() {
|
||||
var screen by remember { mutableStateOf<Screen>(Screen.Loading) }
|
||||
val scope = rememberCoroutineScope()
|
||||
val load: () -> Unit = {
|
||||
screen = Screen.Loading
|
||||
scope.launch { screen = withContext(Dispatchers.IO) { loadSignedIn() } }
|
||||
}
|
||||
LaunchedEffect(Unit) { load() }
|
||||
Column(Modifier.fillMaxSize().background(MaterialTheme.colorScheme.background)) {
|
||||
Row(Modifier.fillMaxWidth().padding(16.dp), verticalAlignment = Alignment.CenterVertically) {
|
||||
OutlinedButton(onClick = { finish() }) { Text("Back") }
|
||||
Text("GeForce NOW", style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold,
|
||||
color = MaterialTheme.colorScheme.onBackground, modifier = Modifier.padding(horizontal = 16.dp).weight(1f))
|
||||
val current = screen
|
||||
if (current is Screen.Games) {
|
||||
Text(current.user, color = MaterialTheme.colorScheme.onBackground, modifier = Modifier.padding(end = 12.dp))
|
||||
OutlinedButton(onClick = {
|
||||
scope.launch {
|
||||
withContext(Dispatchers.IO) { runCatching { GfnCore.request(this@GfnActivity, "auth.logout") } }
|
||||
screen = Screen.SignedOut()
|
||||
}
|
||||
}) { Text("Sign out") }
|
||||
}
|
||||
}
|
||||
Text("Unofficial client built on OpenNOW. NVIDIA does not support third-party GeForce NOW apps.",
|
||||
color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.6f), fontSize = 12.sp,
|
||||
modifier = Modifier.padding(horizontal = 16.dp))
|
||||
when (val current = screen) {
|
||||
Screen.Loading -> Message("Loading…")
|
||||
is Screen.Failed -> Column(Modifier.padding(24.dp)) {
|
||||
Text(current.message, color = MaterialTheme.colorScheme.onBackground)
|
||||
Spacer(Modifier.height(12.dp))
|
||||
Button(onClick = load) { Text("Try again") }
|
||||
}
|
||||
is Screen.SignedOut -> Column(Modifier.padding(24.dp)) {
|
||||
Text("Sign in with your NVIDIA account to play your GeForce NOW games.",
|
||||
color = MaterialTheme.colorScheme.onBackground)
|
||||
current.error?.let { Text(it, color = MaterialTheme.colorScheme.error, modifier = Modifier.padding(top = 8.dp)) }
|
||||
Spacer(Modifier.height(16.dp))
|
||||
Button(onClick = {
|
||||
scope.launch {
|
||||
screen = withContext(Dispatchers.IO) {
|
||||
runCatching { startSignIn() }.getOrElse { Screen.SignedOut(it.message) }
|
||||
}
|
||||
}
|
||||
}) { Text("Sign in") }
|
||||
}
|
||||
is Screen.Code -> {
|
||||
SignInCode(current) {
|
||||
startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(current.url)))
|
||||
}
|
||||
LaunchedEffect(current.attemptId) {
|
||||
screen = withContext(Dispatchers.IO) { waitForSignIn(current) }
|
||||
}
|
||||
}
|
||||
is Screen.Games -> GameGrid(current.games) { game -> play(game) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun Message(text: String) {
|
||||
Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
|
||||
Text(text, color = MaterialTheme.colorScheme.onBackground)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun SignInCode(code: Screen.Code, openBrowser: () -> Unit) {
|
||||
Column(Modifier.padding(24.dp)) {
|
||||
Text("On this phone or another device, open", color = MaterialTheme.colorScheme.onBackground)
|
||||
Text(code.url, color = MaterialTheme.colorScheme.primary, fontWeight = FontWeight.Bold, modifier = Modifier.padding(vertical = 6.dp))
|
||||
Text("and enter this code:", color = MaterialTheme.colorScheme.onBackground)
|
||||
Text(code.userCode, fontSize = 34.sp, fontWeight = FontWeight.Bold, color = MaterialTheme.colorScheme.onBackground,
|
||||
modifier = Modifier.padding(vertical = 12.dp))
|
||||
Button(onClick = openBrowser) { Text("Open the sign-in page") }
|
||||
Text("Waiting for you to sign in…", color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.7f),
|
||||
modifier = Modifier.padding(top = 12.dp))
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun GameGrid(games: List<Game>, onPlay: (Game) -> Unit) {
|
||||
var query by remember { mutableStateOf("") }
|
||||
val shown = remember(games, query) {
|
||||
val words = query.trim().lowercase().split(' ').filter { it.isNotEmpty() }
|
||||
games.filter { game -> words.all { game.search.contains(it) } }
|
||||
}
|
||||
Column {
|
||||
OutlinedTextField(value = query, onValueChange = { query = it }, singleLine = true,
|
||||
label = { Text("Search ${games.size} games") },
|
||||
modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp))
|
||||
LazyVerticalGrid(columns = GridCells.Adaptive(220.dp), modifier = Modifier.fillMaxSize(),
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp), verticalArrangement = Arrangement.spacedBy(12.dp),
|
||||
contentPadding = androidx.compose.foundation.layout.PaddingValues(16.dp)) {
|
||||
items(shown, key = { it.id }) { game ->
|
||||
Column(Modifier.clip(RoundedCornerShape(10.dp)).background(MaterialTheme.colorScheme.surfaceVariant)
|
||||
.clickable { onPlay(game) }) {
|
||||
AsyncImage(model = game.imageUrl, contentDescription = game.title, contentScale = ContentScale.Crop,
|
||||
modifier = Modifier.fillMaxWidth().aspectRatio(460f / 215f))
|
||||
Text(game.title, maxLines = 1, overflow = TextOverflow.Ellipsis, fontWeight = FontWeight.SemiBold,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 10.dp, top = 8.dp, end = 10.dp))
|
||||
Text(game.store + if (game.inLibrary) " · in your library" else "", fontSize = 12.sp,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.7f),
|
||||
modifier = Modifier.padding(start = 10.dp, bottom = 8.dp, end = 10.dp).width(200.dp))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun play(game: Game) {
|
||||
startActivity(Intent(this, GfnPlayerActivity::class.java)
|
||||
.putExtra(GfnPlayerActivity.EXTRA_APP_ID, game.id)
|
||||
.putExtra(GfnPlayerActivity.EXTRA_VARIANT_ID, game.variantId)
|
||||
.putExtra(GfnPlayerActivity.EXTRA_TITLE, game.title))
|
||||
}
|
||||
|
||||
private fun loadSignedIn(): Screen = runCatching {
|
||||
val auth = GfnCore.request(this, "auth.session.get")
|
||||
val user = auth.optJSONObject("session")?.optJSONObject("user") ?: auth.optJSONObject("user")
|
||||
if (user == null || user.optString("userId").isEmpty()) return Screen.SignedOut()
|
||||
Screen.Games(user.optString("displayName").ifEmpty { "Signed in" }, loadGames())
|
||||
}.getOrElse { Screen.Failed(it.message ?: "GeForce NOW could not start.") }
|
||||
|
||||
/** NVIDIA's full list (public catalog), marking the games in the account's library. */
|
||||
private fun loadGames(): List<Game> {
|
||||
val owned = runCatching { gamesOf(GfnCore.request(this, "catalog.library.list", JSONObject().put("limit", 100))) }
|
||||
.getOrDefault(emptyList()).map { it.id }.toSet()
|
||||
return gamesOf(GfnCore.request(this, "catalog.public.list", timeoutMs = 60_000))
|
||||
.map { if (it.id in owned) it.copy(inLibrary = true) else it }
|
||||
.sortedBy { it.title.lowercase() }
|
||||
}
|
||||
|
||||
private fun gamesOf(result: JSONObject): List<Game> {
|
||||
val list = result.optJSONArray("games") ?: return emptyList()
|
||||
return (0 until list.length()).mapNotNull { index ->
|
||||
val game = list.optJSONObject(index) ?: return@mapNotNull null
|
||||
val variants = game.optJSONArray("variants")
|
||||
val variant = variants?.optJSONObject(game.optInt("selectedVariantIndex", 0).coerceIn(0, (variants.length() - 1).coerceAtLeast(0)))
|
||||
Game(id = game.optString("id"),
|
||||
variantId = variant?.optString("id").orEmpty().ifEmpty { game.optString("launchAppId") },
|
||||
title = game.optString("title"),
|
||||
store = variant?.optString("store").orEmpty(),
|
||||
imageUrl = game.optString("imageUrl"),
|
||||
inLibrary = game.optBoolean("isInLibrary"),
|
||||
search = game.optString("searchText").ifEmpty { game.optString("title").lowercase() })
|
||||
}.filter { it.id.isNotEmpty() && it.variantId.isNotEmpty() }
|
||||
}
|
||||
|
||||
private fun startSignIn(): Screen {
|
||||
val challenge = GfnCore.request(this, "auth.device.start")
|
||||
return Screen.Code(
|
||||
userCode = challenge.optString("userCode"),
|
||||
url = challenge.optString("verificationUriComplete").ifEmpty { challenge.optString("verificationUri") },
|
||||
attemptId = challenge.optString("attemptId"),
|
||||
intervalMs = (challenge.optDouble("intervalSeconds", 5.0) * 1000).toLong().coerceAtLeast(1000))
|
||||
}
|
||||
|
||||
private suspend fun waitForSignIn(code: Screen.Code): Screen {
|
||||
var interval = code.intervalMs
|
||||
while (true) {
|
||||
delay(interval)
|
||||
val poll = runCatching { GfnCore.request(this, "auth.device.poll", JSONObject().put("attemptId", code.attemptId)) }
|
||||
.getOrElse { return Screen.SignedOut(it.message) }
|
||||
when (poll.optString("status")) {
|
||||
"authorized" -> {
|
||||
runCatching {
|
||||
GfnCore.request(this, "auth.device.complete",
|
||||
JSONObject().put("attemptId", code.attemptId).put("staySignedIn", true))
|
||||
}.onFailure { return Screen.SignedOut(it.message) }
|
||||
return loadSignedIn()
|
||||
}
|
||||
"pending", "slow_down" -> interval = poll.optLong("retryAfterMs",
|
||||
(poll.optDouble("intervalSeconds", interval / 1000.0) * 1000).toLong()).coerceAtLeast(1000)
|
||||
else -> return Screen.SignedOut(poll.optString("message").ifEmpty { "Sign-in did not finish. Try again." })
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
package com.droiddeck.launcher.stores.gfn
|
||||
|
||||
import android.content.Context
|
||||
import android.util.Log
|
||||
import org.json.JSONObject
|
||||
import java.io.BufferedWriter
|
||||
import java.io.File
|
||||
import java.util.concurrent.CompletableFuture
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
import java.util.concurrent.TimeUnit
|
||||
import java.util.concurrent.TimeoutException
|
||||
import java.util.concurrent.atomic.AtomicLong
|
||||
|
||||
class GfnError(val code: String, message: String) : Exception(message)
|
||||
|
||||
/**
|
||||
* OpenNOW's core service (external/opennow, MIT, by Zortos) as a child process: sign-in, the
|
||||
* GeForce NOW catalog and CloudMatch sessions, spoken as newline-delimited JSON on its stdin and
|
||||
* stdout (external/opennow/docs/core-protocol.md). It ships as libopennowcore.so in the native
|
||||
* library directory, the one place the app may run programs from.
|
||||
*/
|
||||
object GfnCore {
|
||||
private const val TAG = "GfnCore"
|
||||
private const val PROTOCOL_VERSION = 5
|
||||
private const val BINARY = "libopennowcore.so"
|
||||
|
||||
private var process: Process? = null
|
||||
private var writer: BufferedWriter? = null
|
||||
private val pending = ConcurrentHashMap<String, CompletableFuture<JSONObject>>()
|
||||
private val nextId = AtomicLong(1)
|
||||
private val listeners = java.util.concurrent.CopyOnWriteArrayList<(String, JSONObject) -> Unit>()
|
||||
|
||||
fun addListener(listener: (String, JSONObject) -> Unit) { listeners += listener }
|
||||
fun removeListener(listener: (String, JSONObject) -> Unit) { listeners -= listener }
|
||||
|
||||
/** Starts the core if it is not running, then checks the protocol and turns its reporting off. */
|
||||
@Synchronized
|
||||
fun ensureStarted(context: Context) {
|
||||
if (process?.isAlive == true) return
|
||||
val app = context.applicationContext
|
||||
val binary = File(app.applicationInfo.nativeLibraryDir, BINARY)
|
||||
check(binary.isFile) { "This build has no GeForce NOW core ($BINARY)" }
|
||||
val dataDir = File(app.filesDir, "gfn/core").apply { mkdirs() }
|
||||
val logFile = File(app.filesDir, "gfn/core.log")
|
||||
val started = ProcessBuilder(binary.path, "--data-dir", dataDir.path)
|
||||
.directory(dataDir)
|
||||
.redirectError(ProcessBuilder.Redirect.appendTo(logFile))
|
||||
.start()
|
||||
process = started
|
||||
writer = started.outputStream.bufferedWriter()
|
||||
Thread({ readLoop(started) }, "gfn-core-out").apply { isDaemon = true; start() }
|
||||
Log.i(TAG, "core started")
|
||||
request(app, "core.hello", JSONObject()
|
||||
.put("protocolVersion", PROTOCOL_VERSION)
|
||||
.put("shell", "qt")
|
||||
.put("shellVersion", "droiddeck"), timeoutMs = 10_000)
|
||||
// DroidDeck never sends OpenNOW's analytics or crash reports anywhere.
|
||||
for ((key, value) in listOf("automaticBugReports" to "disabled", "errorReportingConsent" to "denied")) {
|
||||
runCatching { request(app, "settings.set", JSONObject().put("key", key).put("value", value)) }
|
||||
.onFailure { Log.w(TAG, "could not set $key: ${it.message}") }
|
||||
}
|
||||
}
|
||||
|
||||
/** One request, answered with its `result` or thrown as [GfnError]. Blocking: call off the main thread. */
|
||||
fun request(context: Context, method: String, params: JSONObject = JSONObject(), timeoutMs: Long = 30_000): JSONObject {
|
||||
if (method != "core.hello") ensureStarted(context)
|
||||
val id = "dd-" + nextId.getAndIncrement()
|
||||
val answer = CompletableFuture<JSONObject>()
|
||||
pending[id] = answer
|
||||
try {
|
||||
val line = JSONObject().put("type", "request").put("id", id).put("method", method).put("params", params).toString()
|
||||
synchronized(this) {
|
||||
val out = writer ?: throw GfnError("core_stopped", "The GeForce NOW core is not running")
|
||||
out.write(line)
|
||||
out.newLine()
|
||||
out.flush()
|
||||
}
|
||||
val response = try {
|
||||
answer.get(timeoutMs, TimeUnit.MILLISECONDS)
|
||||
} catch (e: TimeoutException) {
|
||||
throw GfnError("timeout", "GeForce NOW did not answer in time ($method)")
|
||||
}
|
||||
if (response.optBoolean("ok")) return response.optJSONObject("result") ?: JSONObject()
|
||||
val error = response.optJSONObject("error")
|
||||
throw GfnError(error?.optString("code").orEmpty().ifEmpty { "error" },
|
||||
error?.optString("message").orEmpty().ifEmpty { "GeForce NOW request failed ($method)" })
|
||||
} finally {
|
||||
pending.remove(id)
|
||||
}
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun stop() {
|
||||
runCatching { writer?.close() }
|
||||
process?.destroy()
|
||||
process = null
|
||||
writer = null
|
||||
pending.values.forEach { it.completeExceptionally(GfnError("core_stopped", "The GeForce NOW core stopped")) }
|
||||
pending.clear()
|
||||
}
|
||||
|
||||
private fun readLoop(running: Process) {
|
||||
try {
|
||||
running.inputStream.bufferedReader().useLines { lines ->
|
||||
lines.forEach { line ->
|
||||
val message = runCatching { JSONObject(line) }.getOrNull() ?: return@forEach
|
||||
when (message.optString("type")) {
|
||||
"event" -> {
|
||||
val name = message.optString("name")
|
||||
val payload = message.optJSONObject("payload") ?: JSONObject()
|
||||
listeners.forEach { runCatching { it(name, payload) } }
|
||||
}
|
||||
else -> pending[message.optString("id")]?.complete(message)
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
Log.w(TAG, "core output ended")
|
||||
synchronized(this) {
|
||||
if (process === running) {
|
||||
process = null
|
||||
writer = null
|
||||
}
|
||||
}
|
||||
pending.values.forEach { it.completeExceptionally(GfnError("core_stopped", "The GeForce NOW core stopped")) }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,282 @@
|
||||
package com.droiddeck.launcher.stores.gfn
|
||||
|
||||
import android.app.AlertDialog
|
||||
import android.graphics.Color
|
||||
import android.os.Bundle
|
||||
import android.util.Log
|
||||
import android.view.Gravity
|
||||
import android.view.InputDevice
|
||||
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.activity.OnBackPressedCallback
|
||||
import androidx.core.view.WindowCompat
|
||||
import androidx.core.view.WindowInsetsCompat
|
||||
import androidx.core.view.WindowInsetsControllerCompat
|
||||
import org.json.JSONObject
|
||||
import java.util.concurrent.Executors
|
||||
import kotlin.math.hypot
|
||||
import kotlin.math.roundToInt
|
||||
|
||||
/** Plays one GeForce NOW game: books a seat, waits in the queue, then streams onto a SurfaceView. */
|
||||
class GfnPlayerActivity : ComponentActivity() {
|
||||
companion object {
|
||||
const val EXTRA_APP_ID = "appId"
|
||||
const val EXTRA_VARIANT_ID = "variantId"
|
||||
const val EXTRA_TITLE = "title"
|
||||
private const val TAG = "GfnPlayer"
|
||||
private const val DEADZONE = 0.15f
|
||||
}
|
||||
|
||||
private lateinit var status: TextView
|
||||
private val worker = Executors.newSingleThreadExecutor()
|
||||
private var streamer: GfnStreamer? = null
|
||||
@Volatile private var session: JSONObject? = null
|
||||
@Volatile private var closed = false
|
||||
@Volatile private var capabilities: JSONObject? = null
|
||||
private val helloWait = java.util.concurrent.CompletableFuture<JSONObject>()
|
||||
private val pads = Pads()
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
|
||||
WindowCompat.setDecorFitsSystemWindows(window, false)
|
||||
WindowInsetsControllerCompat(window, window.decorView).apply {
|
||||
hide(WindowInsetsCompat.Type.systemBars())
|
||||
systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
|
||||
}
|
||||
val root = FrameLayout(this).apply { setBackgroundColor(Color.BLACK) }
|
||||
val surface = SurfaceView(this)
|
||||
surface.holder.addCallback(object : SurfaceHolder.Callback {
|
||||
override fun surfaceCreated(holder: SurfaceHolder) = GfnStreamer.setSurface(holder.surface)
|
||||
override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {}
|
||||
override fun surfaceDestroyed(holder: SurfaceHolder) = GfnStreamer.setSurface(null)
|
||||
})
|
||||
root.addView(surface, FrameLayout.LayoutParams(-1, -1))
|
||||
status = TextView(this).apply {
|
||||
setTextColor(Color.WHITE)
|
||||
textSize = 18f
|
||||
gravity = Gravity.CENTER
|
||||
setPadding(48, 48, 48, 48)
|
||||
}
|
||||
root.addView(status, FrameLayout.LayoutParams(-1, -1))
|
||||
setContentView(root)
|
||||
onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
|
||||
override fun handleOnBackPressed() = confirmLeave()
|
||||
})
|
||||
val appId = intent.getStringExtra(EXTRA_APP_ID).orEmpty()
|
||||
val variantId = intent.getStringExtra(EXTRA_VARIANT_ID).orEmpty()
|
||||
val title = intent.getStringExtra(EXTRA_TITLE).orEmpty()
|
||||
show("Starting $title…")
|
||||
worker.execute {
|
||||
runCatching { play(appId, variantId, title) }.onFailure {
|
||||
Log.w(TAG, "could not start: ${it.message}")
|
||||
show(it.message ?: "GeForce NOW could not start this game.")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun play(appId: String, variantId: String, title: String) {
|
||||
val engine = GfnStreamer(::onStreamerMessage)
|
||||
streamer = engine
|
||||
engine.send("hello", JSONObject().put("protocolVersion", 7))
|
||||
val caps = helloWait.get(10, java.util.concurrent.TimeUnit.SECONDS)
|
||||
capabilities = caps
|
||||
|
||||
val inspect = GfnCore.request(this, "catalog.launch.inspect", JSONObject().put("appId", appId).put("variantId", variantId))
|
||||
val decision = inspect.optJSONObject("decision")
|
||||
if (decision?.optString("status") != "ready") {
|
||||
show(decision?.optString("message").orEmpty().ifEmpty { "This game can't be started with this account." })
|
||||
return
|
||||
}
|
||||
show("Requesting a GeForce NOW seat…")
|
||||
var current = GfnCore.request(this, "session.create", JSONObject()
|
||||
.put("appId", variantId)
|
||||
.put("variantId", variantId)
|
||||
.put("catalogAppId", appId)
|
||||
.put("scope", inspect.opt("scope"))
|
||||
.put("title", title)
|
||||
.put("runtimeCapabilities", caps), timeoutMs = 60_000)
|
||||
current = current.optJSONObject("session") ?: current
|
||||
session = current
|
||||
while (!closed && !ready(current)) {
|
||||
val position = current.optInt("queuePosition", 0)
|
||||
show(if (position > 0) "In the queue: position $position" else "Preparing your seat…")
|
||||
Thread.sleep(2_000)
|
||||
val polled = GfnCore.request(this, "session.poll", JSONObject()
|
||||
.put("sessionId", current.opt("sessionId"))
|
||||
.put("streamingBaseUrl", current.opt("streamingBaseUrl")), timeoutMs = 35_000)
|
||||
current = polled.optJSONObject("session") ?: polled
|
||||
session = current
|
||||
if (current.optString("phase") == "failed") {
|
||||
show("GeForce NOW could not prepare this session.")
|
||||
return
|
||||
}
|
||||
}
|
||||
if (closed) return
|
||||
show("Connecting…")
|
||||
val prepared = GfnCore.request(this, "streamer.prepare",
|
||||
JSONObject().put("session", current).put("runtimeCapabilities", caps))
|
||||
prepared.optJSONObject("session")?.let { session = it }
|
||||
val context = prepared.optJSONObject("context") ?: error("GeForce NOW returned no stream context")
|
||||
engine.send("start", JSONObject().put("context", context).put("microphoneEnabled", false))
|
||||
}
|
||||
|
||||
private fun ready(session: JSONObject): Boolean {
|
||||
val phase = session.optString("phase")
|
||||
return phase == "ready" || phase == "streaming" || session.optInt("status", 0) >= 2
|
||||
}
|
||||
|
||||
private fun onStreamerMessage(message: JSONObject) {
|
||||
when (message.optString("type")) {
|
||||
"ready" -> message.optJSONObject("capabilities")?.let { helloWait.complete(it) }
|
||||
"error" -> {
|
||||
Log.w(TAG, "streamer error ${message.optString("code")}: ${message.optString("message")}")
|
||||
show(message.optString("message").ifEmpty { "The stream stopped." })
|
||||
}
|
||||
"status" -> when (message.optString("event")) {
|
||||
"first-frame" -> runOnUiThread { status.visibility = android.view.View.GONE }
|
||||
}
|
||||
"stopped" -> show("The stream ended.")
|
||||
}
|
||||
}
|
||||
|
||||
private fun show(text: String) = runOnUiThread {
|
||||
status.text = text
|
||||
status.visibility = android.view.View.VISIBLE
|
||||
}
|
||||
|
||||
private fun confirmLeave() {
|
||||
AlertDialog.Builder(this)
|
||||
.setTitle("Leave the game?")
|
||||
.setMessage("This ends your GeForce NOW session.")
|
||||
.setPositiveButton("Leave") { _, _ -> finish() }
|
||||
.setNegativeButton("Keep playing", null)
|
||||
.show()
|
||||
}
|
||||
|
||||
override fun onDestroy() {
|
||||
closed = true
|
||||
val engine = streamer
|
||||
val active = session
|
||||
streamer = null
|
||||
Thread({
|
||||
runCatching { engine?.send("stop") }
|
||||
if (active != null) {
|
||||
runCatching {
|
||||
GfnCore.request(applicationContext, "session.stop", JSONObject()
|
||||
.put("sessionId", active.opt("sessionId"))
|
||||
.put("streamingBaseUrl", active.opt("streamingBaseUrl")))
|
||||
}.onFailure { Log.w(TAG, "session stop: ${it.message}") }
|
||||
}
|
||||
engine?.close()
|
||||
}, "gfn-leave").start()
|
||||
worker.shutdownNow()
|
||||
super.onDestroy()
|
||||
}
|
||||
|
||||
// --- controllers: Android gamepads in XInput layout, the same mapping OpenNOW uses ---
|
||||
|
||||
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
|
||||
if (event.isFromSource(InputDevice.SOURCE_GAMEPAD) || event.isFromSource(InputDevice.SOURCE_JOYSTICK)) {
|
||||
val bit = buttonBit(event.keyCode)
|
||||
if (bit != 0) {
|
||||
if (event.action == KeyEvent.ACTION_DOWN && event.repeatCount == 0) pads.press(event.deviceId, bit, true)
|
||||
else if (event.action == KeyEvent.ACTION_UP) pads.press(event.deviceId, bit, false)
|
||||
return true
|
||||
}
|
||||
}
|
||||
return super.dispatchKeyEvent(event)
|
||||
}
|
||||
|
||||
override fun dispatchGenericMotionEvent(event: MotionEvent): Boolean {
|
||||
if (event.isFromSource(InputDevice.SOURCE_JOYSTICK) && event.action == MotionEvent.ACTION_MOVE) {
|
||||
pads.move(event)
|
||||
return true
|
||||
}
|
||||
return super.dispatchGenericMotionEvent(event)
|
||||
}
|
||||
|
||||
private fun buttonBit(keyCode: Int): Int = when (keyCode) {
|
||||
KeyEvent.KEYCODE_BUTTON_A -> 0x1000
|
||||
KeyEvent.KEYCODE_BUTTON_B -> 0x2000
|
||||
KeyEvent.KEYCODE_BUTTON_X -> 0x4000
|
||||
KeyEvent.KEYCODE_BUTTON_Y -> 0x8000
|
||||
KeyEvent.KEYCODE_BUTTON_SELECT -> 0x0020
|
||||
KeyEvent.KEYCODE_BUTTON_START -> 0x0010
|
||||
KeyEvent.KEYCODE_BUTTON_THUMBL -> 0x0040
|
||||
KeyEvent.KEYCODE_BUTTON_THUMBR -> 0x0080
|
||||
KeyEvent.KEYCODE_BUTTON_L1 -> 0x0100
|
||||
KeyEvent.KEYCODE_BUTTON_R1 -> 0x0200
|
||||
KeyEvent.KEYCODE_DPAD_UP -> 0x0001
|
||||
KeyEvent.KEYCODE_DPAD_DOWN -> 0x0002
|
||||
KeyEvent.KEYCODE_DPAD_LEFT -> 0x0004
|
||||
KeyEvent.KEYCODE_DPAD_RIGHT -> 0x0008
|
||||
else -> 0
|
||||
}
|
||||
|
||||
private inner class Pads {
|
||||
private inner class Pad(val slot: Int) {
|
||||
var buttons = 0
|
||||
var hatButtons = 0
|
||||
var lt = 0
|
||||
var rt = 0
|
||||
var lx = 0
|
||||
var ly = 0
|
||||
var rx = 0
|
||||
var ry = 0
|
||||
}
|
||||
|
||||
private val bySlot = arrayOfNulls<Pad>(4)
|
||||
private val byDevice = HashMap<Int, Pad>()
|
||||
|
||||
@Synchronized
|
||||
private fun pad(deviceId: Int): Pad? = byDevice[deviceId] ?: run {
|
||||
val free = (0 until 4).firstOrNull { bySlot[it] == null } ?: return null
|
||||
Pad(free).also { bySlot[free] = it; byDevice[deviceId] = it }
|
||||
}
|
||||
|
||||
private fun connected(): Int = (0 until 4).filter { bySlot[it] != null }.fold(0) { bits, slot -> bits or (1 shl slot) or (1 shl (slot + 8)) }
|
||||
|
||||
fun press(deviceId: Int, bit: Int, down: Boolean) {
|
||||
val pad = pad(deviceId) ?: return
|
||||
pad.buttons = if (down) pad.buttons or bit else pad.buttons and bit.inv()
|
||||
send(pad)
|
||||
}
|
||||
|
||||
fun move(event: MotionEvent) {
|
||||
val pad = pad(event.deviceId) ?: return
|
||||
val (lx, ly) = stick(event.getAxisValue(MotionEvent.AXIS_X), event.getAxisValue(MotionEvent.AXIS_Y))
|
||||
val rightX = event.getAxisValue(MotionEvent.AXIS_Z).takeIf { it != 0f } ?: event.getAxisValue(MotionEvent.AXIS_RX)
|
||||
val rightY = event.getAxisValue(MotionEvent.AXIS_RZ).takeIf { it != 0f } ?: event.getAxisValue(MotionEvent.AXIS_RY)
|
||||
val (rx, ry) = stick(rightX, rightY)
|
||||
pad.lx = lx; pad.ly = ly; pad.rx = rx; pad.ry = ry
|
||||
pad.lt = trigger(maxOf(event.getAxisValue(MotionEvent.AXIS_LTRIGGER), event.getAxisValue(MotionEvent.AXIS_BRAKE)))
|
||||
pad.rt = trigger(maxOf(event.getAxisValue(MotionEvent.AXIS_RTRIGGER), event.getAxisValue(MotionEvent.AXIS_GAS)))
|
||||
val hatX = event.getAxisValue(MotionEvent.AXIS_HAT_X)
|
||||
val hatY = event.getAxisValue(MotionEvent.AXIS_HAT_Y)
|
||||
pad.hatButtons = (if (hatY < -0.5f) 0x0001 else 0) or (if (hatY > 0.5f) 0x0002 else 0) or
|
||||
(if (hatX < -0.5f) 0x0004 else 0) or (if (hatX > 0.5f) 0x0008 else 0)
|
||||
send(pad)
|
||||
}
|
||||
|
||||
/** Radial deadzone, Y flipped so up is positive (XInput). */
|
||||
private fun stick(x: Float, y: Float): Pair<Int, Int> {
|
||||
val magnitude = hypot(x, y)
|
||||
if (magnitude < DEADZONE) return 0 to 0
|
||||
val scaled = ((magnitude - DEADZONE) / (1f - DEADZONE)).coerceIn(0f, 1f) / magnitude
|
||||
return (x * scaled * 32767f).roundToInt() to (-y * scaled * 32767f).roundToInt()
|
||||
}
|
||||
|
||||
private fun trigger(value: Float): Int = (value.coerceIn(0f, 1f) * 255f).roundToInt()
|
||||
|
||||
private fun send(pad: Pad) {
|
||||
streamer?.gamepad(pad.slot, connected(), pad.buttons or pad.hatButtons, pad.lt, pad.rt, pad.lx, pad.ly, pad.rx, pad.ry)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
package com.droiddeck.launcher.stores.gfn
|
||||
|
||||
import android.view.Surface
|
||||
import org.json.JSONObject
|
||||
import java.util.concurrent.atomic.AtomicLong
|
||||
|
||||
/**
|
||||
* OpenNOW's native streamer engine (external/opennow, MIT, by Zortos) inside libdroiddeckgfn.so,
|
||||
* with DroidDeck's Android media backend: MediaCodec onto [setSurface]'s Surface, AAudio sound.
|
||||
* Commands are the engine's JSON protocol (`hello`, `start`, `stop`, ...); answers and events
|
||||
* arrive on [onMessage] from a polling thread.
|
||||
*/
|
||||
class GfnStreamer(private val onMessage: (JSONObject) -> Unit) {
|
||||
private var handle = nativeOpen()
|
||||
private val ids = AtomicLong(1)
|
||||
@Volatile private var open = true
|
||||
private val poller = Thread({
|
||||
while (open) {
|
||||
val line = nativePoll(handle, 250) ?: continue
|
||||
runCatching { JSONObject(line) }.getOrNull()?.let { message -> runCatching { onMessage(message) } }
|
||||
}
|
||||
}, "gfn-streamer-poll").apply { isDaemon = true; start() }
|
||||
|
||||
/** Sends one command; returns its id (responses carry it), or "" if the engine is closed. */
|
||||
fun send(type: String, fields: JSONObject = JSONObject()): String {
|
||||
if (!open) return ""
|
||||
val id = "dd-" + ids.getAndIncrement()
|
||||
fields.put("id", id).put("type", type)
|
||||
return if (nativeCommand(handle, fields.toString())) id else ""
|
||||
}
|
||||
|
||||
fun gamepad(slot: Int, connected: Int, buttons: Int, leftTrigger: Int, rightTrigger: Int,
|
||||
leftX: Int, leftY: Int, rightX: Int, rightY: Int) {
|
||||
if (open) nativeGamepad(handle, slot, connected, buttons, leftTrigger, rightTrigger, leftX, leftY, rightX, rightY)
|
||||
}
|
||||
|
||||
fun key(virtualKey: Int, modifiers: Int, pressed: Boolean) {
|
||||
if (open) nativeKey(handle, virtualKey, modifiers, pressed)
|
||||
}
|
||||
|
||||
fun close() {
|
||||
if (!open) return
|
||||
open = false
|
||||
poller.join(1_000)
|
||||
nativeClose(handle)
|
||||
handle = 0
|
||||
}
|
||||
|
||||
companion object {
|
||||
init { System.loadLibrary("droiddeckgfn") }
|
||||
|
||||
@JvmStatic fun setSurface(surface: Surface?) = nativeSetSurface(surface)
|
||||
|
||||
@JvmStatic private external fun nativeOpen(): Long
|
||||
@JvmStatic private external fun nativeCommand(handle: Long, json: String): Boolean
|
||||
@JvmStatic private external fun nativePoll(handle: Long, timeoutMs: Int): String?
|
||||
@JvmStatic private external fun nativeClose(handle: Long)
|
||||
@JvmStatic private external fun nativeSetSurface(surface: Surface?)
|
||||
@JvmStatic private external fun nativeGamepad(handle: Long, slot: Int, connected: Int, buttons: Int,
|
||||
leftTrigger: Int, rightTrigger: Int,
|
||||
leftX: Int, leftY: Int, rightX: Int, rightY: Int)
|
||||
@JvmStatic private external fun nativeKey(handle: Long, virtualKey: Int, modifiers: Int, pressed: Boolean)
|
||||
}
|
||||
}
|
||||
@@ -93,6 +93,7 @@ import androidx.compose.material.icons.filled.Search
|
||||
import androidx.compose.material.icons.automirrored.filled.Login
|
||||
import androidx.compose.foundation.basicMarquee
|
||||
import androidx.compose.material.icons.filled.Settings
|
||||
import androidx.compose.material.icons.outlined.Cloud
|
||||
import androidx.compose.material.icons.outlined.Download
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
@@ -650,6 +651,12 @@ private fun StoreChips(
|
||||
) { onDownloads() }
|
||||
ChipGlide(keys.indexOf(DOWNLOADS), bounds[DOWNLOADS], tint, visible = fillShown && highlighted == DOWNLOADS)
|
||||
}
|
||||
val gfnContext = LocalContext.current
|
||||
StoreChip(
|
||||
label = "GeForce NOW", on = false, under = false, key = "geforce-now", mark = pal.signal, modifier = Modifier,
|
||||
lead = { Icon(Icons.Outlined.Cloud, null, modifier = Modifier.size(18.dp)) },
|
||||
description = "GeForce NOW", onFocused = onFocusChip,
|
||||
) { gfnContext.startActivity(android.content.Intent(gfnContext, com.droiddeck.launcher.stores.gfn.GfnActivity::class.java)) }
|
||||
var cogAt by remember { mutableStateOf<Rect?>(null) }
|
||||
Box(Modifier.onGloballyPositioned { cogAt = it.boundsInRoot() }) {
|
||||
IconChip(Icons.Filled.Settings, stringResource(R.string.stores_settings)) { onSettings(cogAt) }
|
||||
|
||||
Reference in new issue
Block a user