@iternio/react-native-auto-play 0.5.3 → 0.5.5

package/README.md

@@ -14,7 +14,7 @@
 ## Features
 
 -   **Cross-Platform:** Write once, run on both Apple CarPlay and Android Auto.
--  **Both Architectures:** Supports both the legacy and the new React Native architecture.
+-   **New Architecture:** Supports React Native new architecture only.
 -   **Template-Based UI:** Utilize a rich set of templates like `MapTemplate`, `ListTemplate`, `GridTemplate`, and more to build UIs that comply with automotive design guidelines.
 -   **Navigation APIs:** Build full-featured navigation experiences with APIs for trip management, maneuvers, and route guidance.
 -   **Dashboard & Cluster Support:** Extend your app's presence to the CarPlay Dashboard (CarPlay only) and instrument cluster displays (CarPlay & Android Auto).
@@ -837,36 +837,95 @@ new ListTemplate({
 
 ### Voice Input
 
-The library provides a cross-platform in-app voice recording API built on top of the car microphone (when connected) or the device microphone (when no car is connected).
+The library provides a cross-platform in-app voice recording API built on top of the car microphone (when connected) or the device microphone (when no car is connected). The voice API lives in `HybridVoice`.
 
 #### Permission
 
 ```ts
-// Check whether permission is already granted
-const granted = HybridAutoPlay.hasVoiceInputPermission();
+import { HybridVoice } from '@iternio/react-native-auto-play';
+
+// Check whether permission is already granted (synchronous)
+const granted = HybridVoice.hasVoiceInputPermission();
 
 // Request permission if not yet granted
-const granted = await HybridAutoPlay.requestVoiceInputPermission();
+const granted = await HybridVoice.requestVoiceInputPermission();
 ```
 
+On **iOS**: checks/requests both microphone and speech recognition authorization.
+On **Android**: checks/requests `RECORD_AUDIO` via the car context when connected, otherwise via the RN application context.
+
 #### Recording
 
 ```ts
-// Start recording — resolves with a raw PCM ArrayBuffer (16 kHz, 16-bit, mono)
-// Recording stops automatically on silence or when maxDurationMs is reached
-const pcmBuffer = await HybridAutoPlay.startVoiceInput(
-  1500,       // silenceThresholdMs (default 1500)
-  10_000,     // maxDurationMs (default 10 000)
-  'Listening...' // text shown on the car screen while recording (iOS CarPlay)
-);
+import { HybridVoice, ErrorUtil } from '@iternio/react-native-auto-play';
+
+try {
+  const result = await HybridVoice.startVoiceInput({
+    silenceThresholdMs: 1500,      // ms of silence before auto-stop (default 1500)
+    maxDurationMs: 10_000,         // hard cap on recording duration (default 10 000)
+    listeningText: 'Listening…',   // iOS CarPlay: text shown on CPVoiceControlTemplate
+    preferSpeechToText: false,     // true → STT transcription; false → raw PCM (default)
+    startSound: require('./beep_start.mp3'), // played just before recording starts
+    endSound: require('./beep_end.mp3'),     // played just after recording stops
+    onChunk: (chunk) => {
+      // chunk.audio — raw PCM ArrayBuffer chunk (PCM mode)
+      // chunk.partial — partial transcription string (STT mode)
+    },
+  });
+
+  if (result.transcription) {
+    console.log('Transcription:', result.transcription);
+  } else if (result.audio) {
+    console.log(`PCM audio: ${result.audio.byteLength} bytes`);
+  }
+} catch (e) {
+  if (ErrorUtil.isVoiceInputCanceledError(e)) {
+    // User pressed the cancel button on the car screen
+    console.log('Voice input cancelled');
+  } else {
+    console.error(e);
+  }
+}
 
-// Stop recording early — resolves startVoiceInput with the audio captured so far
-HybridAutoPlay.stopVoiceInput();
+// Stop recording early — resolves startVoiceInput with audio captured so far
+HybridVoice.stopVoiceInput();
 ```
 
-On **Android**: uses `CarAudioRecord` when Android Auto is connected, otherwise falls back to standard `AudioRecord`.
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `silenceThresholdMs` | `number` | `1500` | Auto-stop after this many ms of silence |
+| `maxDurationMs` | `number` | `10000` | Hard recording time limit |
+| `listeningText` | `string` | — | iOS only — text shown on `CPVoiceControlTemplate` |
+| `listeningImage` | `VoiceInputImage` | — | iOS only — animated image in the CarPlay overlay |
+| `preferSpeechToText` | `boolean` | `false` | `true` → resolve with `{ transcription }`; `false` → resolve with `{ audio }` |
+| `startSound` | `number` | — | Metro asset (`require('./beep.mp3')`) played before recording. Takes audio focus so other apps pause. |
+| `endSound` | `number` | — | Metro asset played after recording stops |
+| `onChunk` | `(chunk) => void` | — | Streaming callback: `chunk.audio` (PCM) or `chunk.partial` (STT) |
+| `language` | `string` | system | BCP-47 language tag for the STT recognizer |
+
+**PCM result** (`preferSpeechToText: false`, default): resolves with `{ audio: ArrayBuffer }` — raw 16 kHz, 16-bit, mono PCM.
+
+**STT result** (`preferSpeechToText: true`): resolves with `{ transcription: string }` on success, or falls back to `{ audio }` if recognition is unavailable.
 
-On **iOS**: presents `CPVoiceControlTemplate` on the car screen when CarPlay is connected, and captures audio via `AVAudioEngine`.
+On **Android**: uses `CarAudioRecord` when Android Auto is connected, otherwise falls back to standard `AudioRecord`. STT uses `SpeechRecognizer`.
+
+On **iOS**: presents `CPVoiceControlTemplate` on the car screen when CarPlay is connected, and captures audio via `AVAudioEngine`. STT uses `SFSpeechRecognizer`.
+
+#### Cancel detection
+
+When the user presses the cancel button on the car screen, `startVoiceInput` rejects with a `voiceInputCancelled` error on both platforms. Use `ErrorUtil.isVoiceInputCanceledError` to distinguish it from other errors:
+
+```ts
+import { ErrorUtil } from '@iternio/react-native-auto-play';
+
+HybridVoice.startVoiceInput().catch((e) => {
+  if (ErrorUtil.isVoiceInputCanceledError(e)) {
+    // user dismissed — no action needed
+  } else {
+    throw e;
+  }
+});
+```
 
 #### OS-triggered voice input (Android only)
 

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

@@ -1,5 +1,10 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
-class TemplateNotFoundException(private val templateId: String): Exception("templateNotFound(\"$templateId\")") {
+class TemplateNotFoundException(private val templateId: String) :
+    Exception("templateNotFound(\"$templateId\")") {
     override fun toString(): String = "templateNotFound(\"$templateId\")"
 }
+
+class VoiceInputCancelledException : Exception("voiceInputCancelled") {
+    override fun toString(): String = "voiceInputCancelled"
+}

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

@@ -50,7 +50,7 @@ class HybridVoice : HybridVoiceSpec() {
                             }
                             cont.resume(
                                 grantResults.isNotEmpty() &&
-                                    grantResults.first() == PackageManager.PERMISSION_GRANTED
+                                        grantResults.first() == PackageManager.PERMISSION_GRANTED
                             )
                             true
                         }
@@ -64,9 +64,13 @@ class HybridVoice : HybridVoiceSpec() {
         silenceThresholdMs: Double?,
         maxDurationMs: Double?,
         listeningText: String?,
+        listeningImage: Variant_GlyphImage_AssetImage_RemoteImage?,
+        listeningImageRepeats: Boolean?,
         preferSpeechToText: Boolean?,
         onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
-        language: String?
+        language: String?,
+        startSoundUri: String?,
+        endSoundUri: String?
     ): Promise<VoiceInputResult> {
         return Promise.async {
             if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
@@ -82,7 +86,9 @@ class HybridVoice : HybridVoiceSpec() {
                     maxDurationMs = maxDurationMs?.toLong() ?: 10_000L,
                     preferSpeechToText = preferSpeechToText ?: false,
                     onChunk = onChunk,
-                    language = language
+                    language = language,
+                    startSoundUri = startSoundUri,
+                    endSoundUri = endSoundUri,
                 )
             } finally {
                 voiceInputManager = null

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

@@ -10,7 +10,9 @@ import android.media.AudioFocusRequest
 import android.media.AudioFormat
 import android.media.AudioManager
 import android.media.AudioRecord
+import android.media.MediaPlayer
 import android.media.MediaRecorder
+import android.net.Uri
 import android.os.Build
 import android.os.Bundle
 import android.os.ParcelFileDescriptor
@@ -62,6 +64,9 @@ class VoiceInputManager(
     @Volatile
     private var isRecording = false
 
+    @Volatile
+    private var cancelledByUser = false
+
     // STT state — only set when SpeechRecognizer owns the mic
     @Volatile
     private var activeSpeechRecognizer: SpeechRecognizer? = null
@@ -72,22 +77,41 @@ class VoiceInputManager(
         maxDurationMs: Long = 10_000,
         preferSpeechToText: Boolean = false,
         onChunk: ((chunk: VoiceInputChunk) -> Unit)? = null,
-        language: String? = null
+        language: String? = null,
+        startSoundUri: String? = null,
+        endSoundUri: String? = null,
     ): VoiceInputResult {
-        if (preferSpeechToText) {
-            val context = NitroModules.applicationContext ?: throw IllegalArgumentException()
-            if (SpeechRecognizer.isRecognitionAvailable(context)) {
-                if (carContext != null) {
-                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                        return startSTTFromCarAudio(silenceThresholdMs, maxDurationMs, onChunk, language)
+        cancelledByUser = false
+        if (!requestAudioFocus()) {
+            throw IllegalStateException("Audio focus request denied")
+        }
+        try {
+            startSoundUri?.let { playSound(it) }
+            val result = if (preferSpeechToText) {
+                val context = NitroModules.applicationContext ?: throw IllegalArgumentException()
+                if (SpeechRecognizer.isRecognitionAvailable(context)) {
+                    if (carContext != null) {
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                            startSTTFromCarAudio(silenceThresholdMs, maxDurationMs, onChunk, language)
+                        } else {
+                            // Car connected but API < 33: EXTRA_AUDIO_SOURCE unavailable, fall back to PCM
+                            startPCM(silenceThresholdMs, maxDurationMs, onChunk)
+                        }
+                    } else {
+                        ThreadUtil.postOnUiAndAwait { startSTT(context, onChunk, language) }.getOrThrow()
                     }
-                    // Car connected but API < 33: EXTRA_AUDIO_SOURCE unavailable, fall back to PCM
-                    return startPCM(silenceThresholdMs, maxDurationMs, onChunk)
+                } else {
+                    startPCM(silenceThresholdMs, maxDurationMs, onChunk)
                 }
-                return ThreadUtil.postOnUiAndAwait { startSTT(context, onChunk, language) }.getOrThrow()
+            } else {
+                startPCM(silenceThresholdMs, maxDurationMs, onChunk)
             }
+            if (cancelledByUser) throw VoiceInputCancelledException()
+            endSoundUri?.let { playSound(it) }
+            return result
+        } finally {
+            abandonAudioFocus()
         }
-        return startPCM(silenceThresholdMs, maxDurationMs, onChunk)
     }
 
     // MARK: - STT path (SpeechRecognizer owns the mic)
@@ -309,35 +333,8 @@ class VoiceInputManager(
             return@suspendCancellableCoroutine
         }
 
-        val appContext = NitroModules.applicationContext ?: run {
-            cont.resumeWithException(SecurityException("Missing application context"))
-            return@suspendCancellableCoroutine
-        }
-
         pcmContinuation = cont
 
-        val audioManager = appContext.getSystemService(AudioManager::class.java)
-
-        val audioAttributes =
-            AudioAttributes.Builder().setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
-                .setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE).build()
-
-        val focusRequest =
-            AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE)
-                .setAudioAttributes(audioAttributes).setOnAudioFocusChangeListener { state ->
-                    if (state == AudioManager.AUDIOFOCUS_LOSS) {
-                        stop()
-                    }
-                }.build()
-
-        if (audioManager.requestAudioFocus(focusRequest) != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
-            pcmContinuation = null
-            cont.resumeWithException(IllegalStateException("Audio focus request denied"))
-            return@suspendCancellableCoroutine
-        }
-
-        audioFocusRequest = focusRequest
-
         val bufferSize: Int
 
         if (carContext != null) {
@@ -381,6 +378,8 @@ class VoiceInputManager(
                     ) ?: -1
 
                     if (read < 0) {
+                        // Whenever the user dismisses the microphone on the car screen, the next call to read will return -1
+                        cancelledByUser = carAudioRecord != null && read == -1
                         break
                     }
 
@@ -450,6 +449,72 @@ class VoiceInputManager(
         audioRecord?.stop()
     }
 
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun requestAudioFocus(): Boolean {
+        val appContext = NitroModules.applicationContext ?: return false
+        val audioManager = appContext.getSystemService(AudioManager::class.java)
+        val audioAttributes = AudioAttributes.Builder()
+            .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+            .setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE)
+            .build()
+        val focusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE)
+            .setAudioAttributes(audioAttributes)
+            .setOnAudioFocusChangeListener { state ->
+                if (state == AudioManager.AUDIOFOCUS_LOSS) { stop() }
+            }
+            .build()
+        return if (audioManager.requestAudioFocus(focusRequest) == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
+            audioFocusRequest = focusRequest
+            true
+        } else {
+            false
+        }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun abandonAudioFocus() {
+        audioFocusRequest?.let {
+            val audioManager = (NitroModules.applicationContext ?: carContext)
+                ?.getSystemService(AudioManager::class.java)
+            audioManager?.abandonAudioFocusRequest(it)
+        }
+        audioFocusRequest = null
+    }
+
+    private suspend fun playSound(uri: String) = suspendCancellableCoroutine<Unit> { cont ->
+        val context = NitroModules.applicationContext ?: run {
+            cont.resume(Unit)
+            return@suspendCancellableCoroutine
+        }
+        val player = MediaPlayer()
+        try {
+            player.setAudioAttributes(
+                AudioAttributes.Builder()
+                    .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                    .setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE)
+                    .build()
+            )
+            player.setDataSource(context, Uri.parse(uri))
+            player.setOnCompletionListener {
+                it.release()
+                if (cont.isActive) { cont.resume(Unit) }
+            }
+            player.setOnErrorListener { mp, _, _ ->
+                mp.release()
+                if (cont.isActive) { cont.resume(Unit) }
+                true
+            }
+            player.prepare()
+            player.start()
+        } catch (_: Exception) {
+            try { player.release() } catch (_: Exception) {}
+            if (cont.isActive) { cont.resume(Unit) }
+        }
+        cont.invokeOnCancellation {
+            try { player.release() } catch (_: Exception) {}
+        }
+    }
+
     @RequiresApi(Build.VERSION_CODES.O)
     private fun releaseResources() {
         carAudioRecord?.stopRecording()
@@ -458,13 +523,6 @@ class VoiceInputManager(
         audioRecord?.release()
         audioRecord = null
         recordingJob = null
-        audioFocusRequest?.let {
-            val audioManager = (NitroModules.applicationContext ?: carContext)?.getSystemService(
-                AudioManager::class.java,
-            )
-            audioManager?.abandonAudioFocusRequest(it)
-        }
-        audioFocusRequest = null
     }
 
     fun dispose() {

package/ios/Types.swift

@@ -10,7 +10,7 @@ struct TemplateEventPayload {
     let state: VisibilityState
 }
 
-enum AutoPlayError: Error {
+enum AutoPlayError: LocalizedError {
     case templateNotFound(String)
     case interfaceControllerNotFound(String)
     case invalidTemplateError(String)
@@ -19,4 +19,5 @@ enum AutoPlayError: Error {
     case invalidTemplateType(String)
     case noUiWindow(String)
     case initReactRootViewFailed(String)
+    case voiceInputCancelled
 }

package/ios/extensions/CarPlayTemplateExtensions.swift

@@ -85,3 +85,10 @@ extension CPAlertTemplate {
         initTemplate(template: self, id: id)
     }
 }
+
+extension CPVoiceControlTemplate {
+    convenience init(voiceControlStates: [CPVoiceControlState], id: String) {
+        self.init(voiceControlStates: voiceControlStates)
+        initTemplate(template: self, id: id)
+    }
+}

package/ios/hybrid/HybridAutoPlay.swift

@@ -22,7 +22,6 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     private static var renderStateListeners = [String: [RenderStateListener]]()
     private static var safeAreaInsetsListeners = [String: [SafeAreaListener]]()
 
-
     override init() {
         HybridAutoPlay.listeners.removeAll()
         HybridAutoPlay.renderStateListeners.removeAll()

package/ios/hybrid/HybridVoice.swift

@@ -32,9 +32,13 @@ class HybridVoice: HybridVoiceSpec {
         silenceThresholdMs: Double?,
         maxDurationMs: Double?,
         listeningText: String?,
+        listeningImage: Variant_GlyphImage_AssetImage_RemoteImage?,
+        listeningImageRepeats: Bool?,
         preferSpeechToText: Bool?,
         onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
-        language: String?
+        language: String?,
+        startSoundUri: String?,
+        endSoundUri: String?
     ) throws -> Promise<VoiceInputResult> {
         return Promise.async {
             let interfaceController = try? await RootModule.withInterfaceController { $0 }
@@ -49,9 +53,13 @@ class HybridVoice: HybridVoiceSpec {
                 silenceThresholdMs: silenceThresholdMs ?? 1_500,
                 maxDurationMs: maxDurationMs ?? 10_000,
                 listeningText: listeningText ?? "Listening...",
+                listeningImage: listeningImage,
+                listeningImageRepeats: listeningImageRepeats,
                 preferSpeechToText: preferSpeechToText ?? false,
                 onChunk: onChunk,
-                language: language
+                language: language,
+                startSoundUri: startSoundUri,
+                endSoundUri: endSoundUri
             )
         }
     }

package/ios/templates/Parser.swift

@@ -6,6 +6,7 @@
 //
 
 import CarPlay
+import ImageIO
 import UIKit
 
 struct HeaderActions {
@@ -939,6 +940,100 @@ class Parser {
         )
     }
 
+    // MARK: - Animated image decoding
+
+    /// Decodes raw image data via ImageIO, walking every frame so animated GIF/APNG/WebP all
+    /// animate. UIImage(data:) only ever decodes the first frame for any of these formats.
+    /// `maxDuration` caps the assembled cycle length; pass `.greatestFiniteMagnitude` to skip capping.
+    static func decodeImage(data: Data, scale: CGFloat, maxDuration: TimeInterval = .greatestFiniteMagnitude)
+        -> UIImage?
+    {
+        guard let source = CGImageSourceCreateWithData(data as CFData, nil) else { return nil }
+        let frameCount = CGImageSourceGetCount(source)
+        guard frameCount > 0 else { return nil }
+
+        guard frameCount > 1 else {
+            guard let cgImage = CGImageSourceCreateImageAtIndex(source, 0, nil) else { return nil }
+            return UIImage(cgImage: cgImage, scale: scale, orientation: .up)
+        }
+
+        var frames: [UIImage] = []
+        var totalDuration: TimeInterval = 0
+        for index in 0..<frameCount {
+            guard let cgImage = CGImageSourceCreateImageAtIndex(source, index, nil) else { continue }
+            totalDuration += frameDuration(source: source, index: index)
+            frames.append(UIImage(cgImage: cgImage, scale: scale, orientation: .up))
+        }
+        guard !frames.isEmpty else { return nil }
+        return UIImage.animatedImage(with: frames, duration: min(totalDuration, maxDuration))
+    }
+
+    /// Reads the per-frame delay from whichever format dictionary ImageIO populated
+    /// (GIF, APNG, or WebP), falling back to a sane default if none is present.
+    private static func frameDuration(source: CGImageSource, index: Int) -> TimeInterval {
+        let defaultDuration: TimeInterval = 0.1
+        guard
+            let properties = CGImageSourceCopyPropertiesAtIndex(source, index, nil) as? [CFString: Any]
+        else { return defaultDuration }
+
+        if let gif = properties[kCGImagePropertyGIFDictionary] as? [CFString: Any] {
+            if let unclamped = gif[kCGImagePropertyGIFUnclampedDelayTime] as? Double, unclamped > 0 {
+                return unclamped
+            }
+            if let delay = gif[kCGImagePropertyGIFDelayTime] as? Double, delay > 0 {
+                return delay
+            }
+        }
+
+        if let png = properties[kCGImagePropertyPNGDictionary] as? [CFString: Any] {
+            if let unclamped = png[kCGImagePropertyAPNGUnclampedDelayTime] as? Double, unclamped > 0 {
+                return unclamped
+            }
+            if let delay = png[kCGImagePropertyAPNGDelayTime] as? Double, delay > 0 {
+                return delay
+            }
+        }
+
+        if let webp = properties[kCGImagePropertyWebPDictionary] as? [CFString: Any],
+            let delay = webp[kCGImagePropertyWebPDelayTime] as? Double, delay > 0
+        {
+            return delay
+        }
+
+        return defaultDuration
+    }
+
+    private static func targetSize(for size: CGSize, max maxSize: CGSize) -> CGSize {
+        guard size.width > maxSize.width || size.height > maxSize.height else { return size }
+        let scale = min(maxSize.width / size.width, maxSize.height / size.height)
+        return CGSize(width: (size.width * scale).rounded(), height: (size.height * scale).rounded())
+    }
+
+    static func resize(_ image: UIImage, max maxSize: CGSize) -> UIImage {
+        let target = targetSize(for: image.size, max: maxSize)
+        guard target != image.size else { return image }
+        return UIGraphicsImageRenderer(size: target).image { _ in
+            image.draw(in: CGRect(origin: .zero, size: target))
+        }
+    }
+
+    /// Resizes every frame of an animated UIImage while preserving the per-frame timing.
+    /// UIImage.draw(in:) only renders the current frame, so resize() alone would collapse
+    /// the animation to a still image.
+    static func resizeAnimated(_ image: UIImage, max maxSize: CGSize) -> UIImage {
+        guard let frames = image.images, !frames.isEmpty else {
+            return resize(image, max: maxSize)
+        }
+        let target = targetSize(for: image.size, max: maxSize)
+        guard target != image.size else { return image }
+        let resizedFrames = frames.map { frame in
+            UIGraphicsImageRenderer(size: target).image { _ in
+                frame.draw(in: CGRect(origin: .zero, size: target))
+            }
+        }
+        return UIImage.animatedImage(with: resizedFrames, duration: image.duration) ?? image
+    }
+
     static func imageFromLanes(
         laneImages: Array<NitroImage>.SubSequence,
         traitCollection: UITraitCollection

package/ios/templates/VoiceInputTemplate.swift

@@ -0,0 +1,33 @@
+import CarPlay
+
+class VoiceInputTemplate: AutoPlayTemplate {
+    let template: CPVoiceControlTemplate
+    private let onDidDisappearCallback: () -> Void
+
+    override func getTemplate() -> CPTemplate {
+        return template
+    }
+
+    init(
+        voiceControlStates: [CPVoiceControlState],
+        id: String,
+        onDidDisappear: @escaping () -> Void
+    ) {
+        self.template = CPVoiceControlTemplate(voiceControlStates: voiceControlStates, id: id)
+        self.onDidDisappearCallback = onDidDisappear
+
+        super.init()
+
+        try? RootModule.withTemplateStore { templateStore in
+            templateStore.addTemplate(template: self, templateId: id)
+        }
+    }
+
+    override func onDidDisappear(animated: Bool) {
+        onDidDisappearCallback()
+
+        try? RootModule.withTemplateStore { templateStore in
+            templateStore.removeTemplate(templateId: self.template.id)
+        }
+    }
+}