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

package/README.md

@@ -304,7 +304,49 @@ When using build variants, Android Studio may not be aware of the selected varia
 To work around this and allow for debugging or enhancing the Android Automotive-specific implementation, you can temporarily set the automotive flags in your `gradle.properties` file or your default `.env` file before running a Gradle sync.
 
 ## Icons
-The library is using [Material Symbols](https://fonts.google.com/icons) for iconography. The font is bundled with the library, so no extra setup is required. You can use these icons on both Android Auto and CarPlay.
+The library does **not** bundle any icon font — the consuming app must provide one.
+
+### Setup
+
+1. Add a `.ttf` font file to your native projects:
+   - **iOS** — add `<name>.ttf` to your app bundle (no `UIAppFonts` entry needed — the library registers it via CoreText automatically).
+   - **Android** — place `<name>.ttf` in `res/font/`.
+
+   For cross-platform compatibility use **lowercase names with underscores only** (e.g. `material_symbols`).
+
+2. Register the font and an optional glyph map at startup:
+
+   ```ts
+   import { setIconFont } from '@iternio/react-native-auto-play';
+   import { glyphMap } from './assets/Glyphmap';
+
+   setIconFont('material_symbols', glyphMap);
+   ```
+
+3. Use glyph images by name or code point:
+
+   ```ts
+   { type: 'glyph', name: 'directions_car' }
+   { type: 'glyph', codepoint: 0xe531 }
+   ```
+
+`setIconFont` must be called once before the first glyph is used (subsequent calls are ignored). If no font is registered, the library throws an error when a glyph image is rendered.
+
+### Type-safe glyph names
+
+To get autocompletion and type checking for glyph names, create a declaration file in your app (e.g. `autoplay-glyphs.d.ts`):
+
+```ts
+import type { GlyphName } from './assets/Glyphmap';
+
+declare module '@iternio/react-native-auto-play' {
+  interface AutoPlayGlyphMap extends Record<GlyphName, number> {}
+}
+```
+
+Without this augmentation, `name` accepts any `string`. With it, only keys from your glyph map are allowed and you get full autocompletion.
+
+The example app uses [Material Symbols](https://fonts.google.com/icons). See `apps/example/assets/symbolFont/` for the glyph map generation script.
 
 It is also possible to use custom bundled images (e.g. PNG, WEBP or Vector Drawables). Make sure to add them to your native projects.
 - iOS: Add to your `Images.xcassets`

package/ReactNativeAutoPlay.podspec

@@ -25,10 +25,6 @@ Pod::Spec.new do |s|
   # react helpers like RCTConvert
   s.public_header_files = Array(s.attributes_hash['public_header_files']) + ["ios/ReactHelpers/*.h"]
 
-  s.resource_bundles = {
-    "ReactNativeAutoPlay" => ['ios/Assets/**/*.ttf']
-  }
-  
   s.pod_target_xcconfig = {
     # C++ compiler flags, mainly for folly.
     "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"

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

@@ -598,11 +598,20 @@ object Parser {
         val image = result?.get()
         try {
             if (image is CloseableBitmap) {
-                return image.underlyingBitmap.copy(Bitmap.Config.ARGB_8888, false)
+                // underlyingBitmap can be null when Fresco decodes to a CloseableBitmap
+                // 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)
             } else if (image is CloseableXml) {
                 val drawable = image.buildDrawable()
                 return drawable?.toBitmap(width = image.width, height = image.height, Bitmap.Config.ARGB_8888)
             }
+        } catch (_: Exception) {
+            // Any decode/copy failure (OOM, recycled bitmap, invalid config, …) should
+            // not crash the car app — the image is optional decoration and the caller
+            // handles a null return with CarIcon.ALERT.
+            return null
         } finally {
             image?.close()
             result?.close()

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

@@ -10,39 +10,36 @@ import android.graphics.Typeface
 import androidx.car.app.CarContext
 import androidx.core.content.res.ResourcesCompat
 import androidx.core.graphics.createBitmap
-import androidx.core.graphics.drawable.IconCompat
-import com.margelo.nitro.swe.iternio.reactnativeautoplay.GlyphImage
-import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroImage
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.BuildConfig
-import com.margelo.nitro.swe.iternio.reactnativeautoplay.R
-import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.Parser
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.GlyphImage
 
 object SymbolFont {
-    const val TAG = "SymbolFont"
-
-    private var typeface: Typeface? = null
-
-    private fun loadFont(context: Context) {
-        if (typeface != null) {
-            return
-        }
+    private var cachedFontName: String? = null
+    private var cachedTypeface: Typeface? = null
 
-        typeface = ResourcesCompat.getFont(context, R.font.materialsymbolsoutlined_regular)
+    private fun loadTypeface(context: Context, fontName: String): Typeface? {
+        if (fontName == cachedFontName) return cachedTypeface
+        val id = context.resources.getIdentifier(
+            fontName.lowercase(), "font", context.packageName
+        )
+        if (id == 0) return null
+        val tf = ResourcesCompat.getFont(context, id) ?: return null
+        cachedFontName = fontName
+        cachedTypeface = tf
+        return tf
     }
 
     private fun imageFromGlyph(
         context: Context,
-        glyph: Double,
+        glyphImage: GlyphImage,
         color: Int,
         backgroundColor: Int,
         cornerRadius: Float = 8f, //TODO: make accessible and add it to GlyphImage.cacheKey
-        fontScale: Float,
     ): Bitmap? {
-        loadFont(context)
-
-        val font = typeface ?: run {
-            return null
-        }
+        val font =
+            loadTypeface(context, glyphImage.fontName) ?: run {
+                return null
+            }
 
         val virtualScreenDensity = context.resources.displayMetrics.density
         val scale = BuildConfig.SCALE_FACTOR * virtualScreenDensity
@@ -59,6 +56,8 @@ object SymbolFont {
         }
         canvas.drawRoundRect(rectF, cornerRadius, cornerRadius, paint)
 
+        val fontScale = (glyphImage.fontScale ?: 1.0).toFloat()
+
         // Setup text paint
         paint.reset()
         paint = Paint().apply {
@@ -70,7 +69,7 @@ object SymbolFont {
         }
 
         // Get the character from codepoint
-        val codepoint = glyph.toInt()
+        val codepoint = glyphImage.glyph.toInt()
         val text = String(Character.toChars(codepoint))
 
         // Measure text
@@ -94,13 +93,13 @@ object SymbolFont {
             return bitmap
         }
 
-        bitmap = imageFromGlyph(
-            context = context,
-            glyph = image.glyph,
-            color = image.color.get(context),
-            backgroundColor = image.backgroundColor.get(context),
-            fontScale = (image.fontScale ?: 1.0).toFloat()
-        )
+        bitmap =
+            imageFromGlyph(
+                context = context,
+                glyphImage = image,
+                color = image.color.get(context),
+                backgroundColor = image.backgroundColor.get(context),
+            )
 
         bitmap?.let {
             BitmapCache.put(context, image, it)
@@ -108,4 +107,4 @@ object SymbolFont {
 
         return bitmap
     }
-}
+}

package/ios/utils/SymbolFont.swift

@@ -9,67 +9,65 @@ import CoreText
 import UIKit
 
 class SymbolFont {
-    private static let defaultCanvasSize = 32
+    private static var cachedFontName: String?
+    private static var cachedPSName: String?
 
-    private static var isRegistered = false
-    private static var fontName: String?
-
-    static func loadFont() {
-        let podBundle = Bundle(for: SymbolFont.self)
+    private static func loadFont(named fontName: String) -> String? {
+        if fontName == cachedFontName {
+            return cachedPSName
+        }
 
-        guard
-            let bundleURL = podBundle.url(
-                forResource: "ReactNativeAutoPlay",
-                withExtension: "bundle"
-            ),
-            let resourceBundle = Bundle(url: bundleURL),
-            let fontURL = resourceBundle.url(
-                forResource: "MaterialSymbolsOutlined-Regular",
-                withExtension: "ttf"
-            )
-        else {
-            return
+        guard let url = Bundle.main.url(forResource: fontName, withExtension: "ttf") else {
+            print("[AutoPlay] \(fontName).ttf not found in the app bundle — glyph images will not render.")
+            return nil
         }
 
-        guard let fontData = try? Data(contentsOf: fontURL) as CFData,
+        guard let fontData = try? Data(contentsOf: url) as CFData,
             let provider = CGDataProvider(data: fontData),
             let font = CGFont(provider)
         else {
-            return
+            return nil
         }
 
         var error: Unmanaged<CFError>?
         CTFontManagerRegisterGraphicsFont(font, &error)
-        if let error = error?.takeUnretainedValue() {
-            print("Failed to register font: \(error)")
+        // Ignore already-registered errors (e.g. hot reload)
+
+        guard let psName = font.fullName as? String else {
+            return nil
         }
-        else {
-            print("Font \(font.fullName as String? ?? "unknown") registered")
+
+        cachedFontName = fontName
+        cachedPSName = psName
+        return psName
+    }
+
+    private static func uiFont(for glyphImage: GlyphImage, size: CGFloat, fontScale: CGFloat) -> UIFont? {
+        let pointSize = size * fontScale
+
+        guard let psName = loadFont(named: glyphImage.fontName) else {
+            return nil
         }
 
-        SymbolFont.fontName = font.fullName as? String
-        SymbolFont.isRegistered = true
+        return UIFont(name: psName, size: pointSize)
     }
 
     // creates a single color UIImage
     static func imageFromGlyph(
-        glyph: Double,
+        glyphImage: GlyphImage,
         foregroundColor: UIColor,
         backgroundColor: UIColor,
         size: CGFloat,
         fontScale: CGFloat
     ) -> UIImage? {
-        if !SymbolFont.isRegistered {
-            SymbolFont.loadFont()
+        guard let font = uiFont(for: glyphImage, size: size, fontScale: fontScale) else {
+            return nil
         }
 
-        guard let fontName = SymbolFont.fontName,
-            let font = UIFont(name: fontName, size: size * fontScale)
-        else {
+        guard let scalar = UnicodeScalar(UInt32(glyphImage.glyph)) else {
             return nil
         }
-
-        let codepoint = String(UnicodeScalar(UInt32(glyph))!)
+        let codepoint = String(Character(scalar))
         let canvasSize = CGSize(width: size, height: size)
         let rect = CGRect(origin: .zero, size: canvasSize)
 
@@ -99,14 +97,14 @@ class SymbolFont {
         let y = (canvasSize.height - textSize.height) / 2
         attrString.draw(at: CGPoint(x: x, y: y))
 
-        let image = UIGraphicsGetImageFromCurrentImageContext()
+        let uiImage = UIGraphicsGetImageFromCurrentImageContext()
         UIGraphicsEndImageContext()
 
-        return image
+        return uiImage
     }
 
     static func imageFromGlyph(
-        glyph: Double,
+        glyphImage: GlyphImage,
         size: CGFloat,
         foregroundColor: NitroColor,
         backgroundColor: NitroColor,
@@ -115,7 +113,7 @@ class SymbolFont {
     ) -> UIImage? {
         guard
             let lightImage = imageFromGlyph(
-                glyph: glyph,
+                glyphImage: glyphImage,
                 foregroundColor: Parser.doubleToColor(
                     value: foregroundColor.lightColor
                 ),
@@ -126,7 +124,7 @@ class SymbolFont {
                 fontScale: fontScale
             ),
             let darkImage = imageFromGlyph(
-                glyph: glyph,
+                glyphImage: glyphImage,
                 foregroundColor: Parser.doubleToColor(
                     value: foregroundColor.darkColor
                 ),
@@ -167,6 +165,8 @@ class SymbolFont {
     ) -> UIImage? {
         guard let image else { return nil }
 
+        let fontScale = image.fontScale ?? 1.0
+
         if noImageAsset {
             let foregroundColor = Parser.doubleToColor(
                 value: traitCollection.userInterfaceStyle == .light
@@ -180,21 +180,21 @@ class SymbolFont {
             )
 
             return SymbolFont.imageFromGlyph(
-                glyph: image.glyph,
+                glyphImage: image,
                 foregroundColor: foregroundColor,
                 backgroundColor: backgroundColor,
                 size: size,
-                fontScale: image.fontScale ?? 1.0
+                fontScale: fontScale
             )
         }
 
         return SymbolFont.imageFromGlyph(
-            glyph: image.glyph,
+            glyphImage: image,
             size: size,
             foregroundColor: image.color,
             backgroundColor: image.backgroundColor,
-            fontScale: image.fontScale ?? 1.0,
+            fontScale: fontScale,
             traitCollection: traitCollection
-        )!
+        )
     }
 }

package/ios/utils/VoiceInputManager.swift

@@ -90,7 +90,7 @@ class VoiceInputManager {
 
         // 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.setCategory(.playAndRecord, mode: .measurement, options: [])
         try session.setActive(true)
 
         if let interfaceController {

package/lib/index.d.ts

@@ -43,3 +43,4 @@ export * from './types/Trip';
 export type { AlertPriority, NavigationAlert as Alert, NavigationAlertAction as AlertAction, } from './utils/NitroAlert';
 export type { ThemedColor } from './utils/NitroColor';
 export type { GridButton } from './utils/NitroGrid';
+export { setIconFont } from './utils/NitroImage';

package/lib/index.js

@@ -45,3 +45,4 @@ export * from './types/SignInMethod';
 export * from './types/Telemetry';
 export * from './types/Text';
 export * from './types/Trip';
+export { setIconFont } from './utils/NitroImage';

package/lib/types/Image.d.ts

@@ -1,8 +1,22 @@
 import type { ImageSourcePropType } from 'react-native';
 import type { ThemedColor } from '../utils/NitroColor';
-import type { GlyphName } from './Glyphmap';
-export type AutoImage = {
-    name: GlyphName;
+/**
+ * Augment this interface in your app to get type-safe glyph name autocompletion.
+ *
+ * @example
+ * ```ts
+ * // autoplay-glyphs.d.ts
+ * import type { GlyphName } from './assets/symbolFont/Glyphmap';
+ * declare module '@iternio/react-native-auto-play' {
+ *   interface AutoPlayGlyphMap extends Record<GlyphName, number> {}
+ * }
+ * ```
+ */
+export interface AutoPlayGlyphMap {
+}
+/** Resolves to the augmented glyph name union, or falls back to `string` when not augmented. */
+export type GlyphMapKey = keyof AutoPlayGlyphMap extends never ? string : Extract<keyof AutoPlayGlyphMap, string>;
+type GlyphStyleFields = {
     /**
      * Sets the icon dark and light mode color or a single color for both.
      * Defaults to white for dark mode and black for light mode if not specified.
@@ -15,8 +29,22 @@ export type AutoImage = {
      */
     backgroundColor?: ThemedColor | string;
     fontScale?: number;
+};
+/** Glyph by name — looked up in the glyph map registered via {@link setIconFont}. */
+export type AutoGlyphByName = GlyphStyleFields & {
     type: 'glyph';
-} | {
+    /** Key in the glyph map passed to `setIconFont`. */
+    name: GlyphMapKey;
+    /** Optional override — if set, used instead of the map lookup. */
+    codepoint?: number;
+};
+/** Glyph by raw Unicode code point. */
+export type AutoGlyphByCodepoint = GlyphStyleFields & {
+    type: 'glyph';
+    codepoint: number;
+};
+export type AutoGlyph = AutoGlyphByName | AutoGlyphByCodepoint;
+export type AutoImage = AutoGlyph | {
     image: ImageSourcePropType;
     /**
      * if specified the image gets tinted, if not it will just use the original image
@@ -38,3 +66,4 @@ export type AutoImage = {
     timeoutMs?: number;
     type: 'remote';
 };
+export {};

package/lib/types/Maneuver.d.ts

@@ -1,6 +1,6 @@
 import type { ImageSourcePropType } from 'react-native';
 import type { ThemedColor } from '../utils/NitroColor';
-import type { GlyphName } from './Glyphmap';
+import type { AutoGlyphByCodepoint, AutoGlyphByName } from './Image';
 import type { TravelEstimates } from './Trip';
 export declare enum ManeuverType {
     Depart = 0,
@@ -148,15 +148,7 @@ export interface PreferredLane extends Lane {
     highlightedAngle: number;
     isPreferred: boolean;
 }
-export type ManeuverImage = {
-    name: GlyphName;
-    /**
-     * make sure to specify a color with a proper contrast ratio to cardBackgroundColor otherwise it might not get applied
-     * defaults to white/black for dark/light mode
-     */
-    color?: ThemedColor | string;
-    type: 'glyph';
-} | {
+export type ManeuverImage = Pick<AutoGlyphByName, 'type' | 'name' | 'codepoint' | 'color'> | Pick<AutoGlyphByCodepoint, 'type' | 'codepoint' | 'color'> | {
     image: ImageSourcePropType;
     /**
      * if specified the image gets tinted, if not it will just use the original image

package/lib/utils/NitroImage.d.ts

@@ -1,12 +1,34 @@
 import { type ImageResolvedAssetSource } from 'react-native';
 import type { AutoImage } from '../types/Image';
 import { type NitroColor } from './NitroColor';
+/**
+ * Register the icon font and (optionally) a glyph map for name-based lookups.
+ * Must be called **once** before creating any templates. Subsequent calls are ignored.
+ *
+ * The font name maps directly to a native font asset:
+ * - **Android** — `res/font/<name>.ttf` (must be lowercase)
+ * - **iOS** — `<name>.ttf` in the app bundle (registered via CoreText automatically)
+ *
+ * For cross-platform compatibility use lowercase with underscores only.
+ *
+ * @param name  Native font asset name (without extension).
+ * @param glyphMap  Optional map of glyph names to Unicode code points.
+ *                  When provided, glyphs can use `{ type: 'glyph', name: 'icon_name' }`.
+ *
+ * @example
+ * ```ts
+ * import { glyphMap } from './assets/Glyphmap';
+ * setIconFont('material_symbols', glyphMap);
+ * ```
+ */
+export declare function setIconFont(name: string, glyphMap?: Record<string, number>): void;
 interface AssetImage extends ImageResolvedAssetSource {
     color?: NitroColor;
     packager_asset: boolean;
 }
 interface GlyphImage {
     glyph: number;
+    fontName: string;
     color: NitroColor;
     backgroundColor: NitroColor;
     fontScale?: number;
@@ -17,8 +39,7 @@ interface RemoteImage {
     timeoutMs?: number;
 }
 /**
- * we need to map the ButtonImage.name from GlyphName to
- * the actual numeric value so we need a nitro specific type
+ * NitroModules-compatible image types passed to native.
  */
 export type NitroImage = GlyphImage | AssetImage | RemoteImage;
 declare function convert(image: AutoImage): NitroImage;

package/lib/utils/NitroImage.js

@@ -1,14 +1,68 @@
 import { Image } from 'react-native';
-import { glyphMap } from '../types/Glyphmap';
 import { NitroColorUtil } from './NitroColor';
+let _iconFont;
+let _glyphMap;
+/**
+ * Register the icon font and (optionally) a glyph map for name-based lookups.
+ * Must be called **once** before creating any templates. Subsequent calls are ignored.
+ *
+ * The font name maps directly to a native font asset:
+ * - **Android** — `res/font/<name>.ttf` (must be lowercase)
+ * - **iOS** — `<name>.ttf` in the app bundle (registered via CoreText automatically)
+ *
+ * For cross-platform compatibility use lowercase with underscores only.
+ *
+ * @param name  Native font asset name (without extension).
+ * @param glyphMap  Optional map of glyph names to Unicode code points.
+ *                  When provided, glyphs can use `{ type: 'glyph', name: 'icon_name' }`.
+ *
+ * @example
+ * ```ts
+ * import { glyphMap } from './assets/Glyphmap';
+ * setIconFont('material_symbols', glyphMap);
+ * ```
+ */
+export function setIconFont(name, glyphMap) {
+    if (_iconFont != null) {
+        return;
+    }
+    _iconFont = name;
+    _glyphMap = glyphMap;
+}
+function getIconFont() {
+    if (_iconFont == null) {
+        throw new Error('No icon font configured. Call setIconFont("your_font_name") before using glyph images.');
+    }
+    return _iconFont;
+}
+function resolveGlyph(image) {
+    if ('name' in image && image.name !== undefined) {
+        if (image.codepoint !== undefined) {
+            return image.codepoint;
+        }
+        if (_glyphMap == null) {
+            throw new Error(`Glyph name "${image.name}" used but no glyph map was provided to setIconFont().`);
+        }
+        const cp = _glyphMap[image.name];
+        if (cp === undefined) {
+            throw new Error(`Glyph name "${image.name}" not found in the glyph map.`);
+        }
+        return cp;
+    }
+    if (image.codepoint !== undefined) {
+        return image.codepoint;
+    }
+    throw new Error('Glyph image must provide either `name` or `codepoint`.');
+}
 function convert(image) {
     if (image == null) {
         return undefined;
     }
     if (image.type === 'glyph') {
-        const { color = { darkColor: 'white', lightColor: 'black' }, fontScale, name, backgroundColor = 'transparent', } = image;
+        const { color = { darkColor: 'white', lightColor: 'black' }, fontScale, backgroundColor = 'transparent', } = image;
         return {
-            glyph: glyphMap[name],
+            glyph: resolveGlyph(image),
+            fontName: getIconFont(),
             color: NitroColorUtil.convert(color),
             backgroundColor: NitroColorUtil.convert(backgroundColor),
             fontScale,

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

@@ -13,6 +13,7 @@
 #include "JNitroColor.hpp"
 #include "NitroColor.hpp"
 #include <optional>
+#include <string>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -35,6 +36,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       static const auto clazz = javaClassStatic();
       static const auto fieldGlyph = clazz->getField<double>("glyph");
       double glyph = this->getFieldValue(fieldGlyph);
+      static const auto fieldFontName = clazz->getField<jni::JString>("fontName");
+      jni::local_ref<jni::JString> fontName = this->getFieldValue(fieldFontName);
       static const auto fieldColor = clazz->getField<JNitroColor>("color");
       jni::local_ref<JNitroColor> color = this->getFieldValue(fieldColor);
       static const auto fieldBackgroundColor = clazz->getField<JNitroColor>("backgroundColor");
@@ -43,6 +46,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       jni::local_ref<jni::JDouble> fontScale = this->getFieldValue(fieldFontScale);
       return GlyphImage(
         glyph,
+        fontName->toStdString(),
         color->toCpp(),
         backgroundColor->toCpp(),
         fontScale != nullptr ? std::make_optional(fontScale->value()) : std::nullopt
@@ -55,12 +59,13 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
      */
     [[maybe_unused]]
     static jni::local_ref<JGlyphImage::javaobject> fromCpp(const GlyphImage& value) {
-      using JSignature = JGlyphImage(double, jni::alias_ref<JNitroColor>, jni::alias_ref<JNitroColor>, jni::alias_ref<jni::JDouble>);
+      using JSignature = JGlyphImage(double, jni::alias_ref<jni::JString>, jni::alias_ref<JNitroColor>, jni::alias_ref<JNitroColor>, jni::alias_ref<jni::JDouble>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         value.glyph,
+        jni::make_jstring(value.fontName),
         JNitroColor::fromCpp(value.color),
         JNitroColor::fromCpp(value.backgroundColor),
         value.fontScale.has_value() ? jni::JDouble::valueOf(value.fontScale.value()) : nullptr

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

@@ -15,11 +15,11 @@
 #include "RemoteImage.hpp"
 #include <variant>
 #include "JGlyphImage.hpp"
+#include <string>
 #include "NitroColor.hpp"
 #include "JNitroColor.hpp"
 #include <optional>
 #include "JAssetImage.hpp"
-#include <string>
 #include "JRemoteImage.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {

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

@@ -15,11 +15,11 @@
 #include "RemoteImage.hpp"
 #include <variant>
 #include "JGlyphImage.hpp"
+#include <string>
 #include "NitroColor.hpp"
 #include "JNitroColor.hpp"
 #include <optional>
 #include "JAssetImage.hpp"
-#include <string>
 #include "JRemoteImage.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {

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

@@ -19,11 +19,11 @@
 #include "RemoteImage.hpp"
 #include "JNitroImage.hpp"
 #include "JGlyphImage.hpp"
+#include <string>
 #include "NitroColor.hpp"
 #include "JNitroColor.hpp"
 #include <optional>
 #include "JAssetImage.hpp"
-#include <string>
 #include "JRemoteImage.hpp"
 #include <vector>
 #include "JImageLane.hpp"