Android Native App

.gitignore

@@ -22,7 +22,7 @@ native/opennow-streamer/bin/*/*
 .serena/
 *.xcuserstate
 xcuserdata/
-
+.logs/
 # Xcode build outputs
 DerivedData/
 
@@ -44,6 +44,8 @@ gfn_tokens.json
 
 # Test files
 test/
+!android/app/src/test/
+!android/app/src/test/**
 
 package-lock.json
 opennow-stable/package-lock.json
@@ -56,3 +58,6 @@ release-notes.md
 result
 .deriveddata/
 .deriveddata-device/
+
+/android/app/.cxx
+/android/app/release

android/.gitignore

@@ -0,0 +1,8 @@
+.gradle/
+.idea/
+build/
+local.properties
+captures/
+*.iml
+app/build/
+app/release/

android/README.md

@@ -0,0 +1,37 @@
+# OpenNOW Native Android
+
+This folder is a standalone Android Studio project for the native Kotlin / Jetpack Compose OpenNOW target.
+
+Open it from Android Studio with **File > Open > `OpenNOW/android`**. Android Studio will install/use the required Gradle, Android SDK, CMake, and NDK components from the project configuration.
+
+## Build Targets
+
+- `:app:assembleDebug` builds a debug APK.
+- `:app:assembleRelease` builds the direct-distribution release APK with APK update support.
+- `:app:bundleRelease` builds the Google Play Android App Bundle. This task removes `REQUEST_INSTALL_PACKAGES` and disables APK self-updates so Play installs use Google Play's update mechanism.
+
+Release and debug builds include `arm64-v8a`, `armeabi-v7a`, and `x86_64`. The `armeabi-v7a` slice supports 32-bit ARM phones and 32-bit Android TV firmware. OpenNOW recommends 720p/30 FPS/12 Mbps for 32-bit processes and memory-constrained TVs, and warns when a custom profile exceeds that recommendation without overriding the user's selection.
+
+## APK Update Manifest
+
+APK and debug builds check `https://api.printedwaste.com/releases/opennow/latest` and can download the returned APK. App Bundle builds installed from Google Play detect `com.android.vending` as the install source and do not check, download, or install APK updates. The manifest should look like this:
+
+```json
+{
+  "versionCode": 7,
+  "versionName": "0.5.2",
+  "apkUrl": "https://api.printedwaste.com/release-files/opennow/app-release.apk",
+  "artifactUrl": "https://api.printedwaste.com/release-files/opennow/app-release.apk",
+  "sha256": "optional lowercase apk checksum",
+  "releaseNotes": "Short notes shown in Settings\nSecond line"
+}
+```
+
+`apkUrl`, `artifactUrl`, or `url` may point at the APK. `releaseNotes` may use real newlines or literal `\n` separators. The app compares `versionCode` against its installed build and asks Android's package installer to confirm the downloaded APK.
+
+## Runtime Notes
+
+- UI is native Compose.
+- GFN auth, catalog, subscription, CloudMatch session creation/polling/claim/stop, signaling, and input packet behavior are implemented in Kotlin from the Electron project contracts.
+- Streaming uses Android WebRTC plus hardware MediaCodec probing. The bundled `opennow_native` JNI library exposes native runtime diagnostics and keeps the NDK/CMake path wired for media-sensitive code.
+- Queue ad metadata is preserved in `SessionInfo`; ad playback can use the included Media3 dependency when the server returns an ad media URL.

android/app/build.gradle.kts

@@ -0,0 +1,165 @@
+import java.util.Properties
+
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.plugin.compose")
+    id("org.jetbrains.kotlin.plugin.serialization")
+}
+
+val localProperties = Properties().apply {
+    rootProject.file("local.properties").takeIf { it.exists() }?.inputStream()?.use { load(it) }
+}
+fun Sequence<String?>.firstNonBlankOrNull(): String? =
+    mapNotNull { value -> value?.trim()?.takeIf { it.isNotEmpty() } }.firstOrNull()
+
+fun gradlePropertyValue(vararg names: String): String? =
+    names.asSequence().map { name -> providers.gradleProperty(name).orNull }.firstNonBlankOrNull()
+
+fun localPropertyValue(vararg names: String): String? =
+    names.asSequence().map { name -> localProperties.getProperty(name) }.firstNonBlankOrNull()
+
+fun environmentValue(vararg names: String): String? =
+    names.asSequence().map { name -> providers.environmentVariable(name).orNull }.firstNonBlankOrNull()
+
+fun firstNonBlankValue(vararg values: String?): String =
+    values.asSequence().firstNonBlankOrNull().orEmpty()
+
+fun buildConfigString(value: String): String =
+    "\"" + value
+        .replace("\\", "\\\\")
+        .replace("\"", "\\\"")
+        .replace("\n", "\\n")
+        .replace("\r", "\\r") + "\""
+
+val defaultPostHogProjectToken = "phc_pdob6BhBvbayfd7BA6zXBkty8o6EkxKYY7sF3ZwLymk3"
+val defaultPostHogHost = "https://aa.printedwaste.com"
+
+val postHogProjectToken = firstNonBlankValue(
+    gradlePropertyValue("posthog.apiKey", "posthog.projectToken"),
+    environmentValue("POSTHOG_API_KEY", "POSTHOG_PROJECT_TOKEN"),
+    localPropertyValue("posthog.apiKey", "posthog.projectToken"),
+    defaultPostHogProjectToken,
+)
+val postHogHost = firstNonBlankValue(
+    gradlePropertyValue("posthog.host"),
+    environmentValue("POSTHOG_HOST"),
+    localPropertyValue("posthog.host"),
+    defaultPostHogHost,
+)
+val buildingPlayReleaseBundle = gradle.startParameter.taskNames.any { taskName ->
+    taskName.substringAfterLast(":").equals("bundleRelease", ignoreCase = true)
+}
+
+android {
+    namespace = "com.opencloudgaming.opennow"
+    compileSdk = 37
+
+    defaultConfig {
+        applicationId = "com.opencloudgaming.opennow"
+        minSdk = 23
+        targetSdk = 36
+        versionCode = 55
+        versionName = "1.0.0"
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+
+        buildConfigField("String", "POSTHOG_PROJECT_TOKEN", buildConfigString(postHogProjectToken))
+        buildConfigField("String", "POSTHOG_HOST", buildConfigString(postHogHost))
+        buildConfigField("boolean", "APK_UPDATES_SUPPORTED", "true")
+
+        ndk {
+            abiFilters += listOf("arm64-v8a", "armeabi-v7a", "x86_64")
+        }
+
+    }
+
+    buildTypes {
+        debug {
+            isMinifyEnabled = false
+        }
+        release {
+            isMinifyEnabled = true
+            isShrinkResources = true
+            buildConfigField("boolean", "APK_UPDATES_SUPPORTED", (!buildingPlayReleaseBundle).toString())
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro",
+            )
+        }
+    }
+
+    sourceSets {
+        if (buildingPlayReleaseBundle) {
+            getByName("release").manifest.srcFile("src/playBundle/AndroidManifest.xml")
+        }
+    }
+
+    buildFeatures {
+        compose = true
+        buildConfig = true
+    }
+
+    externalNativeBuild {
+        cmake {
+            path = file("src/main/cpp/CMakeLists.txt")
+            version = "3.22.1"
+        }
+    }
+
+    packaging {
+        jniLibs {
+            useLegacyPackaging = false
+        }
+        resources {
+            excludes += setOf(
+                "META-INF/AL2.0",
+                "META-INF/LGPL2.1",
+                "META-INF/LICENSE*",
+                "META-INF/NOTICE*",
+            )
+        }
+    }
+}
+
+kotlin {
+    jvmToolchain(17)
+}
+
+dependencies {
+    implementation(platform("androidx.compose:compose-bom:2026.06.00"))
+    androidTestImplementation(platform("androidx.compose:compose-bom:2026.06.00"))
+
+    implementation("androidx.activity:activity-compose:1.13.0")
+    implementation("androidx.browser:browser:1.10.0")
+    implementation("androidx.compose.foundation:foundation")
+    implementation("androidx.compose.material:material-icons-extended")
+    implementation("androidx.compose.material3:material3")
+    implementation("androidx.compose.ui:ui")
+    implementation("androidx.compose.ui:ui-tooling-preview")
+    implementation("androidx.core:core:1.19.0")
+    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.11.0")
+    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.11.0")
+    implementation("androidx.media3:media3-common:1.10.1")
+    implementation("androidx.media3:media3-exoplayer:1.10.1")
+    implementation("androidx.media3:media3-ui:1.10.1")
+    implementation("androidx.work:work-runtime:2.11.2")
+
+    implementation("io.coil-kt.coil3:coil-compose:3.4.0")
+    implementation("io.coil-kt.coil3:coil-network-okhttp:3.4.0")
+
+    implementation("com.squareup.okhttp3:logging-interceptor:5.4.0")
+    implementation("com.squareup.okhttp3:okhttp-dnsoverhttps:5.4.0")
+    implementation("com.squareup.okhttp3:okhttp:5.4.0")
+    implementation("io.github.webrtc-sdk:android:144.7559.09")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.11.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.11.0")
+    implementation("com.posthog:posthog-android:3.51.2")
+
+    debugImplementation("androidx.compose.ui:ui-tooling")
+    debugImplementation("androidx.compose.ui:ui-test-manifest")
+
+    testImplementation("junit:junit:4.13.2")
+    androidTestImplementation("androidx.test.ext:junit:1.3.0")
+    androidTestImplementation("androidx.test:runner:1.7.0")
+    androidTestImplementation("androidx.test.espresso:espresso-core:3.7.0")
+    androidTestImplementation("androidx.compose.ui:ui-test-junit4")
+}

android/app/proguard-rules.pro

@@ -0,0 +1,6 @@
+-keep class org.webrtc.** { *; }
+-keep class org.jni_zero.** { *; }
+-keep class kotlinx.serialization.** { *; }
+-keepclassmembers class com.opencloudgaming.opennow.** {
+    @kotlinx.serialization.Serializable *;
+}

android/app/src/androidTest/java/com/opencloudgaming/opennow/LocalTvConnectorInstrumentedTest.kt

@@ -0,0 +1,84 @@
+package com.opencloudgaming.opennow
+
+import android.net.Uri
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class LocalTvConnectorInstrumentedTest {
+    @Test
+    fun encryptedLocalPairingTransfersLaunchAndSignIn() = runBlocking {
+        val tv = LocalTvConnector()
+        val phone = LocalTvConnector()
+        try {
+            tv.startHosting()
+            val pairingState = awaitState(tv) { it.hosting && it.pairUri != null }
+            assertTrue(pairingState.pairingCode.orEmpty().matches(Regex("[0-9]{4}")))
+            val pairUri = pairingState.pairUri!!
+
+            phone.pairPhone(Uri.parse(pairUri))
+            val phoneState = awaitState(phone) { it.phoneConnected || it.error != null }
+            assertTrue(phoneState.error.orEmpty(), phoneState.phoneConnected)
+            val pairedState = awaitState(tv) { it.pairedDeviceName != null }
+            assertTrue(pairedState.trustRequestedByDevice)
+
+            val launchResult = async { withTimeout(5_000L) { tv.launchRequests.first() } }
+            phone.sendLaunch("test-game-42", "Connector test game")
+            assertEquals("test-game-42", launchResult.await().gameId)
+
+            phone.sendRemoteAction("open_stream_menu")
+            val untrustedState = awaitState(phone) { it.error?.contains("Trust this phone") == true }
+            assertTrue(untrustedState.error.orEmpty(), untrustedState.error?.contains("Trust this phone") == true)
+
+            tv.setPairedDeviceTrusted(true)
+            val remoteResult = async { withTimeout(5_000L) { tv.remoteRequests.first() } }
+            phone.sendRemoteAction("open_stream_menu")
+            assertEquals("open_stream_menu", remoteResult.await().action)
+
+            val transferred = AuthSession(
+                provider = LoginProvider(
+                    idpId = "test",
+                    code = "TEST",
+                    displayName = "Test provider",
+                    streamingServiceUrl = "https://example.invalid",
+                ),
+                tokens = AuthTokens(
+                    accessToken = "instrumentation-access-token",
+                    refreshToken = "instrumentation-refresh-token",
+                    expiresAt = System.currentTimeMillis() + 60_000L,
+                ),
+                user = AuthUser(
+                    userId = "instrumentation-user",
+                    displayName = "Instrumentation user",
+                    membershipTier = "FREE",
+                ),
+            )
+            val signInResult = async { withTimeout(5_000L) { tv.signInRequests.first() } }
+            phone.sendSignIn(transferred)
+            assertEquals(transferred, signInResult.await())
+        } finally {
+            phone.close()
+            tv.close()
+        }
+    }
+
+    private suspend fun awaitState(
+        connector: LocalTvConnector,
+        predicate: (LocalTvConnectorState) -> Boolean,
+    ): LocalTvConnectorState = withTimeout(8_000L) {
+        while (true) {
+            connector.state.value.takeIf(predicate)?.let { return@withTimeout it }
+            delay(25L)
+        }
+        @Suppress("UNREACHABLE_CODE")
+        connector.state.value
+    }
+}

android/app/src/androidTest/java/com/opencloudgaming/opennow/StreamingProfileInstrumentedTest.kt

@@ -0,0 +1,66 @@
+package com.opencloudgaming.opennow
+
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class StreamingProfileInstrumentedTest {
+    @Test
+    fun commonResolutionAspectAndCodecMatrixResolvesToUsableHardwareProfile() {
+        val report = CodecProbe.report(ApplicationProvider.getApplicationContext())
+        val h264 = report.capabilities.firstOrNull { it.codec == VideoCodec.H264 }
+        assertNotNull("Every supported Android target must provide H264 decoding", h264)
+        assertTrue("H264 must be usable by the WebRTC launch path", h264?.streamingDecoderUsableForLaunch() == true)
+
+        val modes = listOf(
+            "1280x720" to "16:9",
+            "1366x768" to "16:9",
+            "1600x900" to "16:9",
+            "1920x1080" to "16:9",
+            "2560x1440" to "16:9",
+            "3840x2160" to "16:9",
+            "1280x800" to "16:10",
+            "1920x1200" to "16:10",
+            "2560x1600" to "16:10",
+            "1024x768" to "4:3",
+            "1680x720" to "21:9",
+            "2560x1080" to "21:9",
+            "3440x1440" to "21:9",
+        )
+        for ((resolution, aspectRatio) in modes) {
+            for (codec in VideoCodec.entries) {
+                val requested = StreamSettings(
+                    resolution = resolution,
+                    aspectRatio = aspectRatio,
+                    fps = 60,
+                    codec = codec,
+                    colorQuality = if (codec == VideoCodec.H264) ColorQuality.EightBit420 else ColorQuality.TenBit420,
+                )
+                val adjusted = requested.adjustedForDevice(report)
+                val effectiveCapability = report.capabilities.first { it.codec == adjusted.codec }
+
+                assertTrue("$resolution $codec did not resolve to a usable decoder", effectiveCapability.streamingDecoderUsableForLaunch())
+                assertEquals(
+                    "$resolution $codec resolved with inconsistent aspect metadata",
+                    streamAspectRatioForResolution(adjusted.resolution),
+                    adjusted.aspectRatio,
+                )
+                assertEquals(
+                    "$resolution $codec was unnecessarily reduced despite explicit decoder support",
+                    resolution,
+                    adjusted.resolution,
+                )
+                println(
+                    "STREAM_MATRIX requested=$resolution/$aspectRatio/$codec effective=${adjusted.resolution}/${adjusted.aspectRatio}/${adjusted.codec} " +
+                        "fps=${adjusted.fps} decoder=${effectiveCapability.webRtcDecoderName ?: effectiveCapability.decoderName} " +
+                        "max=${effectiveCapability.maxSupportedWidth}x${effectiveCapability.maxSupportedHeight}",
+                )
+            }
+        }
+    }
+}