@iternio/react-native-auto-play 0.3.11 → 0.3.12

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

@@ -6,6 +6,7 @@ import androidx.car.app.CarContext
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.AssetImage
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.GlyphImage
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroColor
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.RemoteImage
 
 object BitmapCache {
     private val maxMemory = Runtime.getRuntime().maxMemory()
@@ -37,6 +38,16 @@ object BitmapCache {
         put(key, bitmap)
     }
 
+    fun get(context: CarContext, image: RemoteImage): Bitmap? {
+        val key = image.cacheKey(context)
+        return get(key)
+    }
+
+    fun put(context: CarContext, image: RemoteImage, bitmap: Bitmap) {
+        val key = image.cacheKey(context)
+        put(key, bitmap)
+    }
+
     private fun get(key: String): Bitmap? {
         synchronized(bitmapCache) {
             return bitmapCache.get(key)
@@ -56,5 +67,8 @@ fun NitroColor.get(context: CarContext): Int =
 fun AssetImage.cacheKey(context: CarContext): String =
     this.color?.let { "${this.uri}/${it.get(context)}" } ?: run { this.uri }
 
+fun RemoteImage.cacheKey(context: CarContext): String =
+    this.color?.let { "${this.uri}/${it.get(context)}" } ?: run { this.uri }
+
 fun GlyphImage.cacheKey(context: CarContext): String =
     "$glyph/${color.get(context)}/${backgroundColor.get(context)}/$fontScale"

package/ios/extensions/NitroImageExtensions.swift

@@ -8,6 +8,7 @@
 protocol ImageProtocol {
     var glyphImage: GlyphImage? { get }
     var assetImage: AssetImage? { get }
+    var remoteImage: RemoteImage? { get }
 }
 
 extension NitroImage: ImageProtocol {
@@ -19,9 +20,13 @@ extension NitroImage: ImageProtocol {
         if case .second(let asset) = self { return asset }
         return nil
     }
+    var remoteImage: RemoteImage? {
+        if case .third(let remote) = self { return remote }
+        return nil
+    }
 }
 
-extension Variant_GlyphImage_AssetImage: ImageProtocol {
+extension Variant_GlyphImage_AssetImage_RemoteImage: ImageProtocol {
     var glyphImage: GlyphImage? {
         if case .first(let glyph) = self { return glyph }
         return nil
@@ -30,4 +35,8 @@ extension Variant_GlyphImage_AssetImage: ImageProtocol {
         if case .second(let asset) = self { return asset }
         return nil
     }
+    var remoteImage: RemoteImage? {
+        if case .third(let remote) = self { return remote }
+        return nil
+    }
 }

package/ios/hybrid/HybridAutoPlay.swift

@@ -1,3 +1,4 @@
+import AVFoundation
 import CarPlay
 import NitroModules
 
@@ -20,6 +21,7 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     private static var listeners = [EventName: [StateListener]]()
     private static var renderStateListeners = [String: [RenderStateListener]]()
     private static var safeAreaInsetsListeners = [String: [SafeAreaListener]]()
+    private static var voiceInputManager: VoiceInputManager?
 
     override init() {
         HybridAutoPlay.listeners.removeAll()
@@ -117,10 +119,55 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     func addListenerVoiceInput(
         callback: @escaping (Location?, String?) -> Void
     ) throws -> () -> Void {
-        // TODO: Inplement voice input
+        // iOS does not use the OS-triggered voice input path — use startVoiceInput() instead.
         return {}
     }
 
+    func hasVoiceInputPermission() throws -> Bool {
+        return AVAudioSession.sharedInstance().recordPermission == .granted
+    }
+
+    func requestVoiceInputPermission() throws -> Promise<Bool> {
+        return Promise.async {
+            return await withCheckedContinuation { cont in
+                AVAudioSession.sharedInstance().requestRecordPermission { granted in
+                    cont.resume(returning: granted)
+                }
+            }
+        }
+    }
+
+    func startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?) throws -> Promise<
+        ArrayBuffer
+    > {
+        return Promise.async {
+            let interfaceController = try? await RootModule.withInterfaceController { $0 }
+
+            let manager = VoiceInputManager()
+            HybridAutoPlay.voiceInputManager = manager
+
+            defer {
+                HybridAutoPlay.voiceInputManager = nil
+            }
+
+            let data = try await manager.start(
+                interfaceController: interfaceController,
+                silenceThresholdMs: silenceThresholdMs ?? 1_500,
+                maxDurationMs: maxDurationMs ?? 10_000,
+                listeningText: listeningText ?? "Listening..."
+            )
+
+            return try ArrayBuffer.copy(data: data)
+        }
+    }
+
+    func stopVoiceInput() throws {
+        Task { @MainActor in
+            let interfaceController = try? await RootModule.withInterfaceController { $0 }
+            HybridAutoPlay.voiceInputManager?.stop(interfaceController: interfaceController)
+        }
+    }
+
     // MARK: set/push/pop templates
     func setRootTemplate(templateId: String) throws -> Promise<Void> {
         return Promise.async {
@@ -151,7 +198,7 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     }
 
     func pushTemplate(templateId: String) throws
-        -> NitroModules.Promise<Void>
+        -> Promise<Void>
     {
         return Promise.async {
             try await RootModule.withSceneAndInterfaceController {
@@ -201,7 +248,7 @@ class HybridAutoPlay: HybridAutoPlaySpec {
         }
     }
 
-    func popTemplate(animate: Bool?) throws -> NitroModules.Promise<Void> {
+    func popTemplate(animate: Bool?) throws -> Promise<Void> {
         return Promise.async {
             try await RootModule.withInterfaceController {
                 interfaceController in
@@ -222,7 +269,7 @@ class HybridAutoPlay: HybridAutoPlaySpec {
         }
     }
 
-    func popToRootTemplate(animate: Bool?) throws -> NitroModules.Promise<Void> {
+    func popToRootTemplate(animate: Bool?) throws -> Promise<Void> {
         return Promise.async {
             try await RootModule.withInterfaceController {
                 interfaceController in

package/ios/templates/GridTemplate.swift

@@ -69,6 +69,13 @@ class GridTemplate: AutoPlayHeaderProviding {
                 )
             }
 
+            if let remoteImage = button.image.remoteImage {
+                image = Parser.parseRemoteImage(
+                    remoteImage: remoteImage,
+                    traitCollection: traitCollection
+                )
+            }
+
             guard let image = image else { return nil }
             guard let title = Parser.parseText(text: button.title) else { return nil }
 

package/ios/templates/MapTemplate.swift

@@ -127,6 +127,20 @@ class MapTemplate: AutoPlayHeaderProviding,
                     button.onPress?()
                 }
             }
+            if let remoteImage = button.image.remoteImage,
+                let icon = Parser.parseRemoteImage(
+                    remoteImage: remoteImage,
+                    traitCollection: traitCollection
+                )
+            {
+                return CPMapButton(image: icon) { _ in
+                    if button.type == .pan {
+                        self.onPanButtonPress()
+                        return
+                    }
+                    button.onPress?()
+                }
+            }
 
             return CPMapButton { _ in
                 if button.type == .pan {

package/ios/templates/Parser.swift

@@ -74,6 +74,12 @@ class Parser {
                         traitCollection: traitCollection
                     )
                 }
+                if let remoteImage = action.image?.remoteImage {
+                    image = Parser.parseRemoteImage(
+                        remoteImage: remoteImage,
+                        traitCollection: traitCollection
+                    )
+                }
 
                 var button: CPBarButton
 
@@ -771,9 +777,30 @@ class Parser {
             )
         }
 
+        if let remoteImage = image?.remoteImage {
+            return Parser.parseRemoteImage(
+                remoteImage: remoteImage,
+                traitCollection: traitCollection
+            )
+        }
+
         return nil
     }
 
+    // MARK: - Remote image cache
+    private static let remoteImageCache: NSCache<NSString, UIImage> = {
+        let cache = NSCache<NSString, UIImage>()
+        cache.countLimit = 50
+        cache.totalCostLimit = 8 * 1024 * 1024  // 8 MB, matching Android's BitmapCache
+        return cache
+    }()
+
+    /// Shared session — long-lived by design; failed tasks don't invalidate it.
+    private static let remoteImageSession = URLSession(configuration: .default)
+
+    /// Default network timeout for remote images when no `timeoutMs` is provided.
+    private static let defaultRemoteTimeoutSeconds: TimeInterval = 0.5
+
     static func parseAssetImage(
         assetImage: AssetImage,
         traitCollection: UITraitCollection
@@ -784,17 +811,77 @@ class Parser {
             "__packager_asset": assetImage.packager_asset,
         ])
 
-        guard let color = assetImage.color else {
-            return uiImage
-        }
+        return applyTint(
+            uiImage: uiImage,
+            color: assetImage.color,
+            traitCollection: traitCollection
+        )
+    }
+
+    static func parseRemoteImage(
+        remoteImage: RemoteImage,
+        traitCollection: UITraitCollection
+    ) -> UIImage? {
+        let timeoutSeconds = remoteImage.timeoutMs.map { $0 / 1000.0 } ?? defaultRemoteTimeoutSeconds
+        let uiImage = loadRemoteImage(uri: remoteImage.uri, timeoutSeconds: timeoutSeconds)
+
+        return applyTint(
+            uiImage: uiImage,
+            color: remoteImage.color,
+            traitCollection: traitCollection
+        )
+    }
+
+    private static func applyTint(
+        uiImage: UIImage?,
+        color: NitroColor?,
+        traitCollection: UITraitCollection
+    ) -> UIImage? {
+        guard let image = uiImage else { return nil }
+        guard let color else { return image }
 
         return getTintedImageAsset(
             color: color,
-            uiImage: uiImage,
+            uiImage: image,
             traitCollection: traitCollection
         )
     }
 
+    /// Synchronously loads an image from a remote HTTPS URL with in-memory caching.
+    /// `parseRemoteImage` is always invoked on a background thread by the Car App rendering pipeline,
+    /// so the semaphore wait cannot block the main thread.
+    private static func loadRemoteImage(uri: String, timeoutSeconds: TimeInterval) -> UIImage? {
+        let cacheKey = uri as NSString
+        if let cached = remoteImageCache.object(forKey: cacheKey) {
+            return cached
+        }
+
+        guard let url = URL(string: uri) else { return nil }
+
+        var request = URLRequest(url: url)
+        request.timeoutInterval = timeoutSeconds
+
+        var resultData: Data?
+        let semaphore = DispatchSemaphore(value: 0)
+        let task = remoteImageSession.dataTask(with: request) { data, _, _ in
+            resultData = data
+            semaphore.signal()
+        }
+        task.resume()
+        if semaphore.wait(timeout: .now() + timeoutSeconds) == .timedOut {
+            task.cancel()
+            return UIImage(systemName: "exclamationmark.circle")
+        }
+
+        guard let data = resultData, let image = UIImage(data: data) else {
+            return UIImage(systemName: "exclamationmark.circle")
+        }
+
+        let cost = Int(image.size.width * image.size.height * image.scale * image.scale * 4)
+        remoteImageCache.setObject(image, forKey: cacheKey, cost: cost)
+        return image
+    }
+
     static func getTintedImageAsset(
         color: NitroColor,
         uiImage: UIImage,

package/ios/utils/VoiceInputManager.swift

@@ -0,0 +1,233 @@
+import AVFoundation
+import CarPlay
+
+/// Captures audio from the car microphone and buffers raw 16 kHz / 16-bit / mono PCM.
+/// Recording stops automatically when silence is detected or the max duration is reached.
+class VoiceInputManager {
+    private var audioEngine: AVAudioEngine?
+    private var voiceControlTemplate: CPVoiceControlTemplate?
+    private var continuation: CheckedContinuation<[Int16], Error>?
+    private var samples: [Int16] = []
+    private var isStopping = false
+    private let stopLock = NSLock()
+
+    // Timing
+    private var recordingStart: Date?
+    private var silenceStart: Date?
+
+    private static let sampleRate: Double = 16_000
+    private static let tapBufferSize: AVAudioFrameCount = 4_096
+    private static let silenceAmplitudeThreshold = 500
+    private static let warmupMs: Double = 500
+
+    private static let targetFormat = AVAudioFormat(
+        commonFormat: .pcmFormatInt16,
+        sampleRate: sampleRate,
+        channels: 1,
+        interleaved: true
+    )!
+
+    // MARK: - Public
+
+    func start(
+        interfaceController: AutoPlayInterfaceController?,
+        silenceThresholdMs: Double,
+        maxDurationMs: Double,
+        listeningText: String
+    ) async throws -> Data {
+        let samples = try await withCheckedThrowingContinuation {
+            (cont: CheckedContinuation<[Int16], Error>) in
+            self.continuation = cont
+            self.samples = []
+            self.isStopping = false
+
+            do {
+                try self.startCapture(
+                    interfaceController: interfaceController,
+                    silenceThresholdMs: silenceThresholdMs,
+                    maxDurationMs: maxDurationMs,
+                    listeningText: listeningText
+                )
+            }
+            catch {
+                self.stopCapture(interfaceController: interfaceController)
+                self.continuation = nil
+                cont.resume(throwing: error)
+            }
+        }
+
+        return samplesAsData(samples)
+    }
+
+    func stop(interfaceController: AutoPlayInterfaceController? = nil) {
+        stopLock.lock()
+        guard !isStopping else {
+            stopLock.unlock()
+            return
+        }
+        isStopping = true
+        let capturedContinuation = continuation
+        let capturedSamples = samples
+        continuation = nil
+        samples = []
+        stopLock.unlock()
+
+        stopCapture(interfaceController: interfaceController)
+        capturedContinuation?.resume(returning: capturedSamples)
+    }
+
+    // MARK: - Private
+
+    private func startCapture(
+        interfaceController: AutoPlayInterfaceController?,
+        silenceThresholdMs: Double,
+        maxDurationMs: Double,
+        listeningText: String
+    ) throws {
+        guard AVAudioSession.sharedInstance().recordPermission == .granted else {
+            throw VoiceInputError.microphonePermissionDenied
+        }
+
+        // Activate the session first so inputNode reports the correct hardware format
+        let session = AVAudioSession.sharedInstance()
+        try session.setCategory(.playAndRecord, mode: .measurement, options: [.mixWithOthers])
+        try session.setActive(true)
+
+        if let interfaceController {
+            presentVoiceTemplate(interfaceController: interfaceController, listeningText: listeningText)
+        }
+
+        let engine = AVAudioEngine()
+        let inputNode = engine.inputNode
+        let nativeFormat = inputNode.outputFormat(forBus: 0)
+
+        let targetFormat = VoiceInputManager.targetFormat
+        guard let converter = AVAudioConverter(from: nativeFormat, to: targetFormat) else {
+            throw VoiceInputError.converterUnavailable
+        }
+
+        recordingStart = Date()
+        silenceStart = nil
+
+        inputNode.installTap(
+            onBus: 0,
+            bufferSize: VoiceInputManager.tapBufferSize,
+            format: nativeFormat
+        ) { [weak self] buffer, _ in
+            guard let self, !self.isStopping else { return }
+
+            let outputFrameCapacity = AVAudioFrameCount(
+                Double(buffer.frameLength)
+                    * VoiceInputManager.sampleRate
+                    / nativeFormat.sampleRate
+            )
+
+            guard
+                let outputBuffer = AVAudioPCMBuffer(
+                    pcmFormat: targetFormat,
+                    frameCapacity: outputFrameCapacity
+                )
+            else { return }
+
+            var conversionError: NSError?
+            let status = converter.convert(to: outputBuffer, error: &conversionError) {
+                _,
+                outStatus in
+                outStatus.pointee = .haveData
+                return buffer
+            }
+
+            guard status != .error, let int16Data = outputBuffer.int16ChannelData else { return }
+
+            let frameCount = Int(outputBuffer.frameLength)
+            let newSamples = Array(UnsafeBufferPointer(start: int16Data[0], count: frameCount))
+            self.samples.append(contentsOf: newSamples)
+
+            let now = Date()
+
+            // Max duration check
+            if let start = self.recordingStart,
+                now.timeIntervalSince(start) * 1000 >= maxDurationMs
+            {
+                self.triggerAutoStop(interfaceController: interfaceController)
+                return
+            }
+
+            // Silence detection — skip during warm-up so the pipeline has time
+            // to stabilise before we start measuring amplitude
+            if let start = self.recordingStart,
+                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)
+                    }
+                }
+                else {
+                    self.silenceStart = nil
+                }
+            }
+        }
+
+        try engine.start()
+        audioEngine = engine
+    }
+
+    private func triggerAutoStop(interfaceController: AutoPlayInterfaceController?) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            self.stop(interfaceController: interfaceController)
+        }
+    }
+
+    private func stopCapture(interfaceController: AutoPlayInterfaceController?) {
+        audioEngine?.inputNode.removeTap(onBus: 0)
+        audioEngine?.stop()
+        audioEngine = nil
+        recordingStart = nil
+        silenceStart = nil
+        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+        if let interfaceController {
+            dismissVoiceTemplate(interfaceController: interfaceController)
+        }
+    }
+
+    private func presentVoiceTemplate(interfaceController: AutoPlayInterfaceController, listeningText: String) {
+        let listeningState = CPVoiceControlState(
+            identifier: "listening",
+            titleVariants: [listeningText],
+            image: nil,
+            repeats: true
+        )
+        let template = CPVoiceControlTemplate(voiceControlStates: [listeningState])
+        initTemplate(template: template, id: "voice-input")
+        voiceControlTemplate = template
+
+        Task { @MainActor in
+            try? await interfaceController.presentTemplate(template, animated: true)
+            template.activateVoiceControlState(withIdentifier: "listening")
+        }
+    }
+
+    private func dismissVoiceTemplate(interfaceController: AutoPlayInterfaceController) {
+        Task { @MainActor in
+            try? await interfaceController.dismissTemplate(animated: true)
+        }
+        voiceControlTemplate = nil
+    }
+
+    private func samplesAsData(_ samples: [Int16]) -> Data {
+        samples.withUnsafeBufferPointer { ptr in
+            Data(buffer: ptr)
+        }
+    }
+}
+
+enum VoiceInputError: Error {
+    case microphonePermissionDenied
+    case converterUnavailable
+    case noActiveSession
+}

package/lib/specs/AutoPlay.nitro.d.ts

@@ -24,12 +24,42 @@ export interface AutoPlay extends HybridObject<{
      */
     addListenerRenderState(moduleName: string, callback: (payload: VisibilityState) => void): CleanupCallback;
     /**
-     * Adds a listener for voice input events. Not implemented on iOS.
+     * Adds a listener for voice input events fired by the OS (Android Auto only).
+     * On iOS this is a no-op — use startVoiceInput instead.
      * @param callback the callback to receive the voice input
      * @returns callback to remove the listener
      * @namespace Android
      */
     addListenerVoiceInput(callback: (coordinates: Location | undefined, query: string | undefined) => void): CleanupCallback;
+    /**
+     * Returns true if microphone permission has already been granted.
+     */
+    hasVoiceInputPermission(): boolean;
+    /**
+     * Request microphone permission from the user.
+     * On Android: uses the car context when Android Auto is connected, otherwise
+     * falls back to the React Native application context.
+     * On iOS: uses AVAudioApplication (iOS 17+) or AVAudioSession (iOS 15–16).
+     * Returns true if permission was granted, false if denied.
+     */
+    requestVoiceInputPermission(): Promise<boolean>;
+    /**
+     * Start an in-app voice recording session.
+     * On Android: acquires audio focus and captures via CarAudioRecord when
+     * Android Auto is connected, otherwise uses standard AudioRecord.
+     * On iOS: presents CPVoiceControlTemplate (when a car is connected) and
+     * captures audio via AVAudioEngine.
+     * Resolves with the complete raw PCM buffer (16 kHz, 16-bit, mono) when
+     * silence is detected, the max duration is reached, or stopVoiceInput() is called.
+     * Rejects if microphone permission has not been granted or recording fails to start.
+     */
+    startVoiceInput(silenceThresholdMs?: number, maxDurationMs?: number, listeningText?: string): Promise<ArrayBuffer>;
+    /**
+     * Stop the active voice recording session early. Causes the Promise returned
+     * by startVoiceInput() to resolve with the audio captured so far.
+     * No-op if no recording is in progress.
+     */
+    stopVoiceInput(): void;
     /**
      * sets the specified template as root template, initializes a new stack
      * Promise might contain an error message in case setting root template failed

package/lib/types/Image.d.ts

@@ -24,4 +24,17 @@ export type AutoImage = {
      */
     color?: ThemedColor | string;
     type: 'asset';
+} | {
+    /** HTTPS URL to a remote image. HTTP is not supported (blocked by App Transport Security). */
+    uri: string;
+    /**
+     * if specified the image gets tinted, if not it will just use the original image
+     */
+    color?: ThemedColor | string;
+    /**
+     * Network timeout in milliseconds before the remote fetch is abandoned and `null` is returned.
+     * Defaults to 500ms when not specified.
+     */
+    timeoutMs?: number;
+    type: 'remote';
 };

package/lib/utils/NitroImage.d.ts

@@ -11,11 +11,16 @@ interface GlyphImage {
     backgroundColor: NitroColor;
     fontScale?: number;
 }
+interface RemoteImage {
+    uri: string;
+    color?: NitroColor;
+    timeoutMs?: number;
+}
 /**
  * we need to map the ButtonImage.name from GlyphName to
  * the actual numeric value so we need a nitro specific type
  */
-export type NitroImage = GlyphImage | AssetImage;
+export type NitroImage = GlyphImage | AssetImage | RemoteImage;
 declare function convert(image: AutoImage): NitroImage;
 declare function convert(image?: AutoImage): NitroImage | undefined;
 export declare const NitroImageUtil: {

package/lib/utils/NitroImage.js

@@ -14,6 +14,13 @@ function convert(image) {
             fontScale,
         };
     }
+    if (image.type === 'remote') {
+        return {
+            uri: image.uri,
+            color: NitroColorUtil.convert(image.color),
+            timeoutMs: image.timeoutMs,
+        };
+    }
     // Image.resolveAssetSource is pretty terrible, it will simply return whatever object you pass it is not a number [require(...)]
     // so the input allows all optional parameters which are returned as is even though
     // the return type claims to not have any optional parameters...

package/nitrogen/generated/android/ReactNativeAutoPlay+autolinking.cmake

@@ -49,7 +49,7 @@ target_sources(
   ../nitrogen/generated/android/c++/JHybridAndroidAutomotiveSpec.cpp
   ../nitrogen/generated/android/c++/JHybridAndroidAutoTelemetrySpec.cpp
   ../nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp
-  ../nitrogen/generated/android/c++/JVariant_GlyphImage_AssetImage.cpp
+  ../nitrogen/generated/android/c++/JVariant_GlyphImage_AssetImage_RemoteImage.cpp
   ../nitrogen/generated/android/c++/JHybridClusterSpec.cpp
   ../nitrogen/generated/android/c++/JNitroImage.cpp
   ../nitrogen/generated/android/c++/JHybridGridTemplateSpec.cpp

package/nitrogen/generated/android/c++/JGridTemplateConfig.hpp

@@ -33,7 +33,8 @@
 #include "JNitroImage.hpp"
 #include "JNitroMapButton.hpp"
 #include "JNitroMapButtonType.hpp"
-#include "JVariant_GlyphImage_AssetImage.hpp"
+#include "JRemoteImage.hpp"
+#include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
 #include "NitroAction.hpp"
 #include "NitroActionType.hpp"
 #include "NitroAlignment.hpp"
@@ -43,6 +44,7 @@
 #include "NitroGridButton.hpp"
 #include "NitroMapButton.hpp"
 #include "NitroMapButtonType.hpp"
+#include "RemoteImage.hpp"
 #include <NitroModules/JNICallable.hpp>
 #include <functional>
 #include <optional>