@iternio/react-native-auto-play 0.0.1

package/lib/utils/NitroAlert.d.ts

@@ -0,0 +1,43 @@
+import type { AutoImage } from '../types/Image';
+import type { AutoText } from '../types/Text';
+import { type NitroImage } from './NitroImage';
+export type AlertActionStyle = 'default' | 'destructive' | 'cancel';
+type AlertDismissalReason = 'timeout' | 'user' | 'system';
+export type NavigationAlertAction = {
+    title: string;
+    style?: AlertActionStyle;
+    onPress: () => void;
+};
+export type AlertPriority = 'low' | 'medium' | 'high';
+export type NavigationAlert = {
+    id: number;
+    title: AutoText;
+    subtitle?: AutoText;
+    image?: AutoImage;
+    primaryAction: NavigationAlertAction;
+    secondaryAction?: NavigationAlertAction;
+    durationMs: number;
+    onWillShow?: () => void;
+    onDidDismiss?: (reason: AlertDismissalReason) => void;
+    /**
+     * The priority of the alert. When an alert with a higher priority is visible, and a lower priority alert is sent, the lower priority alert will not be shown.
+     * However if a higher priority alert is sent and a lower priority alert is visible, the lower priority alert will be replaced by the higher priority alert.
+     */
+    priority: AlertPriority;
+};
+export type NitroNavigationAlert = {
+    id: number;
+    title: AutoText;
+    subtitle?: AutoText;
+    image?: NitroImage;
+    primaryAction: NavigationAlertAction;
+    secondaryAction?: NavigationAlertAction;
+    durationMs: number;
+    onWillShow?: () => void;
+    onDidDismiss?: (reason: AlertDismissalReason) => void;
+    priority: number;
+};
+export declare const NitroAlertUtil: {
+    convert: (alert: NavigationAlert) => NitroNavigationAlert;
+};
+export {};

package/lib/utils/NitroAlert.js

@@ -0,0 +1,16 @@
+import { NitroImageUtil } from './NitroImage';
+var AlertPriorityEnum;
+(function (AlertPriorityEnum) {
+    AlertPriorityEnum[AlertPriorityEnum["low"] = 0] = "low";
+    AlertPriorityEnum[AlertPriorityEnum["medium"] = 1] = "medium";
+    AlertPriorityEnum[AlertPriorityEnum["high"] = 2] = "high";
+})(AlertPriorityEnum || (AlertPriorityEnum = {}));
+const convert = (alert) => {
+    const { image, priority, ...rest } = alert;
+    return {
+        ...rest,
+        image: NitroImageUtil.convert(image),
+        priority: AlertPriorityEnum[priority],
+    };
+};
+export const NitroAlertUtil = { convert };

package/lib/utils/NitroAttributedString.d.ts

@@ -0,0 +1,22 @@
+import type { AutoImage } from '../types/Image';
+import { type NitroImage } from './NitroImage';
+type NitroAttributedStringImage = {
+    image: NitroImage;
+    position: number;
+};
+export type NitroAttributedString = {
+    text: string;
+    images?: Array<NitroAttributedStringImage>;
+};
+export type AutoAttributedString = {
+    text: string;
+    images?: Array<{
+        image: AutoImage;
+        position: number;
+    }>;
+};
+declare function convert(attributedStrings: Array<AutoAttributedString>): Array<NitroAttributedString>;
+export declare const NitroAttributedStringUtil: {
+    convert: typeof convert;
+};
+export {};

package/lib/utils/NitroAttributedString.js

@@ -0,0 +1,11 @@
+import { NitroImageUtil } from './NitroImage';
+function convert(attributedStrings) {
+    return attributedStrings.map((attributedString) => ({
+        ...attributedString,
+        images: attributedString.images?.map((image) => ({
+            ...image,
+            image: NitroImageUtil.convert(image.image),
+        })),
+    }));
+}
+export const NitroAttributedStringUtil = { convert };

package/lib/utils/NitroColor.d.ts

@@ -0,0 +1,14 @@
+export type NitroColor = {
+    lightColor: number;
+    darkColor: number;
+};
+export type ThemedColor = {
+    lightColor: string;
+    darkColor: string;
+};
+declare function convert(color: ThemedColor | string): NitroColor;
+declare function convert(color?: ThemedColor | string): NitroColor | undefined;
+export declare const NitroColorUtil: {
+    convert: typeof convert;
+};
+export {};

package/lib/utils/NitroColor.js

@@ -0,0 +1,21 @@
+import { processColor } from 'react-native';
+function convertColor(color) {
+    // since we accept only string it can return a number only
+    return processColor(color);
+}
+function convert(color) {
+    if (color == null) {
+        return undefined;
+    }
+    if (typeof color === 'string') {
+        const convertedColor = convertColor(color);
+        return { darkColor: convertedColor, lightColor: convertedColor };
+    }
+    const darkColor = convertColor(color.darkColor);
+    const lightColor = convertColor(color.lightColor);
+    return {
+        darkColor,
+        lightColor,
+    };
+}
+export const NitroColorUtil = { convert };

package/lib/utils/NitroGrid.d.ts

@@ -0,0 +1,16 @@
+import type { AutoImage } from '../types/Image';
+import type { AutoText } from '../types/Text';
+import { type NitroImage } from './NitroImage';
+export type GridButton<T> = {
+    title: AutoText;
+    image: AutoImage;
+    onPress: (template: T) => void;
+};
+export type NitroGridButton = {
+    title: AutoText;
+    image: NitroImage;
+    onPress: () => void;
+};
+export declare const NitroGridUtil: {
+    convert: <T>(template: T, buttons: Array<GridButton<T>>) => NitroGridButton[];
+};

package/lib/utils/NitroGrid.js

@@ -0,0 +1,9 @@
+import { NitroImageUtil } from './NitroImage';
+const convert = (template, buttons) => {
+    return buttons.map((button) => ({
+        title: button.title,
+        image: NitroImageUtil.convert(button.image),
+        onPress: () => button.onPress(template),
+    }));
+};
+export const NitroGridUtil = { convert };

package/lib/utils/NitroImage.d.ts

@@ -0,0 +1,24 @@
+import { type ImageResolvedAssetSource } from 'react-native';
+import type { AutoImage } from '../types/Image';
+import { type NitroColor } from './NitroColor';
+interface AssetImage extends ImageResolvedAssetSource {
+    color?: NitroColor;
+    packager_asset: boolean;
+}
+interface GlyphImage {
+    glyph: number;
+    color: NitroColor;
+    backgroundColor: NitroColor;
+    fontScale?: 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;
+declare function convert(image: AutoImage): NitroImage;
+declare function convert(image?: AutoImage): NitroImage | undefined;
+export declare const NitroImageUtil: {
+    convert: typeof convert;
+};
+export {};

package/lib/utils/NitroImage.js

@@ -0,0 +1,32 @@
+import { Image } from 'react-native';
+import { glyphMap } from '../types/Glyphmap';
+import { NitroColorUtil } from './NitroColor';
+function convert(image) {
+    if (image == null) {
+        return undefined;
+    }
+    if (image.type === 'glyph') {
+        const { color = { darkColor: 'white', lightColor: 'black' }, fontScale, name, backgroundColor = 'transparent', } = image;
+        return {
+            glyph: glyphMap[name],
+            color: NitroColorUtil.convert(color),
+            backgroundColor: NitroColorUtil.convert(backgroundColor),
+            fontScale,
+        };
+    }
+    // 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...
+    // we specify some default values to not crash because of proper typing required by nitro-modules
+    const { height = 0, scale = 0, uri, width = 0, ...rest } = Image.resolveAssetSource(image.image);
+    const assetImage = {
+        height,
+        scale,
+        uri,
+        width,
+        packager_asset: '__packager_asset' in rest ? Boolean(rest.__packager_asset) : false,
+        color: NitroColorUtil.convert(image.color),
+    };
+    return assetImage;
+}
+export const NitroImageUtil = { convert };

package/lib/utils/NitroManeuver.d.ts

@@ -0,0 +1,42 @@
+import { type BaseManeuver, type ForkType, type KeepType, type Lane, type MessageManeuver, type OffRampType, type OnRampType, type PreferredLane, type RoutingManeuver, type TurnType } from '../types/Maneuver';
+import type { NitroAttributedString } from './NitroAttributedString';
+import { type NitroColor } from './NitroColor';
+import { type NitroImage } from './NitroImage';
+interface PreferredImageLane extends PreferredLane {
+    image: NitroImage;
+}
+interface ImageLane extends Lane {
+    image: NitroImage;
+}
+export interface LaneGuidance {
+    instructionVariants: Array<string>;
+    lanes: Array<PreferredImageLane | ImageLane>;
+}
+export interface NitroRoutingManeuver extends BaseManeuver {
+    attributedInstructionVariants: Array<NitroAttributedString>;
+    symbolImage: NitroImage;
+    junctionImage?: NitroImage;
+    turnType?: TurnType;
+    angle?: number;
+    elementAngles?: Array<number>;
+    exitNumber?: number;
+    offRampType?: OffRampType;
+    onRampType?: OnRampType;
+    forkType?: ForkType;
+    keepType?: KeepType;
+    linkedLaneGuidance?: LaneGuidance;
+    cardBackgroundColor: NitroColor;
+}
+export interface NitroMessageManeuver {
+    title: string;
+    text?: string;
+    image?: NitroImage;
+    cardBackgroundColor: NitroColor;
+}
+export type NitroManeuver = Array<NitroRoutingManeuver> | NitroMessageManeuver;
+declare function convert(autoManeuver: MessageManeuver): NitroMessageManeuver;
+declare function convert(autoManeuver: RoutingManeuver): NitroRoutingManeuver;
+export declare const NitroManeuverUtil: {
+    convert: typeof convert;
+};
+export {};

package/lib/utils/NitroManeuver.js

@@ -0,0 +1,78 @@
+import { ManeuverType, } from '../types/Maneuver';
+import { NitroColorUtil } from './NitroColor';
+import { NitroImageUtil } from './NitroImage';
+function convertManeuverImage(image) {
+    if (image == null) {
+        return undefined;
+    }
+    if (image.type === 'glyph') {
+        const color = typeof image.color === 'string'
+            ? image.color
+            : (image.color ?? { darkColor: 'white', lightColor: 'black' });
+        return NitroImageUtil.convert({
+            ...image,
+            color: color,
+        });
+    }
+    return NitroImageUtil.convert(image);
+}
+function convert(autoManeuver) {
+    if (autoManeuver.type === 'message') {
+        const { title, image, text } = autoManeuver;
+        return {
+            title,
+            text,
+            image: convertManeuverImage(image),
+            cardBackgroundColor: NitroColorUtil.convert(autoManeuver.cardBackgroundColor),
+        };
+    }
+    const { symbolImage, junctionImage, attributedInstructionVariants, id, maneuverType, trafficSide, travelEstimates, highwayExitLabel, linkedLaneGuidance, roadName, cardBackgroundColor, } = autoManeuver;
+    const elementAngles = maneuverType === ManeuverType.Turn || maneuverType === ManeuverType.Roundabout
+        ? autoManeuver.elementAngles
+        : undefined;
+    const angle = maneuverType === ManeuverType.Turn || maneuverType === ManeuverType.Roundabout
+        ? autoManeuver.angle
+        : undefined;
+    const turnType = maneuverType === ManeuverType.Turn ? autoManeuver.turnType : undefined;
+    const exitNumber = maneuverType === ManeuverType.Roundabout ? autoManeuver.exitNumber : undefined;
+    const offRampType = maneuverType === ManeuverType.OffRamp ? autoManeuver.offRampType : undefined;
+    const onRampType = maneuverType === ManeuverType.OnRamp ? autoManeuver.onRampType : undefined;
+    const forkType = maneuverType === ManeuverType.Fork ? autoManeuver.forkType : undefined;
+    const keepType = maneuverType === ManeuverType.Keep ? autoManeuver.keepType : undefined;
+    return {
+        id,
+        maneuverType,
+        trafficSide,
+        travelEstimates,
+        linkedLaneGuidance: linkedLaneGuidance
+            ? {
+                ...linkedLaneGuidance,
+                lanes: linkedLaneGuidance.lanes.map((lane) => ({
+                    ...lane,
+                    image: convertManeuverImage(lane.image),
+                })),
+            }
+            : undefined,
+        highwayExitLabel,
+        roadName,
+        attributedInstructionVariants: attributedInstructionVariants.map((variant) => ({
+            text: variant.text,
+            images: variant.images?.map(({ image, position }) => ({
+                image: convertManeuverImage(image),
+                position,
+            })),
+        })),
+        junctionImage: convertManeuverImage(junctionImage),
+        symbolImage: convertManeuverImage(symbolImage),
+        elementAngles,
+        angle,
+        turnType,
+        exitNumber,
+        offRampType,
+        onRampType,
+        forkType,
+        keepType,
+        cardBackgroundColor: NitroColorUtil.convert(cardBackgroundColor),
+    };
+}
+export const NitroManeuverUtil = { convert };

package/lib/utils/NitroMapButton.d.ts

@@ -0,0 +1,12 @@
+import type { MapButtons } from '../templates/MapTemplate';
+import { type NitroImage } from './NitroImage';
+type NitroMapButtonType = 'pan' | 'custom';
+export type NitroMapButton = {
+    type: NitroMapButtonType;
+    image?: NitroImage;
+    onPress: () => void;
+};
+export declare const NitroMapButton: {
+    convert: <T>(template: T, mapButtons?: MapButtons<T>) => Array<NitroMapButton> | undefined;
+};
+export {};

package/lib/utils/NitroMapButton.js

@@ -0,0 +1,35 @@
+import { Platform } from 'react-native';
+import { NitroImageUtil } from './NitroImage';
+const convert = (template, mapButtons) => {
+    if (mapButtons == null) {
+        return undefined;
+    }
+    return mapButtons?.map((button) => {
+        const { onPress, type } = button;
+        if (button.type === 'pan') {
+            if (Platform.OS === 'android') {
+                return { type: 'pan', onPress: () => onPress(template) };
+            }
+            throw new Error('unsupported platform, pan button can be used on Android only! Use a custom button instead.');
+        }
+        if (button.image.type === 'glyph') {
+            const backgroundColor = Platform.OS === 'android'
+                ? 'transparent'
+                : 'backgroundColor' in button.image
+                    ? button.image.backgroundColor
+                    : 'transparent';
+            const fontScale = (button.image.fontScale ?? Platform.OS === 'android') ? 1.0 : 0.65;
+            return {
+                type,
+                onPress: () => onPress(template),
+                image: NitroImageUtil.convert({ ...button.image, backgroundColor, fontScale }),
+            };
+        }
+        return {
+            type,
+            onPress: () => onPress(template),
+            image: NitroImageUtil.convert(button.image),
+        };
+    });
+};
+export const NitroMapButton = { convert };

package/lib/utils/NitroSection.d.ts

@@ -0,0 +1,23 @@
+import type { Section } from '../templates/ListTemplate';
+import type { AutoText } from '../types/Text';
+import { type NitroImage } from './NitroImage';
+type NitroSectionType = 'default' | 'radio';
+export type NitroRow = {
+    title: AutoText;
+    detailedText?: AutoText;
+    browsable?: boolean;
+    enabled: boolean;
+    image?: NitroImage;
+    checked?: boolean;
+    onPress?: (checked?: boolean) => void;
+    selected?: boolean;
+};
+export type NitroSection = {
+    title?: string;
+    items: Array<NitroRow>;
+    type: NitroSectionType;
+};
+export declare const NitroSectionUtil: {
+    convert: <T>(template: T, sections?: Section<T>) => Array<NitroSection> | undefined;
+};
+export {};

package/lib/utils/NitroSection.js

@@ -0,0 +1,62 @@
+import { NitroImageUtil } from './NitroImage';
+const validateRadioItems = (type, items) => {
+    if (__DEV__ &&
+        type === 'radio' &&
+        (items.filter((item) => item.selected).length > 1 || items.every((item) => !item.selected))) {
+        throw new Error('radio lists must have one selected item');
+    }
+};
+const convert = (template, sections) => {
+    if (sections == null) {
+        return undefined;
+    }
+    if (Array.isArray(sections)) {
+        return sections.map((section) => {
+            const { title, type } = section;
+            const items = section.items.map((item) => convertRow(template, item));
+            validateRadioItems(type, items);
+            return {
+                items,
+                type,
+                title,
+            };
+        });
+    }
+    const items = sections.items.map((item) => convertRow(template, item));
+    validateRadioItems(sections.type, items);
+    return [
+        {
+            items,
+            type: sections.type,
+        },
+    ];
+};
+const convertRow = (template, item) => {
+    const { title, type, enabled = true, image } = item;
+    const detailedText = 'detailedText' in item ? item.detailedText : undefined;
+    const selected = type === 'radio' ? (item.selected ?? false) : undefined;
+    const onTogglePress = item.type === 'toggle' ? item.onPress : undefined;
+    const onRowPress = item.type !== 'text' && item.type !== 'toggle' ? item.onPress : undefined;
+    const onPress = item.type === 'text'
+        ? undefined
+        : (checked) => {
+            if (onTogglePress != null && checked != null) {
+                onTogglePress(template, checked);
+                return;
+            }
+            if (onRowPress != null) {
+                onRowPress(template);
+            }
+        };
+    return {
+        browsable: type === 'default' ? item.browsable : undefined,
+        detailedText,
+        enabled,
+        image: NitroImageUtil.convert(image),
+        title,
+        checked: type === 'toggle' ? item.checked : undefined,
+        onPress,
+        selected,
+    };
+};
+export const NitroSectionUtil = { convert };

package/nitro.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": ["swe", "iternio", "reactnativeautoplay"],
+  "ios": {
+    "iosModuleName": "ReactNativeAutoPlay"
+  },
+  "android": {
+    "androidNamespace": ["swe", "iternio", "reactnativeautoplay"],
+    "androidCxxLibName": "ReactNativeAutoPlay"
+  },
+  "autolinking": {
+    "AutoPlay": {
+      "kotlin": "HybridAutoPlay",
+      "swift": "HybridAutoPlay"
+    },
+    "AndroidAutoTelemetry": {
+      "kotlin": "HybridAndroidAutoTelemetry"
+    },
+    "ListTemplate": {
+      "kotlin": "HybridListTemplate",
+      "swift": "HybridListTemplate"
+    },
+    "InformationTemplate": {
+      "kotlin": "HybridInformationTemplate",
+      "swift": "HybridInformationTemplate"
+    },
+    "GridTemplate": {
+      "kotlin": "HybridGridTemplate",
+      "swift": "HybridGridTemplate"
+    },
+    "MapTemplate": {
+      "kotlin": "HybridMapTemplate",
+      "swift": "HybridMapTemplate"
+    },
+    "MessageTemplate": {
+      "kotlin": "HybridMessageTemplate",
+      "swift": "HybridMessageTemplate"
+    },
+    "SearchTemplate": {
+      "kotlin": "HybridSearchTemplate",
+      "swift": "HybridSearchTemplate"
+    },
+    "CarPlayDashboard": {
+      "swift": "HybridCarPlayDashboard"
+    },
+    "Cluster": {
+      "kotlin": "HybridCluster",
+      "swift": "HybridCluster"
+    }
+  },
+  "ignorePaths": ["**/node_modules"]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

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

@@ -0,0 +1,102 @@
+#
+# ReactNativeAutoPlay+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © 2025 Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/ReactNativeAutoPlay+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_REACTNATIVEAUTOPLAY_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  ReactNativeAutoPlay PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridAndroidAutoTelemetrySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridAutoPlaySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCarPlayDashboardSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridClusterSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridGridTemplateSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridInformationTemplateSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridListTemplateSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMapTemplateSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMessageTemplateSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSearchTemplateSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridAndroidAutoTelemetrySpec.cpp
+  ../nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp
+  ../nitrogen/generated/android/c++/JVariant_GlyphImage_AssetImage.cpp
+  ../nitrogen/generated/android/c++/JHybridClusterSpec.cpp
+  ../nitrogen/generated/android/c++/JNitroImage.cpp
+  ../nitrogen/generated/android/c++/JHybridGridTemplateSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridInformationTemplateSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridListTemplateSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridMapTemplateSpec.cpp
+  ../nitrogen/generated/android/c++/JNitroManeuver.cpp
+  ../nitrogen/generated/android/c++/JVariant_PreferredImageLane_ImageLane.cpp
+  ../nitrogen/generated/android/c++/JHybridMessageTemplateSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridSearchTemplateSpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  ReactNativeAutoPlay PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        ReactNativeAutoPlay
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        ReactNativeAutoPlay
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        ReactNativeAutoPlay
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

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

@@ -0,0 +1,27 @@
+///
+/// ReactNativeAutoPlay+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/ReactNativeAutoPlay+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 ReactNativeAutoPlay is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}