@iternio/react-native-auto-play 0.5.12 → 0.5.14-beta

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

@@ -41,6 +41,7 @@ class VirtualRenderer(
     private val isCluster: Boolean = false
 ) {
     private var virtualDisplay: VirtualDisplay? = null
+    private val pendingDisplays = mutableListOf<VirtualDisplay>()
 
     private var reactSurfaceImpl: ReactSurfaceImpl? = null
     private var reactSurfaceView: ReactSurfaceView? = null
@@ -92,8 +93,8 @@ class VirtualRenderer(
                 stableArea = Rect(0, 0, 0, 0)
                 visibleArea = Rect(0, 0, 0, 0)
 
-                virtualDisplay?.release()
-                virtualDisplay = null
+                // Not releasing virtualDisplay here, and not relying on this firing at all (unreliable on
+                // some Automotive devices) -- see applySurface/onDraw sweep for where the old display actually gets freed.
             }
 
             override fun onScroll(distanceX: Float, distanceY: Float) {
@@ -236,10 +237,15 @@ class VirtualRenderer(
         // surface itself is kept alive so JS state survives the resize; the JS side is informed
         // via the windowInformation listener since the window initial prop stays stale.
         val isResize = reactSurfaceView != null && (width != surfaceWidth
-            || height != surfaceHeight || dpi != surfaceContainer.dpi)
+                || height != surfaceHeight || dpi != surfaceContainer.dpi)
 
         val manager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
-        virtualDisplay?.release()
+
+        virtualDisplay?.let {
+            // released once its replacement (created below) has drawn
+            pendingDisplays.add(it)
+        }
+
         virtualDisplay = manager.createVirtualDisplay(
             moduleName,
             surfaceWidth,
@@ -415,6 +421,23 @@ class VirtualRenderer(
                 rootContainer.addView(it)
             }
 
+            rootContainer.viewTreeObserver.addOnDrawListener(object :
+                ViewTreeObserver.OnDrawListener {
+                override fun onDraw() {
+                    rootContainer.post {
+                        rootContainer.viewTreeObserver.removeOnDrawListener(this)
+                        // Releasing here, only once a new display has drawn, avoids the window-absent gap that
+                        // stops Choreographer. Releasing old displays any earlier reintroduces that suspension. It
+                        // freezes the map (Mapbox ValueAnimator) and RN (setInterval/setTimeout) until the phone
+                        // screen is woken.
+                        pendingDisplays.forEach {
+                            it.release()
+                        }
+                        pendingDisplays.clear()
+                    }
+                }
+            })
+
             setContentView(rootContainer)
         }
     }
@@ -491,6 +514,13 @@ class VirtualRenderer(
         virtualDisplay?.release()
         virtualDisplay = null
 
+        pendingDisplays.forEach {
+            // make sure to release any pending displays in case
+            // the new one did not draw yet but stop is called
+            it.release()
+        }
+        pendingDisplays.clear()
+
         try {
             stopReactSurface()
         } finally {

package/ios/hybrid/HybridAutoPlay.swift

@@ -18,14 +18,26 @@ struct SafeAreaListener {
 }
 
 class HybridAutoPlay: HybridAutoPlaySpec {
+    /// Guards the three listener dictionaries below. They are mutated from the
+    /// JS thread (add/remove) and read from the main thread (UIKit layout
+    /// driving `emitSafeAreaInsets`), so every access must be serialised.
+    private static let listenersLock = NSLock()
     private static var listeners = [EventName: [StateListener]]()
     private static var renderStateListeners = [String: [RenderStateListener]]()
     private static var safeAreaInsetsListeners = [String: [SafeAreaListener]]()
 
+    private static func withListenersLock<T>(_ body: () -> T) -> T {
+        listenersLock.lock()
+        defer { listenersLock.unlock() }
+        return body()
+    }
+
     override init() {
-        HybridAutoPlay.listeners.removeAll()
-        HybridAutoPlay.renderStateListeners.removeAll()
-        HybridAutoPlay.safeAreaInsetsListeners.removeAll()
+        HybridAutoPlay.withListenersLock {
+            HybridAutoPlay.listeners.removeAll()
+            HybridAutoPlay.renderStateListeners.removeAll()
+            HybridAutoPlay.safeAreaInsetsListeners.removeAll()
+        }
         super.init()
     }
 
@@ -34,18 +46,22 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     {
         let listener = StateListener(id: UUID(), callback: callback)
 
-        HybridAutoPlay.listeners[eventType, default: []].append(listener)
+        HybridAutoPlay.withListenersLock {
+            HybridAutoPlay.listeners[eventType, default: []].append(listener)
+        }
 
         if eventType == .didconnect && SceneStore.isRootModuleConnected() {
             callback()
         }
 
         return {
-            HybridAutoPlay.listeners[eventType]?.removeAll {
-                $0.id == listener.id
-            }
-            if HybridAutoPlay.listeners[eventType]?.isEmpty ?? false {
-                HybridAutoPlay.listeners.removeValue(forKey: eventType)
+            HybridAutoPlay.withListenersLock {
+                HybridAutoPlay.listeners[eventType]?.removeAll {
+                    $0.id == listener.id
+                }
+                if HybridAutoPlay.listeners[eventType]?.isEmpty ?? false {
+                    HybridAutoPlay.listeners.removeValue(forKey: eventType)
+                }
             }
         }
     }
@@ -56,24 +72,28 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     ) throws -> () -> Void {
         let listener = RenderStateListener(id: UUID(), callback: callback)
 
-        HybridAutoPlay.renderStateListeners[moduleName, default: []].append(
-            listener
-        )
+        HybridAutoPlay.withListenersLock {
+            HybridAutoPlay.renderStateListeners[moduleName, default: []].append(
+                listener
+            )
+        }
 
         if let state = SceneStore.getState(moduleName: moduleName) {
             callback(state)
         }
 
         return {
-            HybridAutoPlay.renderStateListeners[moduleName]?.removeAll {
-                $0.id == listener.id
-            }
-            if HybridAutoPlay.renderStateListeners[moduleName]?.isEmpty
-                ?? false
-            {
-                HybridAutoPlay.renderStateListeners.removeValue(
-                    forKey: moduleName
-                )
+            HybridAutoPlay.withListenersLock {
+                HybridAutoPlay.renderStateListeners[moduleName]?.removeAll {
+                    $0.id == listener.id
+                }
+                if HybridAutoPlay.renderStateListeners[moduleName]?.isEmpty
+                    ?? false
+                {
+                    HybridAutoPlay.renderStateListeners.removeValue(
+                        forKey: moduleName
+                    )
+                }
             }
         }
     }
@@ -92,9 +112,10 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     ) throws -> () -> Void {
         let listener = SafeAreaListener(id: UUID(), callback: callback)
 
-        HybridAutoPlay.safeAreaInsetsListeners[moduleName, default: []].append(
-            listener
-        )
+        HybridAutoPlay.withListenersLock {
+            HybridAutoPlay.safeAreaInsetsListeners[moduleName, default: []]
+                .append(listener)
+        }
 
         if let safeAreaInsets = SceneStore.getScene(moduleName: moduleName)?
             .safeAreaInsets
@@ -106,15 +127,17 @@ class HybridAutoPlay: HybridAutoPlaySpec {
         }
 
         return {
-            HybridAutoPlay.safeAreaInsetsListeners[moduleName]?.removeAll {
-                $0.id == listener.id
-            }
-            if HybridAutoPlay.safeAreaInsetsListeners[moduleName]?.isEmpty
-                ?? false
-            {
-                HybridAutoPlay.safeAreaInsetsListeners.removeValue(
-                    forKey: moduleName
-                )
+            HybridAutoPlay.withListenersLock {
+                HybridAutoPlay.safeAreaInsetsListeners[moduleName]?.removeAll {
+                    $0.id == listener.id
+                }
+                if HybridAutoPlay.safeAreaInsetsListeners[moduleName]?.isEmpty
+                    ?? false
+                {
+                    HybridAutoPlay.safeAreaInsetsListeners.removeValue(
+                        forKey: moduleName
+                    )
+                }
             }
         }
     }
@@ -298,14 +321,21 @@ class HybridAutoPlay: HybridAutoPlaySpec {
 
     // MARK: events
     static func emit(event: EventName) {
-        HybridAutoPlay.listeners[event]?.forEach { listener in
+        // Snapshot under the lock, then call out without holding it so a
+        // callback that adds or removes a listener cannot deadlock.
+        let listeners = HybridAutoPlay.withListenersLock {
+            HybridAutoPlay.listeners[event] ?? []
+        }
+        listeners.forEach { listener in
             listener.callback()
         }
     }
 
     static func emitRenderState(moduleName: String, state: VisibilityState) {
-        HybridAutoPlay.renderStateListeners[moduleName]?.forEach {
-            listener in
+        let listeners = HybridAutoPlay.withListenersLock {
+            HybridAutoPlay.renderStateListeners[moduleName] ?? []
+        }
+        listeners.forEach { listener in
             listener.callback(state)
         }
     }
@@ -317,14 +347,19 @@ class HybridAutoPlay: HybridAutoPlaySpec {
         let insets = HybridAutoPlay.getSafeAreaInsets(
             safeAreaInsets: safeAreaInsets
         )
-        HybridAutoPlay.safeAreaInsetsListeners[moduleName]?.forEach {
-            listener in listener.callback(insets)
+        let listeners = HybridAutoPlay.withListenersLock {
+            HybridAutoPlay.safeAreaInsetsListeners[moduleName] ?? []
         }
+        listeners.forEach { listener in listener.callback(insets) }
     }
 
     static func removeListeners(templateId: String) {
-        HybridAutoPlay.renderStateListeners.removeValue(forKey: templateId)
-        HybridAutoPlay.safeAreaInsetsListeners.removeValue(forKey: templateId)
+        HybridAutoPlay.withListenersLock {
+            HybridAutoPlay.renderStateListeners.removeValue(forKey: templateId)
+            HybridAutoPlay.safeAreaInsetsListeners.removeValue(
+                forKey: templateId
+            )
+        }
     }
 
     static func getSafeAreaInsets(safeAreaInsets: UIEdgeInsets)

package/ios/hybrid/HybridCarPlayDashboard.swift

@@ -7,26 +7,40 @@
 import NitroModules
 
 class HybridCarPlayDashboard: HybridCarPlayDashboardSpec {
+    /// Guards the listener dictionaries below. `addListener*` mutate them from
+    /// the JS thread while `DashboardSceneDelegate` emits from main-thread
+    /// CarPlay callbacks, and Swift dictionaries are not thread-safe.
+    private static let listenersLock = NSLock()
     private static var listeners = [EventName: [String: () -> Void]]()
     private static var colorSchemeListeners = [
         String: (_:ColorScheme) -> Void
     ]()
 
+    private static func withListenersLock<T>(_ body: () -> T) -> T {
+        listenersLock.lock()
+        defer { listenersLock.unlock() }
+        return body()
+    }
+
     func addListener(eventType: EventName, callback: @escaping () -> Void)
         throws -> () -> Void
     {
         let uuid = UUID().uuidString
-        HybridCarPlayDashboard.listeners[eventType, default: [:]][uuid] =
-            callback
+        HybridCarPlayDashboard.withListenersLock {
+            HybridCarPlayDashboard.listeners[eventType, default: [:]][uuid] =
+                callback
+        }
 
         if eventType == .didconnect && SceneStore.isDashboardModuleConnected() {
             callback()
         }
 
         return {
-            HybridCarPlayDashboard.listeners[eventType]?.removeValue(
-                forKey: uuid
-            )
+            HybridCarPlayDashboard.withListenersLock {
+                _ = HybridCarPlayDashboard.listeners[eventType]?.removeValue(
+                    forKey: uuid
+                )
+            }
         }
     }
 
@@ -54,23 +68,36 @@ class HybridCarPlayDashboard: HybridCarPlayDashboardSpec {
         callback: @escaping (_ payload: ColorScheme) -> Void
     ) throws -> () -> Void {
         let uuid = UUID().uuidString
-        HybridCarPlayDashboard.colorSchemeListeners[uuid] = callback
+        HybridCarPlayDashboard.withListenersLock {
+            HybridCarPlayDashboard.colorSchemeListeners[uuid] = callback
+        }
 
         return {
-            HybridCarPlayDashboard.colorSchemeListeners.removeValue(
-                forKey: uuid
-            )
+            HybridCarPlayDashboard.withListenersLock {
+                _ = HybridCarPlayDashboard.colorSchemeListeners.removeValue(
+                    forKey: uuid
+                )
+            }
         }
     }
 
     static func emit(event: EventName) {
-        HybridCarPlayDashboard.listeners[event]?.values.forEach {
+        // Snapshot under the lock, then call out without holding it so a
+        // callback that adds or removes a listener cannot deadlock.
+        let listeners = HybridCarPlayDashboard.withListenersLock {
+            HybridCarPlayDashboard.listeners[event].map { Array($0.values) }
+                ?? []
+        }
+        listeners.forEach {
             $0()
         }
     }
 
     static func emitColorScheme(colorScheme: ColorScheme) {
-        HybridCarPlayDashboard.colorSchemeListeners.values.forEach {
+        let listeners = HybridCarPlayDashboard.withListenersLock {
+            Array(HybridCarPlayDashboard.colorSchemeListeners.values)
+        }
+        listeners.forEach {
             $0(colorScheme)
         }
     }

package/ios/hybrid/HybridCluster.swift

@@ -7,6 +7,11 @@
 import NitroModules
 
 class HybridCluster: HybridClusterSpec {
+    /// Guards every listener dictionary below. `addListener*` mutate them from
+    /// the JS thread while `ClusterSceneDelegate` emits from main-thread
+    /// CarPlay callbacks, and Swift dictionaries are not thread-safe.
+    private static let listenersLock = NSLock()
+
     private static var listeners = [
         ClusterEventName: [String: (_:String) -> Void]
     ]()
@@ -31,12 +36,20 @@ class HybridCluster: HybridClusterSpec {
         String: (_: String, _: Bool) -> Void
     ]()
 
+    private static func withListenersLock<T>(_ body: () -> T) -> T {
+        listenersLock.lock()
+        defer { listenersLock.unlock() }
+        return body()
+    }
+
     override init() {
-        HybridCluster.listeners.removeAll()
-        HybridCluster.colorSchemeListeners.removeAll()
-        HybridCluster.zoomListeners.removeAll()
-        HybridCluster.compassListeners.removeAll()
-        HybridCluster.speedLimitListeners.removeAll()
+        HybridCluster.withListenersLock {
+            HybridCluster.listeners.removeAll()
+            HybridCluster.colorSchemeListeners.removeAll()
+            HybridCluster.zoomListeners.removeAll()
+            HybridCluster.compassListeners.removeAll()
+            HybridCluster.speedLimitListeners.removeAll()
+        }
         super.init()
     }
 
@@ -45,20 +58,22 @@ class HybridCluster: HybridClusterSpec {
         callback: @escaping (_ clusterId: String) -> Void
     ) throws -> () -> Void {
         let uuid = UUID().uuidString
-        HybridCluster.listeners[eventType, default: [:]][uuid] =
-            callback
+        let queuedClusterIds = HybridCluster.withListenersLock {
+            () -> [String]? in
+            HybridCluster.listeners[eventType, default: [:]][uuid] = callback
 
-        if let queuedClusterIds = HybridCluster.eventQueue[eventType] {
-            for clusterId in queuedClusterIds {
-                callback(clusterId)
-            }
-            HybridCluster.eventQueue[eventType] = nil
+            return HybridCluster.eventQueue.removeValue(forKey: eventType)
         }
 
+        // Drain the queue outside the lock — the callback runs JS.
+        queuedClusterIds?.forEach { clusterId in callback(clusterId) }
+
         return {
-            HybridCluster.listeners[eventType]?.removeValue(
-                forKey: uuid
-            )
+            HybridCluster.withListenersLock {
+                _ = HybridCluster.listeners[eventType]?.removeValue(
+                    forKey: uuid
+                )
+            }
         }
     }
 
@@ -90,7 +105,17 @@ class HybridCluster: HybridClusterSpec {
         attributedInactiveDescriptionVariants:
             [NitroAttributedString]
     ) throws {
-        if #available(iOS 15.4, *) {
+        guard #available(iOS 15.4, *) else {
+            throw AutoPlayError.unsupportedVersion(
+                "Cluster support only available on iOS >= 15.4"
+            )
+        }
+
+        // This runs on the JS thread, but it ends up assigning
+        // CPInstrumentClusterController.attributedInactiveDescriptionVariants,
+        // which is main-thread only — and the stored variants are also read
+        // from main-thread trait/content-style callbacks.
+        Task { @MainActor in
             guard
                 let scene = SceneStore.getClusterScene(
                     clusterId: clusterId
@@ -104,23 +129,22 @@ class HybridCluster: HybridClusterSpec {
                     attributedInactiveDescriptionVariants
             )
         }
-        else {
-            throw AutoPlayError.unsupportedVersion(
-                "Cluster support only available on iOS >= 15.4"
-            )
-        }
     }
 
     func addListenerColorScheme(
         callback: @escaping (String, ColorScheme) -> Void
     ) throws -> () -> Void {
         let uuid = UUID().uuidString
-        HybridCluster.colorSchemeListeners[uuid] = callback
+        HybridCluster.withListenersLock {
+            HybridCluster.colorSchemeListeners[uuid] = callback
+        }
 
         return {
-            HybridCluster.colorSchemeListeners.removeValue(
-                forKey: uuid
-            )
+            HybridCluster.withListenersLock {
+                _ = HybridCluster.colorSchemeListeners.removeValue(
+                    forKey: uuid
+                )
+            }
         }
     }
 
@@ -128,12 +152,16 @@ class HybridCluster: HybridClusterSpec {
         callback: @escaping (_ clusterId: String, _ payload: ZoomEvent) -> Void
     ) throws -> () -> Void {
         let uuid = UUID().uuidString
-        HybridCluster.zoomListeners[uuid] = callback
+        HybridCluster.withListenersLock {
+            HybridCluster.zoomListeners[uuid] = callback
+        }
 
         return {
-            HybridCluster.zoomListeners.removeValue(
-                forKey: uuid
-            )
+            HybridCluster.withListenersLock {
+                _ = HybridCluster.zoomListeners.removeValue(
+                    forKey: uuid
+                )
+            }
         }
     }
 
@@ -141,12 +169,16 @@ class HybridCluster: HybridClusterSpec {
         callback: @escaping (_ clusterId: String, _ payload: Bool) -> Void
     ) throws -> () -> Void {
         let uuid = UUID().uuidString
-        HybridCluster.compassListeners[uuid] = callback
+        HybridCluster.withListenersLock {
+            HybridCluster.compassListeners[uuid] = callback
+        }
 
         return {
-            HybridCluster.compassListeners.removeValue(
-                forKey: uuid
-            )
+            HybridCluster.withListenersLock {
+                _ = HybridCluster.compassListeners.removeValue(
+                    forKey: uuid
+                )
+            }
         }
     }
 
@@ -154,48 +186,72 @@ class HybridCluster: HybridClusterSpec {
         callback: @escaping (_ clusterId: String, _ payload: Bool) -> Void
     ) throws -> () -> Void {
         let uuid = UUID().uuidString
-        HybridCluster.speedLimitListeners[uuid] = callback
+        HybridCluster.withListenersLock {
+            HybridCluster.speedLimitListeners[uuid] = callback
+        }
 
         return {
-            HybridCluster.speedLimitListeners.removeValue(
-                forKey: uuid
-            )
+            HybridCluster.withListenersLock {
+                _ = HybridCluster.speedLimitListeners.removeValue(
+                    forKey: uuid
+                )
+            }
         }
     }
 
     static func emit(event: ClusterEventName, clusterId: String) {
-        guard let listeners = HybridCluster.listeners[event], !listeners.isEmpty
-        else {
-            // no listeners -> queue the event
-            HybridCluster.eventQueue[event, default: []].append(clusterId)
-            return
+        // Snapshot under the lock, then call out without holding it so a
+        // callback that adds or removes a listener cannot deadlock.
+        let listeners = HybridCluster.withListenersLock {
+            () -> [(_: String) -> Void] in
+            guard let listeners = HybridCluster.listeners[event],
+                !listeners.isEmpty
+            else {
+                // no listeners -> queue the event
+                HybridCluster.eventQueue[event, default: []].append(clusterId)
+                return []
+            }
+
+            return Array(listeners.values)
         }
 
-        listeners.values.forEach {
+        listeners.forEach {
             $0(clusterId)
         }
     }
 
     static func emitColorScheme(clusterId: String, colorScheme: ColorScheme) {
-        HybridCluster.colorSchemeListeners.values.forEach {
+        let listeners = HybridCluster.withListenersLock {
+            Array(HybridCluster.colorSchemeListeners.values)
+        }
+        listeners.forEach {
             $0(clusterId, colorScheme)
         }
     }
 
     static func emitZoom(clusterId: String, payload: ZoomEvent) {
-        HybridCluster.zoomListeners.values.forEach {
+        let listeners = HybridCluster.withListenersLock {
+            Array(HybridCluster.zoomListeners.values)
+        }
+        listeners.forEach {
             $0(clusterId, payload)
         }
     }
 
     static func emitCompass(clusterId: String, payload: Bool) {
-        HybridCluster.compassListeners.values.forEach {
+        let listeners = HybridCluster.withListenersLock {
+            Array(HybridCluster.compassListeners.values)
+        }
+        listeners.forEach {
             $0(clusterId, payload)
         }
     }
 
     static func emitSpeedLimit(clusterId: String, payload: Bool) {
-        HybridCluster.speedLimitListeners.values.forEach {
+        let listeners = HybridCluster.withListenersLock {
+            Array(HybridCluster.speedLimitListeners.values)
+        }
+        listeners.forEach {
             $0(clusterId, payload)
         }
     }

package/ios/scenes/SceneStore.swift

@@ -12,36 +12,49 @@ class SceneStore {
     static let dashboardModuleName = "CarPlayDashboard"
     static let windowSceneModuleName = "main"
 
+    /// Guards `renderState` and `store`. Scenes are added/removed on the main
+    /// thread while the dictionaries are read from the JS thread, and Swift
+    /// dictionaries are not thread-safe.
+    private static let lock = NSLock()
+
     private static var renderState = [String: VisibilityState]()
 
     private static var store: [String: AutoPlayScene] = [:]
 
+    private static func withLock<T>(_ body: () -> T) -> T {
+        lock.lock()
+        defer { lock.unlock() }
+        return body()
+    }
+
     static func addScene(moduleName: String, scene: AutoPlayScene) {
-        store[moduleName] = scene
+        withLock { store[moduleName] = scene }
     }
 
     static func removeScene(moduleName: String) {
-        store.removeValue(forKey: moduleName)
+        let _ = withLock { store.removeValue(forKey: moduleName) }
     }
 
     static func getScene(moduleName: String) -> AutoPlayScene? {
-        return store[moduleName]
+        return withLock { store[moduleName] }
     }
 
     static func isRootModuleConnected() -> Bool {
-        return store[SceneStore.rootModuleName]?.isConnected ?? false
+        return getScene(moduleName: SceneStore.rootModuleName)?.isConnected
+            ?? false
     }
 
     static func isDashboardModuleConnected() -> Bool {
-        return store[SceneStore.dashboardModuleName]?.isConnected ?? false
+        return getScene(moduleName: SceneStore.dashboardModuleName)?.isConnected
+            ?? false
     }
 
     static func getState(moduleName: String) -> VisibilityState? {
-        return renderState[moduleName]
+        return withLock { renderState[moduleName] }
     }
 
     static func setState(moduleName: String, state: VisibilityState) {
-        renderState[moduleName] = state
+        withLock { renderState[moduleName] = state }
 
         HybridAutoPlay.emitRenderState(
             moduleName: moduleName,
@@ -77,10 +90,10 @@ class SceneStore {
     }
 
     static func getRootScene() -> AutoPlayScene? {
-        return store[SceneStore.rootModuleName]
+        return getScene(moduleName: SceneStore.rootModuleName)
     }
 
     static func getRootTraitCollection() -> UITraitCollection? {
-        return store[SceneStore.rootModuleName]?.traitCollection
+        return getRootScene()?.traitCollection
     }
 }

package/ios/templates/TemplateStore.swift

@@ -7,47 +7,67 @@
 import CarPlay
 
 class TemplateStore {
+    /// Guards `store`. Templates are added from the JS thread (the
+    /// `createXTemplate` hybrid methods are synchronous and never hop actors)
+    /// while the CarPlay delegate callbacks remove/purge them on the main
+    /// thread, and Swift dictionaries are not thread-safe.
+    private let lock = NSLock()
     private var store: [String: AutoPlayTemplate] = [:]
 
+    private func withLock<T>(_ body: () -> T) -> T {
+        lock.lock()
+        defer { lock.unlock() }
+        return body()
+    }
+
     func getCPTemplate(templateId key: String) -> CPTemplate? {
-        return store[key]?.getTemplate()
+        return withLock { store[key] }?.getTemplate()
     }
 
     func getTemplate(templateId: String) throws -> AutoPlayTemplate {
-        if let template = store[templateId] {
+        if let template = withLock({ store[templateId] }) {
             return template
         }
         throw AutoPlayError.templateNotFound(templateId)
     }
 
     func addTemplate(template: AutoPlayTemplate, templateId: String) {
-        store[templateId] = template
+        withLock { store[templateId] = template }
     }
 
     func removeTemplate(templateId: String) {
-        store[templateId]?.onPopped()
+        // Remove first, then notify outside the lock: `onPopped` runs a JS
+        // callback which can re-enter the store (see
+        // VoiceInputTemplate.onDidDisappear).
+        let removed = withLock { store.removeValue(forKey: templateId) }
 
-        store.removeValue(forKey: templateId)
+        removed?.onPopped()
     }
 
     func removeTemplates(templateIds: [String]) {
-        templateIds.forEach { templateId in
-            store[templateId]?.onPopped()
+        let removed = withLock {
+            templateIds.compactMap { store.removeValue(forKey: $0) }
         }
 
-        store = store.filter { !templateIds.contains($0.key) }
+        removed.forEach { template in template.onPopped() }
     }
 
     func purge() {
-        store = store.filter { !($0.value.getTemplate() is CPSearchTemplate) }
+        withLock {
+            store = store.filter {
+                !($0.value.getTemplate() is CPSearchTemplate)
+            }
+        }
     }
 
     @MainActor
     func traitCollectionDidChange() {
-        store.values.forEach { template in template.traitCollectionDidChange() }
+        let templates = withLock { Array(store.values) }
+
+        templates.forEach { template in template.traitCollectionDidChange() }
     }
 
     func disconnect() {
-        store = [:]
+        withLock { store = [:] }
     }
 }

package/ios/utils/SymbolFont.swift

@@ -9,10 +9,17 @@ import CoreText
 import UIKit
 
 class SymbolFont {
+    /// Guards the font cache below. Glyphs are rendered both during template
+    /// construction on the JS thread and from `@MainActor` template
+    /// invalidation, so the cache is touched from more than one thread.
+    private static let cacheLock = NSLock()
     private static var cachedFontName: String?
     private static var cachedPSName: String?
 
     private static func loadFont(named fontName: String) -> String? {
+        cacheLock.lock()
+        defer { cacheLock.unlock() }
+
         if fontName == cachedFontName {
             return cachedPSName
         }

package/ios/utils/VoiceInputManager.swift

@@ -307,9 +307,11 @@ class VoiceInputManager {
             throw VoiceInputError.converterUnavailable
         }
 
-        recordingStart = Date()
-        silenceStart = nil
-        firstBufferContinuation = nil
+        stopLock.withLock {
+            recordingStart = Date()
+            silenceStart = nil
+            firstBufferContinuation = nil
+        }
 
         inputNode.installTap(
             onBus: 0,
@@ -381,18 +383,22 @@ class VoiceInputManager {
                 now.timeIntervalSince(start) * 1000 >= VoiceInputManager.warmupMs
             {
                 let peak = newSamples.reduce(0) { max($0, abs(Int($1))) }
-                if peak < VoiceInputManager.silenceAmplitudeThreshold {
-                    if self.silenceStart == nil {
-                        self.silenceStart = now
-                    }
-                    if let silenceBegin = self.silenceStart,
-                        now.timeIntervalSince(silenceBegin) * 1000 >= silenceThresholdMs
-                    {
-                        self.triggerAutoStop(interfaceController: interfaceController)
+                // `silenceStart` is also cleared from cleanup() on another
+                // thread, so the read-modify-write has to hold stopLock.
+                let silenceElapsedMs = self.stopLock.withLock { () -> Double? in
+                    guard peak < VoiceInputManager.silenceAmplitudeThreshold else {
+                        self.silenceStart = nil
+                        return nil
                     }
+
+                    let silenceBegin = self.silenceStart ?? now
+                    self.silenceStart = silenceBegin
+
+                    return now.timeIntervalSince(silenceBegin) * 1000
                 }
-                else {
-                    self.silenceStart = nil
+
+                if let silenceElapsedMs, silenceElapsedMs >= silenceThresholdMs {
+                    self.triggerAutoStop(interfaceController: interfaceController)
                 }
             }
         }
@@ -412,10 +418,11 @@ class VoiceInputManager {
         audioEngine?.stop()
         audioEngine = nil
         recognitionRequest = nil
-        recordingStart = nil
-        silenceStart = nil
         // Drain firstBufferContinuation so the template Task doesn't hang if stop() fired before the first buffer.
         let pendingCont = stopLock.withLock { () -> CheckedContinuation<Void, Never>? in
+            recordingStart = nil
+            silenceStart = nil
+
             let c = firstBufferContinuation
             firstBufferContinuation = nil
             return c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iternio/react-native-auto-play",
-  "version": "0.5.12",
+  "version": "0.5.14-beta",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",