@voltkit-rtc/react-native 0.0.0-stage → 0.1.0

package/android/build.gradle

@@ -0,0 +1,70 @@
+// @voltkit-rtc/react-native for Android: one codegen TurboModule (audio routing, the call service, native timers,
+// visibility, the network) and the init provider that gives react-native-webrtc its audio device module. Built by
+// the app (autolinking): the app's build brings the Android Gradle plugin, Kotlin and React Native's plugin.
+//
+// It never depends on in.voltkit:voltkit-rtc, which bundles its own libwebrtc: two copies in one APK clash. The
+// WebRTC here is react-native-webrtc's (org.jitsi:webrtc).
+
+import groovy.json.JsonSlurper
+
+def packageJson = new JsonSlurper().parse(file('../package.json'))
+
+if (findProject(':react-native-webrtc') == null) {
+    throw new GradleException(
+        "@voltkit-rtc/react-native needs react-native-webrtc: npm install react-native-webrtc, then rebuild the app"
+    )
+}
+
+apply plugin: 'com.android.library'
+
+// Android Gradle plugin 9 compiles Kotlin itself unless the app opts out (android.builtInKotlin=false, as Expo's
+// template does); before 9, and when opted out, the Kotlin plugin does.
+def agpMajor = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')[0].toInteger()
+def builtInKotlin = agpMajor >= 9 && (findProperty('android.builtInKotlin') ?: 'true').toString() != 'false'
+if (!builtInKotlin) {
+    apply plugin: 'org.jetbrains.kotlin.android'
+}
+
+// Runs codegen for src/specs/NativeVoltkitRtc.ts (package.json codegenConfig) and compiles its Java base class.
+apply plugin: 'com.facebook.react'
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+    namespace = "com.voltkit.rtc.reactnative"
+    compileSdk = safeExtGet('compileSdkVersion', 36)
+
+    defaultConfig {
+        minSdk = 24
+        consumerProguardFiles 'consumer-rules.pro'
+        buildConfigField "String", "VOLTKIT_RTC_VERSION", "\"${packageJson.version}\""
+    }
+
+    buildFeatures {
+        buildConfig = true
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    testOptions {
+        // The JVM tests touch only android.* constants; the stubs must not throw if anything else is reached.
+        unitTests.returnDefaultValues = true
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-android'
+    // WebRTCModuleOptions (the audio device module, the screen-share service) and org.webrtc's JavaAudioDeviceModule.
+    implementation project(':react-native-webrtc')
+    // ProcessLifecycleOwner, for visibility (the Android SDK's pin).
+    implementation 'androidx.lifecycle:lifecycle-process:2.10.0'
+    // ServiceCompat.startForeground with types (1.12+); NotificationCompat.
+    implementation 'androidx.core:core:1.13.1'
+
+    testImplementation 'junit:junit:4.13.2'
+}

package/android/consumer-rules.pro

@@ -0,0 +1,21 @@
+# @voltkit-rtc/react-native: consumer rules, applied to every app that depends on it. Apps add nothing for the SDK.
+
+# react-native-webrtc 155.0.1 brings org.jitsi:webrtc 155.0.1, whose libwebrtc.jar has org.webrtc.Dav1dDecoderJni
+# without org.webrtc.Dav1dDecoder$Natives. react-native-webrtc's own rules keep org.webrtc.** but do not silence
+# that, so every R8 release build fails with "Missing class org.webrtc.Dav1dDecoder$Natives (referenced from:
+# org.webrtc.Dav1dDecoderJni.get() ...)" (Phase 0, finding 2). Nothing calls it: the AV1 decoder that ships is
+# libaom's.
+-dontwarn org.webrtc.Dav1dDecoder$Natives
+
+# selectAudioInput(null) goes back to the default microphone through JavaAudioDeviceModule's recorder, by reflection:
+# its public setPreferredInputDevice(null) throws in jitsi's WebRTC 155 (it logs the device's id first).
+# react-native-webrtc's rules keep org.webrtc.** already; these keep the two members even if that changes.
+-keepclassmembers class org.webrtc.audio.JavaAudioDeviceModule {
+    org.webrtc.audio.WebRtcAudioRecord audioInput;
+}
+-keepclassmembers class org.webrtc.audio.WebRtcAudioRecord {
+    void setPreferredDevice(android.media.AudioDeviceInfo);
+}
+
+# Nothing else is needed: React Native's rules keep every NativeModule (VoltkitRtcModule and its codegen base class),
+# and the manifest keeps the provider and the call service.

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!--
+      Only what every app using @voltkit-rtc/react-native needs, as the Android SDK's manifest. CAMERA and
+      RECORD_AUDIO are left to the app (a viewer-only app should not declare them), and so is the call service with
+      its FOREGROUND_SERVICE permissions (the Expo plugin's callService option, or the manifest block in the docs):
+      an app that never runs background calls takes on no Play declaration.
+    -->
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+
+    <application>
+        <!--
+          Gives react-native-webrtc its audio device module (audio mode, echo cancellation) and turns on its
+          screen-share service, from the in.voltkit.rtc.* meta-data, before react-native-webrtc starts.
+        -->
+        <provider
+            android:name="com.voltkit.rtc.reactnative.VoltkitRtcInitProvider"
+            android:authorities="${applicationId}.voltkitrtcinit"
+            android:exported="false" />
+    </application>
+
+</manifest>

package/android/src/main/java/com/voltkit/rtc/reactnative/AppVisibility.kt

@@ -0,0 +1,67 @@
+package com.voltkit.rtc.reactnative
+
+import android.os.Handler
+import android.os.Looper
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ProcessLifecycleOwner
+import java.util.concurrent.CopyOnWriteArraySet
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * Whether the app is in the foreground (any activity started), from the process lifecycle, which knows it from the
+ * start however late a client is made. A process with no activity at all (a call answered from a push, a service)
+ * counts as in the background. Ported unchanged from the Android SDK (android-sdk/.../AppVisibility.kt).
+ *
+ * Why not React Native's AppState: it says `background` while a permission dialog or the screen-share consent is
+ * open, though the app is still in front (Phase 0 S8: ProcessLifecycleOwner said ON_PAUSE only, never ON_STOP).
+ *
+ * The observer is registered through a post to the main looper, never in place: the init provider calls [install]
+ * while providers are being created, before androidx.startup's InitializationProvider starts the process lifecycle
+ * (S7/S8). The post runs after every provider and Application.onCreate.
+ */
+internal object AppVisibility {
+    private val listeners = CopyOnWriteArraySet<(Boolean) -> Unit>()
+    private val installed = AtomicBoolean(false)
+
+    @Volatile
+    var visible: Boolean = true
+        private set
+
+    /** Hear every change; returns how to stop hearing them. */
+    fun watch(listener: (visible: Boolean) -> Unit): () -> Unit {
+        install()
+        listeners.add(listener)
+        return { listeners.remove(listener) }
+    }
+
+    /** Start following the process lifecycle (once; the work is posted to the main looper). */
+    fun install() {
+        if (!installed.compareAndSet(false, true)) return
+        val main = Handler(Looper.getMainLooper())
+        main.post {
+            try {
+                val lifecycle = ProcessLifecycleOwner.get().lifecycle
+                // INITIALIZED: the process lifecycle never started in this process (a
+                // second process, or an app that removed its initializer). Not knowing
+                // counts as visible, as below; a later start still reports changes.
+                if (lifecycle.currentState != Lifecycle.State.INITIALIZED) {
+                    set(lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED))
+                }
+                lifecycle.addObserver(object : DefaultLifecycleObserver {
+                    override fun onStart(owner: LifecycleOwner) = set(true)
+                    override fun onStop(owner: LifecycleOwner) = set(false)
+                })
+            } catch (_: Throwable) {
+                // No process lifecycle (a test runner without it): treat the app as visible.
+            }
+        }
+    }
+
+    private fun set(now: Boolean) {
+        if (visible == now) return
+        visible = now
+        listeners.forEach { runCatching { it(now) } }
+    }
+}

package/android/src/main/java/com/voltkit/rtc/reactnative/AudioDevices.kt

@@ -0,0 +1,67 @@
+package com.voltkit.rtc.reactnative
+
+/** What a [MediaDevice] is. Names as in every VoltKit SDK (`MediaDeviceInfo.kind`). */
+@Suppress("EnumEntryName")
+internal enum class DeviceKind {
+    audioinput,
+    videoinput,
+    audiooutput,
+}
+
+/** The kind of audio device, for an icon in a "speaker / phone / headset" picker. The Android SDK's names. */
+@Suppress("EnumEntryName")
+internal enum class AudioDeviceType {
+    /** The loudspeaker. */
+    speaker,
+
+    /** The phone's earpiece, held to the ear. Phones only; tablets and the emulator have none. */
+    earpiece,
+
+    /** Headphones or a headset on the jack. */
+    wiredHeadset,
+
+    /** A Bluetooth headset, car kit or hearing device, in call (two-way) mode. */
+    bluetooth,
+
+    /** A USB headset or audio interface. */
+    usb,
+
+    /** The device's own microphone. */
+    builtinMic,
+    other,
+}
+
+/**
+ * An audio input or output as [AudioRouter] lists it, the Android SDK's `MediaDevice` (Devices.kt) without cameras:
+ * react-native-webrtc lists those. JavaScript receives it as the client's `MediaDevice`.
+ */
+internal data class MediaDevice(
+    /** Stable while the device stays connected: `speaker`, `earpiece`, `bluetooth:12`, `mic`. */
+    val deviceId: String,
+    val kind: DeviceKind,
+    /** A name to show, e.g. "Speaker", "Pixel Buds". */
+    val label: String,
+    val type: AudioDeviceType? = null,
+    /** Devices that belong together (a headset's microphone and earphones share one). */
+    val groupId: String = "",
+)
+
+/** The devices now, and what appeared and went since the last list (a headset plugged in, Bluetooth connected). */
+internal data class DevicesChanged(
+    val devices: List<MediaDevice>,
+    val added: List<MediaDevice>,
+    val removed: List<MediaDevice>,
+) {
+    companion object {
+        /** What appeared and what went between two lists. */
+        fun between(before: List<MediaDevice>, after: List<MediaDevice>): DevicesChanged {
+            val was = before.map { it.kind to it.deviceId }.toSet()
+            val now = after.map { it.kind to it.deviceId }.toSet()
+            return DevicesChanged(
+                devices = after,
+                added = after.filter { (it.kind to it.deviceId) !in was },
+                removed = before.filter { (it.kind to it.deviceId) !in now },
+            )
+        }
+    }
+}