@iternio/react-native-auto-play 0.6.1 → 0.8.0

package/README.md

@@ -25,6 +25,7 @@
 ## Requirements
 
 -   **iOS builds require Xcode 27+** (the iOS 27 SDK), even for apps that don't use any `mapConfig`/panel features — the library references `CPMapPanel`/`CPPanel` types internally behind `@available(iOS 27.0, *)` checks, but `@available` only defers *runtime* execution, not compile-time symbol resolution, so the SDK must be present to build at all.
+-   **`react-native-nitro-modules` 0.37.1 or newer** — the generated native bindings target that runtime shape; an older nitro-modules install fails at native build time.
 
 ## Installation
 
@@ -474,10 +475,11 @@ Use the color `'default'` for every monochrome icon that has to stay readable in
 
 ### 1. Register the AutoPlay Components
 
-You need to register your AutoPlay components in your app's entry file (e.g., `index.js`). This includes setting up the headless task that runs when CarPlay or Android Auto is connected.
+You need to register your AutoPlay components in your app's entry file (e.g., `index.js`). Import `@iternio/react-native-auto-play/installTimers` — a side-effect-only module that replaces the global `setTimeout`/`setInterval`/`requestAnimationFrame` (and their `clear*`/`cancel*` counterparts) with versions that keep running while CarPlay/Android Auto is actively driving the car screen, even if the phone itself is backgrounded or its screen is locked. React Native's own timers throttle or pause in that state regardless of whether the app process is actually still alive, which would otherwise stall ETA updates and telemetry polling. It must run before any other module has a chance to capture a reference to the original globals, which means it must be your entry file's **first import** — ES import declarations are hoisted and evaluated in source order, so it needs to come before everything else, including `react-native` itself:
 
 ```javascript
 // index.js
+import '@iternio/react-native-auto-play/installTimers';
 import { AppRegistry } from 'react-native';
 import { name as appName } from './app.json';
 import App from './src/App';
@@ -680,7 +682,7 @@ Below is a concise overview of the most important props per template. Optional p
 
 | Prop | Type | Required | Notes |
 | --- | --- | --- | --- |
-| `signInMethod` | `SignInMethod` | ✅ | The sign-in method configuration. Can be QRSignIn, PinSignIn, InputSignIn. |
+| `signInMethod` | `SignInMethod` | ✅ | The sign-in method configuration. Can be QRSignIn, PinSignIn, InputSignIn, GoogleSignIn. |
 | `title` | `string` | ❌ | Header title. |
 | `additionalText` | `string` | ❌ | Additional descriptive text. |
 | `instructions` | `string` | ❌ | Sign-in Instructions text. |
@@ -694,6 +696,19 @@ Below is a concise overview of the most important props per template. Optional p
 | QR | `QrSignIn` | QR Code sign in |
 | PIN | `PinSignIn` | PIN Code sign in (1–12 characters) |
 | Input | `InputSignIn` | Text sign in, for example mail/username and password |
+| Google | `GoogleSignIn` | Sign in with Google. Requires Google Play services 23.08 or newer — check `SignInTemplate.isGoogleSignInAvailable()` first. |
+
+`GoogleSignIn` takes a `serverClientId` (your **Web** OAuth client ID), a `signInButtonText` and a `callback(error?, account?)`. On success the returned `GoogleSignInAccount` always carries both `idToken` and `serverAuthCode` (offline access, `openid` `profile` `email` scopes) for your backend. If the user cancels, or either the account picker or the authorization step fails, `callback` is called with an `error` and no account.
+
+**Sign in with Google needs a recent Play services.** Constructing a `SignInTemplate` with `GoogleSignIn` throws `playServicesUnavailable` (and `updateTemplate` rejects with it) when Google Play services is missing or older than 23.08 (e.g. Android Automotive builds without GMS). Pick a different method up front instead:
+
+```ts
+const signInMethod: SignInMethod = SignInTemplate.isGoogleSignInAvailable()
+  ? { method: SignInMethods.GOOGLE, serverClientId, signInButtonText: 'Sign in with Google', callback }
+  : { method: SignInMethods.QR, url: loginUrl };
+```
+
+`isGoogleSignInAvailable()` always returns `false` on iOS.
 
 For InputSignIn the keyboard and input fields can be configured with following properties:
 
@@ -1314,8 +1329,6 @@ The same no-op surface is what `react-native-web` builds get automatically via `
 
 -   **Broken exceptions with `react-native-skia`**: When using `react-native-skia` exceptions on iOS are not reported correctly. This is fixed since version `2.4.19` of `react-native-skia`. For more details, see this [pull request](https://github.com/Shopify/react-native-skia/pull/3595) and [issue](https://github.com/Shopify/react-native-skia/issues/3635).
 -   **AppState on iOS**: The `AppState` module from React Native does not work correctly on iOS because this library uses scenes, which are not supported by the stock `AppState` module. This library provides a custom state listener that works for both Android and iOS. Use `HybridAutoPlay.addListenerRenderState` instead of `AppState`.
--   **Timers stop on screen lock**: iOS stops all timers when the device main screen is turned off. To ensure timers continue to run (which is often necessary for background tasks related to autoplay), a patch for `react-native` is required. A patch is included in the root `patches/` directory and can be applied using `patch-package`.
-In case you are using Expo SDK >= 56 make sure to set `buildReactNativeFromSource` to `true` in your app config for [expo-build-properties](https://docs.expo.dev/versions/latest/sdk/build-properties/#sharedbuildconfigfields), otherwise the patch can't be applied.
 -   **expo-splash-screen stuck on iOS**: The `expo-splash-screen` module is broken on iOS because it does not support scenes, which are used by this library. This can cause the splash screen to be stuck on either the mobile device or on CarPlay. To fix this, a patch for `expo-splash-screen` is included in the root `patches/` directory and can be applied using `patch-package`. After applying the patch, you can hide the splash screen for a specific scene by passing the module name to the `hide` or `hideAsync` function. The module name can be one of the values from the `AutoPlayModules` enum or the UUID of a cluster screen.
     ```tsx
     import { hideAsync } from 'expo-splash-screen';

package/android/build.gradle

@@ -165,7 +165,9 @@ dependencies {
     implementation "androidx.car.app:app-projected:1.7.0"
   }
 
-  implementation 'com.google.android.gms:play-services-base:18.10.0'
-  implementation 'com.google.android.gms:play-services-auth:21.5.1'
+  implementation 'com.google.android.gms:play-services-auth:22.0.0'
+  implementation 'androidx.credentials:credentials:1.6.0'
+  implementation 'androidx.credentials:credentials-play-services-auth:1.6.0'
+  implementation 'com.google.android.libraries.identity.googleid:googleid:1.1.1'
 }
 

package/android/src/automotive/AndroidManifest-nonnav.xml

@@ -58,8 +58,6 @@
             </intent-filter>
         </service>
 
-        <service android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.HeadlessTaskService" />
-
         <activity android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.SignInWithGoogleActivity" />
 
         <provider

package/android/src/automotive/AndroidManifest.xml

@@ -74,8 +74,6 @@
             </intent-filter>
         </service>
 
-        <service android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.HeadlessTaskService" />
-
         <activity android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.SignInWithGoogleActivity" />
 
         <provider

package/android/src/main/AndroidManifest-nonnav.xml

@@ -28,8 +28,6 @@
         <meta-data android:name="com.google.android.gms.car.application" android:resource="@xml/automotive_app_desc" tools:ignore="MetadataTagInsideApplicationTag" />
         <meta-data android:name="androidx.car.app.minCarApiLevel" android:value="1" />
 
-        <service android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.HeadlessTaskService" />
-
         <provider android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.ActivityRenderStateProvider" android:authorities="${applicationId}.ActivityRenderStateProvider" android:exported="false" />
     </application>
 </manifest>

package/android/src/main/AndroidManifest.xml

@@ -37,8 +37,6 @@
         <meta-data android:name="com.google.android.gms.car.application" android:resource="@xml/automotive_app_desc" tools:ignore="MetadataTagInsideApplicationTag" />
         <meta-data android:name="androidx.car.app.minCarApiLevel" android:value="1" />
 
-        <service android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.HeadlessTaskService" />
-
         <provider android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.ActivityRenderStateProvider" android:authorities="${applicationId}.ActivityRenderStateProvider" android:exported="false" />
     </application>
 </manifest>

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/AndroidAutoService.kt

@@ -5,14 +5,10 @@ import android.annotation.SuppressLint
 import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
-import android.content.ComponentName
-import android.content.Intent
-import android.content.ServiceConnection
 import android.content.pm.ApplicationInfo
 import android.content.pm.PackageManager
 import android.graphics.Bitmap
 import android.os.Build
-import android.os.IBinder
 import android.util.Log
 import androidx.car.app.CarAppService
 import androidx.car.app.Session
@@ -23,6 +19,7 @@ import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.ReactApplication
 import com.facebook.react.bridge.LifecycleEventListener
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.AppInfo
@@ -30,7 +27,6 @@ import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.AppInfo
 class AndroidAutoService : CarAppService() {
     private lateinit var notificationManager: NotificationManager
 
-    private var isServiceBound = false
     private var isSessionStarted = false
     private var isReactAppStarted = false
 
@@ -48,6 +44,8 @@ class AndroidAutoService : CarAppService() {
         super.onCreate()
         instance = this
 
+        (application as? ReactApplication)?.reactHost?.start()
+
         NitroModules.applicationContext?.addLifecycleEventListener(reactLifecycleObserver)
 
         notificationManager = getSystemService(NotificationManager::class.java)
@@ -98,11 +96,6 @@ class AndroidAutoService : CarAppService() {
     }
 
     private val sessionLifecycleObserver = object : DefaultLifecycleObserver {
-        override fun onCreate(owner: LifecycleOwner) {
-            val serviceIntent = Intent(applicationContext, HeadlessTaskService::class.java)
-            bindService(serviceIntent, connection, BIND_AUTO_CREATE)
-        }
-
         override fun onResume(owner: LifecycleOwner) {
             isSessionStarted = true
         }
@@ -112,27 +105,10 @@ class AndroidAutoService : CarAppService() {
         }
 
         override fun onDestroy(owner: LifecycleOwner) {
-            if (isServiceBound) {
-                unbindService(connection)
-                isServiceBound = false
-            }
-
             this@AndroidAutoService.stopForeground(STOP_FOREGROUND_REMOVE)
         }
     }
 
-    private val connection: ServiceConnection = object : ServiceConnection {
-        override fun onServiceConnected(
-            className: ComponentName, service: IBinder
-        ) {
-            isServiceBound = true
-        }
-
-        override fun onServiceDisconnected(arg0: ComponentName) {
-            isServiceBound = false
-        }
-    }
-
     private fun createNotification(
         title: String?, text: String?, largeIcon: Bitmap?
     ): Notification {

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/AutoPlayError.kt

@@ -8,3 +8,7 @@ class TemplateNotFoundException(private val templateId: String) :
 class VoiceInputCancelledException : Exception("voiceInputCancelled") {
     override fun toString(): String = "voiceInputCancelled"
 }
+
+class PlayServicesUnavailableException : Exception("playServicesUnavailable") {
+    override fun toString(): String = "playServicesUnavailable"
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlayTiming.kt

@@ -0,0 +1,122 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import java.lang.ref.WeakReference
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+
+private class ScheduledTimer(
+    val callback: () -> Unit,
+    val interval: Long,
+    val repeats: Boolean,
+    var target: Long,
+)
+
+// Weak ref, so a stale instance (dev reload / host restart) can't tick forever in the queue.
+private class TickRunnable(target: HybridAutoPlayTiming) : Runnable {
+    private val ref = WeakReference(target)
+
+    override fun run() {
+        ref.get()?.tick()
+    }
+}
+
+/**
+ * Backs setTimeout/setInterval (see AutoPlayTimers.ts) with a plain Handler loop on the main
+ * Looper -- not Choreographer, which JavaTimerManager itself uses and only keeps ticking while
+ * the host is resumed or a headless JS task is running. See AutoPlayTiming.nitro.ts.
+ *
+ * Ticks at a fixed ~60Hz while any timer is pending and stops entirely once idle, rather than
+ * scheduling a delay to the next due target: postDelayed's dispatch is gated on uptimeMillis(),
+ * which pauses during deep sleep, so a long pre-sleep delay would need that much *awake* time
+ * after waking. A short, repeated delay only needs ~16ms of awake time, so it fires within
+ * about one frame of the device waking regardless of sleep length -- due timers are then found
+ * correctly because target/now use elapsedRealtime(), which counts straight through sleep.
+ */
+class HybridAutoPlayTiming : HybridAutoPlayTimingSpec() {
+    companion object {
+        private const val FRAME_DURATION_MS = 1000L / 60L
+
+        // RN's TimerManager also numbers ids from 1; offsetting avoids collisions with ids a
+        // pre-install caller (e.g. React's own scheduler) still holds against the original
+        // clearTimeout, now replaced.
+        private const val ID_OFFSET = 1_000_000_000L
+    }
+
+    private val handler = Handler(Looper.getMainLooper())
+    private val timers = ConcurrentHashMap<Double, ScheduledTimer>()
+    private val nextId = AtomicLong(ID_OFFSET)
+    private val isTicking = AtomicBoolean(false)
+    private val tickRunnable = TickRunnable(this)
+
+    private fun ensureTicking() {
+        if (isTicking.compareAndSet(false, true)) {
+            handler.postDelayed(tickRunnable, FRAME_DURATION_MS)
+        }
+    }
+
+    internal fun tick() {
+        // elapsedRealtime(), not uptimeMillis(): both are immune to NTP/manual clock changes,
+        // but unlike uptimeMillis() this one keeps counting through deep sleep.
+        val now = SystemClock.elapsedRealtime()
+
+        // Sort by (target, id): ConcurrentHashMap iteration order is unspecified, so
+        // setTimeout(a, 0); setTimeout(b, 0) could otherwise fire b before a.
+        val dueIds = timers.entries.filter { it.value.target <= now }
+            .sortedWith(compareBy({ it.value.target }, { it.key }))
+            .map { it.key }
+
+        for (id in dueIds) {
+            // Re-check membership: a same-tick callback may have cleared a later timer in
+            // this snapshotted list (e.g. `clearTimeout(t); t = setTimeout(...)`).
+            val timer = timers[id] ?: continue
+
+            if (timer.repeats) {
+                timer.target = now + timer.interval
+            } else {
+                timers.remove(id)
+            }
+
+            timer.callback()
+        }
+
+        if (timers.isNotEmpty()) {
+            handler.postDelayed(tickRunnable, FRAME_DURATION_MS)
+            return
+        }
+
+        isTicking.set(false)
+        // Reclaim: a concurrent createTimer() may have inserted an entry and found `isTicking`
+        // still true (skipping its own post) in the gap before the flag was cleared above.
+        if (timers.isNotEmpty()) {
+            ensureTicking()
+        }
+    }
+
+    override fun createTimer(callback: () -> Unit, durationMs: Double, repeats: Boolean): Double {
+        val interval = durationMs.toLong().coerceAtLeast(0)
+        val id = nextId.getAndIncrement().toDouble()
+        timers[id] = ScheduledTimer(
+            callback = callback,
+            interval = interval,
+            repeats = repeats,
+            target = SystemClock.elapsedRealtime() + interval,
+        )
+        ensureTicking()
+        return id
+    }
+
+    override fun deleteTimer(id: Double) {
+        timers.remove(id)
+    }
+
+    override fun dispose() {
+        handler.removeCallbacks(tickRunnable)
+        isTicking.set(false)
+        timers.clear()
+        super.dispose()
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridSignInTemplate.kt

@@ -1,5 +1,8 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
+import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.SignInTemplate
@@ -9,14 +12,34 @@ class HybridSignInTemplate : HybridSignInTemplateSpec() {
         val context = AndroidAutoSession.getRootContext()
             ?: throw IllegalArgumentException("createSignInTemplate failed, no carContext found")
 
+        assertSignInMethodAvailable(config)
+
         val template = SignInTemplate(context, config)
         AndroidAutoTemplate.setTemplate(config.id, template)
     }
 
     override fun updateTemplate(templateId: String, config: SignInTemplateConfig): Promise<Unit> {
         return Promise.async {
+            assertSignInMethodAvailable(config)
             val template = AndroidAutoTemplate.getTemplate<SignInTemplate>(templateId)
             template.updateTemplate(config)
         }
     }
+
+    override fun isGoogleSignInAvailable(): Boolean {
+        val context = NitroModules.applicationContext ?: return false
+
+        // on older versions sign in with google is no longer supported
+        val googleServiceMinVersion = 230815045
+        val available = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(
+                context, googleServiceMinVersion
+            )
+        return ConnectionResult.SUCCESS == available
+    }
+
+    private fun assertSignInMethodAvailable(config: SignInTemplateConfig) {
+        if (config.signInMethod?.asFourthOrNull() != null && !isGoogleSignInAvailable()) {
+            throw PlayServicesUnavailableException()
+        }
+    }
 }

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/SignInWithGoogleActivity.kt

@@ -4,42 +4,90 @@ import android.os.Binder
 import android.os.Bundle
 import android.os.IBinder
 import androidx.activity.ComponentActivity
-import androidx.activity.result.ActivityResult
+import androidx.activity.result.IntentSenderRequest
 import androidx.activity.result.contract.ActivityResultContracts
-import com.google.android.gms.auth.api.signin.GoogleSignIn
-import com.google.android.gms.auth.api.signin.GoogleSignInAccount
-import com.google.android.gms.auth.api.signin.GoogleSignInOptions
+import androidx.credentials.CredentialManager
+import androidx.credentials.GetCredentialRequest
+import androidx.lifecycle.lifecycleScope
+import com.google.android.gms.auth.api.identity.AuthorizationRequest
+import com.google.android.gms.auth.api.identity.Identity
+import com.google.android.gms.common.Scopes
+import com.google.android.gms.common.api.Scope
+import com.google.android.libraries.identity.googleid.GetSignInWithGoogleOption
+import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential
+import kotlinx.coroutines.launch
 import java.security.InvalidParameterException
-import javax.annotation.Nullable
 
 class SignInWithGoogleActivity : ComponentActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
 
-        val signInCompleteCallback = intent.extras?.getBinder(BINDER_KEY) as OnSignInComplete?
+    private var callback: OnSignInComplete? = null
+    private var idCredential: GoogleIdTokenCredential? = null
+
+    private val authLauncher = registerForActivityResult(
+        ActivityResultContracts.StartIntentSenderForResult()
+    ) { result ->
+        val auth = runCatching {
+            Identity.getAuthorizationClient(this)
+                .getAuthorizationResultFromIntent(result.data)
+        }.getOrNull()
+        finishWith(auth?.serverAuthCode)
+    }
 
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        callback = intent.extras?.getBinder(BINDER_KEY) as OnSignInComplete?
         val serverClientId = intent.extras?.getString("serverClientId")
             ?: throw InvalidParameterException("missing serverClientId parameter")
 
-        val activityResultLauncher = registerForActivityResult(
-            ActivityResultContracts.StartActivityForResult()
-        ) { result: ActivityResult ->
-            val account = GoogleSignIn.getSignedInAccountFromIntent(
-                result.data
-            ).result
-            signInCompleteCallback?.onSignInComplete(account)
-            finish()
-        }
+        lifecycleScope.launch {
+            // 1. Authentication: ID token
+            val request = GetCredentialRequest.Builder()
+                .addCredentialOption(GetSignInWithGoogleOption.Builder(serverClientId).build())
+                .build()
+            try {
+                val result = CredentialManager.create(this@SignInWithGoogleActivity)
+                    .getCredential(this@SignInWithGoogleActivity, request)
+                idCredential = GoogleIdTokenCredential.createFrom(result.credential.data)
+            } catch (_: Exception) {
+                callback?.onSignInComplete(null, null)
+                finish()
+                return@launch
+            }
 
-        val googleSignInClient = GoogleSignIn.getClient(
-            this,
-            GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
-                .requestServerAuthCode(serverClientId)
-                .requestEmail()
-                .requestIdToken(serverClientId)
+            // 2. Authorization: server auth code
+            val authRequest = AuthorizationRequest.builder()
+                // matches the legacy DEFAULT_SIGN_IN + requestEmail() scopes, so the exchanged
+                // server auth code grants the same access as before the Credential Manager migration
+                .setRequestedScopes(
+                    listOf(Scope(Scopes.OPEN_ID), Scope(Scopes.PROFILE), Scope(Scopes.EMAIL))
+                )
+                .requestOfflineAccess(serverClientId)
                 .build()
-        )
-        activityResultLauncher.launch(googleSignInClient.signInIntent)
+            Identity.getAuthorizationClient(this@SignInWithGoogleActivity)
+                .authorize(authRequest)
+                .addOnSuccessListener { res ->
+                    if (res.hasResolution()) {
+                        authLauncher.launch(
+                            IntentSenderRequest.Builder(res.pendingIntent!!.intentSender).build()
+                        )
+                    } else {
+                        finishWith(res.serverAuthCode)
+                    }
+                }
+                .addOnFailureListener { finishWith(null) }
+        }
+    }
+
+    private fun finishWith(serverAuthCode: String?) {
+        // a cancelled or failed authorization step yields no server auth code; report it as a
+        // failed sign in so callers get either an error or a complete account, as with the
+        // legacy GoogleSignIn flow, never an account without a server auth code
+        if (serverAuthCode == null) {
+            callback?.onSignInComplete(null, null)
+        } else {
+            callback?.onSignInComplete(idCredential, serverAuthCode)
+        }
+        finish()
     }
 
     /**
@@ -49,9 +97,13 @@ class SignInWithGoogleActivity : ComponentActivity() {
         /**
          * Notifies that sign in flow completed.
          *
-         * @param account the account signed in or `null` if there were issues signing in.
+         * @param credential the account signed in or `null` if there were issues signing in.
+         * @param serverAuthCode the server auth code, always non-null when [credential] is non-null.
          */
-        abstract fun onSignInComplete(@Nullable account: GoogleSignInAccount?)
+        abstract fun onSignInComplete(
+            credential: GoogleIdTokenCredential?,
+            serverAuthCode: String?
+        )
     }
 
     companion object {

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/Parser.kt

@@ -378,7 +378,7 @@ object Parser {
                     }
                     row.onPress?.let {
                         setOnClickListener {
-                            row.onPress(null)
+                            it(null)
                         }
                     }
                     row.browsable?.let {
@@ -650,7 +650,7 @@ object Parser {
                 // whose backing bitmap has already been recycled or failed to allocate;
                 // copy() can also throw (e.g., OOM on very large remote images). Either
                 // way we return null so the caller falls back to a placeholder icon.
-                return image.underlyingBitmap.copy(Bitmap.Config.ARGB_8888, false)
+                return image.underlyingBitmap?.copy(Bitmap.Config.ARGB_8888, false)
             } else if (image is CloseableXml) {
                 val drawable = image.buildDrawable()
                 return drawable?.toBitmap(

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/SignInTemplate.kt

@@ -1,8 +1,8 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay.template
 
 import android.content.Intent
-import android.net.Uri
 import android.os.Bundle
+import android.util.Base64
 import androidx.car.app.CarContext
 import androidx.car.app.model.Action
 import androidx.car.app.model.ActionStrip
@@ -18,7 +18,9 @@ import androidx.car.app.model.signin.ProviderSignInMethod
 import androidx.car.app.model.signin.QRCodeSignInMethod
 import androidx.car.app.model.signin.SignInTemplate
 import androidx.core.graphics.drawable.IconCompat
-import com.google.android.gms.auth.api.signin.GoogleSignInAccount
+import androidx.core.net.toUri
+import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential
+import com.margelo.nitro.NitroModules
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.KeyboardType
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroAction
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroActionType
@@ -26,8 +28,8 @@ import com.margelo.nitro.swe.iternio.reactnativeautoplay.R
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.SignInTemplateConfig
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.SignInWithGoogleActivity
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.TextInputType
+import org.json.JSONObject
 import java.security.InvalidParameterException
-import androidx.core.net.toUri
 
 class SignInTemplate(
     context: CarContext, config: SignInTemplateConfig
@@ -115,32 +117,35 @@ class SignInTemplate(
                         ).build()
                     )
                     setOnClickListener(ParkedOnlyOnClickListener.create {
-                        val extras = Bundle(1)
+                        val extras = Bundle(2)
                         extras.putBinder(
                             SignInWithGoogleActivity.BINDER_KEY,
                             object : SignInWithGoogleActivity.OnSignInComplete() {
-                                override fun onSignInComplete(account: GoogleSignInAccount?) {
-                                    if (account == null) {
+                                override fun onSignInComplete(
+                                    credential: GoogleIdTokenCredential?,
+                                    serverAuthCode: String?
+                                ) {
+                                    if (credential == null) {
                                         googleSignIn.callback("Error signing in", null)
-                                    } else {
-                                        googleSignIn.callback(
-                                            null,
-                                            com.margelo.nitro.swe.iternio.reactnativeautoplay.GoogleSignInAccount(
-                                                serverAuthCode = account.serverAuthCode,
-                                                email = account.email,
-                                                id = account.id,
-                                                displayName = account.displayName,
-                                                photoUrl = account.photoUrl?.toString(),
-                                                idToken = account.idToken,
-                                                givenName = account.givenName,
-                                                familyName = account.familyName
-                                            )
-                                        )
+                                        return
                                     }
+                                    googleSignIn.callback(
+                                        null,
+                                        com.margelo.nitro.swe.iternio.reactnativeautoplay.GoogleSignInAccount(
+                                            serverAuthCode = serverAuthCode,
+                                            email = credential.id,
+                                            id = subFromIdToken(credential.idToken),
+                                            displayName = credential.displayName,
+                                            photoUrl = credential.profilePictureUri?.toString(),
+                                            idToken = credential.idToken,
+                                            givenName = credential.givenName,
+                                            familyName = credential.familyName
+                                        )
+                                    )
                                 }
                             })
                         extras.putString("serverClientId", googleSignIn.serverClientId)
-                        context.startActivity(
+                        NitroModules.applicationContext?.startActivity(
                             Intent().setClass(context, SignInWithGoogleActivity::class.java)
                                 .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK).putExtras(extras)
                         )
@@ -211,4 +216,13 @@ class SignInTemplate(
         config.onPopped?.let { it() }
         templates.remove(templateId)
     }
+
+    private fun subFromIdToken(idToken: String): String? = runCatching {
+        val payload = idToken.split(".")[1]
+        val json = String(
+            Base64.decode(payload, Base64.URL_SAFE or Base64.NO_PADDING or Base64.NO_WRAP),
+            Charsets.UTF_8
+        )
+        JSONObject(json).getString("sub")
+    }.getOrNull()
 }

package/installTimers.ts

@@ -0,0 +1,3 @@
+// Root re-export so `@iternio/react-native-auto-play/installTimers` is a deliberate, explicitly
+// published public entry point rather than a reach into src/ internals -- see src/installTimers.ts.
+import './src/installTimers';

package/installTimers.web.ts

@@ -0,0 +1,2 @@
+// Web/Jest counterpart to installTimers.ts, picked by Metro's platform resolution.
+import './src/installTimers.web';