react-native-alpha-video 0.0.0-stage → 1.0.1

package/react-native/android/CMakeLists.txt

@@ -0,0 +1,14 @@
+# The React Native package's native libraries: the standalone library's core, and the codec
+# modules in ALPHA_VIDEO_CODECS (build.gradle), each its own library as in the Maven artifacts.
+cmake_minimum_required(VERSION 3.22.1)
+project(alphavideo_reactnative)
+
+# "none" rather than empty: an empty -D value doesn't reach CMake, which would then build both.
+set(ALPHA_VIDEO_CODECS "vpx;av1" CACHE STRING "Codec modules to build: vpx, av1, or none")
+set(ANDROID_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../android")
+
+add_subdirectory("${ANDROID_DIR}/src/main/cpp" core)
+list(REMOVE_ITEM ALPHA_VIDEO_CODECS none)
+foreach(codec IN LISTS ALPHA_VIDEO_CODECS)
+    add_subdirectory("${ANDROID_DIR}/${codec}/src/main/cpp" "${codec}")
+endforeach()

package/react-native/android/build.gradle

@@ -0,0 +1,113 @@
+// The React Native package's Android module. It compiles the standalone library's sources
+// (../../android) together with the React Native glue, because autolinking adds only this one
+// Gradle project to the app.
+
+def isNewArchitectureEnabled() {
+    // Set by the app's gradle.properties, and always "true" from React Native 0.82
+    return project.findProperty('newArchEnabled')?.toString() == 'true'
+}
+
+apply plugin: 'com.android.library'
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
+
+def safeExtGet(name, fallback) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
+}
+
+def coreDir = file('../../android')
+def packageRoot = file('../..')
+
+// The codec modules built in, android/vpx (libvpx) and android/av1 (dav1d): the app's package.json
+// "react-native-alpha-video": { "codecs": [...] }, else both. The podspec reads the same setting.
+def readCodecs() {
+    def allCodecs = ['vpx', 'av1']
+    def appPackageJson = rootProject.file('../package.json')
+    if (!appPackageJson.exists()) return allCodecs
+    def config = new groovy.json.JsonSlurper().parse(appPackageJson)['react-native-alpha-video']
+    if (config?.codecs == null) return allCodecs
+    def unknown = config.codecs.findAll { !allCodecs.contains(it) }
+    if (!(config.codecs instanceof List) || unknown) {
+        throw new GradleException("react-native-alpha-video: \"codecs\" in ${appPackageJson} must list some of ${allCodecs}, not ${config.codecs}")
+    }
+    return allCodecs.findAll { config.codecs.contains(it) }
+}
+def codecs = readCodecs()
+logger.lifecycle("react-native-alpha-video: codecs ${codecs.isEmpty() ? 'none (MediaCodec only)' : codecs.join(', ')}")
+
+// range-source, the add-on the player reads URLs and data sources through, is the app's own
+// dependency, react-native-range-source, which autolinking adds; the player finds it at run time
+// (RangeSourceLink) and plays URLs without it.
+def rangeSourceProject = rootProject.findProject(':react-native-range-source')
+logger.lifecycle("react-native-alpha-video: range-source ${rangeSourceProject ? 'from react-native-range-source' : 'not installed (URLs are downloaded whole; npm i react-native-range-source for range streaming and storage)'}")
+
+if (isNewArchitectureEnabled()) {
+    // The codegen tasks look for package.json and the specs next to this folder; both are two
+    // levels up, in the package root.
+    tasks.named('generateCodegenSchemaFromJavaScript').configure {
+        jsRootDir.set(file("${packageRoot}/react-native/src"))
+        // A property in newer React Native; in 0.76 and earlier, a file tree that follows jsRootDir
+        if (jsInputFiles instanceof org.gradle.api.provider.Property) {
+            jsInputFiles.set(fileTree("${packageRoot}/react-native/src") { include '**/*.ts', '**/*.tsx' })
+        }
+    }
+    tasks.named('generateCodegenArtifactsFromSchema').configure {
+        packageJsonFile.set(file("${packageRoot}/package.json"))
+    }
+}
+
+android {
+    namespace 'dev.mediacache.alphavideo.reactnative'
+    compileSdk safeExtGet('compileSdkVersion', 36)
+    ndkVersion safeExtGet('ndkVersion', '27.1.12297006')
+
+    defaultConfig {
+        minSdk safeExtGet('minSdkVersion', 24)
+        buildConfigField 'boolean', 'IS_NEW_ARCHITECTURE_ENABLED', isNewArchitectureEnabled().toString()
+        consumerProguardFiles("${coreDir}/consumer-rules.pro", *codecs.collect { "${coreDir}/${it}/consumer-rules.pro" })
+
+        externalNativeBuild {
+            cmake {
+                cppFlags '-std=c++17 -frtti -fexceptions -O3'
+                abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86_64'
+                arguments '-DANDROID_STL=c++_shared', "-DALPHA_VIDEO_CODECS=${codecs.isEmpty() ? 'none' : codecs.join(';')}"
+            }
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path 'CMakeLists.txt'
+            version '3.22.1'
+        }
+    }
+
+    buildFeatures {
+        buildConfig true
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs = [
+                'src/main/java',
+                "${coreDir}/src/main/java",
+                isNewArchitectureEnabled() ? 'src/newarch/java' : 'src/oldarch/java',
+                // AppDataSource, against range-source's classes, or a stub without them
+                rangeSourceProject ? "${coreDir}/src/rangesource/java" : 'src/norangesource/java',
+            ] + codecs.collect { "${coreDir}/${it}/src/main/java" }
+        }
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-android'
+    if (rangeSourceProject) {
+        compileOnly rangeSourceProject
+    }
+}

package/react-native/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/react-native/android/src/main/java/dev/mediacache/alphavideo/reactnative/AlphaVideoModule.java

@@ -0,0 +1,102 @@
+package dev.mediacache.alphavideo.reactnative;
+
+import dev.mediacache.alphavideo.AlphaVideoCodecs;
+import dev.mediacache.alphavideo.SurfaceTextureVideoDecoder;
+
+import android.util.Log;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.bridge.WritableNativeMap;
+
+/**
+ * React Native Module for WebM Alpha Player utility functions.
+ * Provides access to video decoder information and diagnostics.
+ */
+public class AlphaVideoModule extends AlphaVideoModuleSpec {
+    
+    private static final String TAG = "RNAlphaVideo";
+    
+    public AlphaVideoModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+    
+    /**
+     * Get detailed decoder information for all supported codecs (VP9, AV1).
+     */
+    @Override
+    @ReactMethod
+    public void getDecoderInfo(Promise promise) {
+        try {
+            String info = SurfaceTextureVideoDecoder.getDecoderInfo();
+            Log.i(TAG, info);
+            promise.resolve(info);
+        } catch (Exception e) {
+            promise.reject("DECODER_INFO_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Get the maximum number of concurrent decoder instances for a given codec.
+     */
+    @Override
+    @ReactMethod
+    public void getMaxDecoderInstances(String mimeType, Promise promise) {
+        try {
+            int max = SurfaceTextureVideoDecoder.getMaxInstances(mimeType);
+            promise.resolve(max);
+        } catch (Exception e) {
+            promise.reject("DECODER_INFO_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Get the current number of active decoder instances.
+     */
+    @Override
+    @ReactMethod
+    public void getActiveDecoderCount(Promise promise) {
+        try {
+            int count = SurfaceTextureVideoDecoder.getActiveDecoderCount();
+            promise.resolve(count);
+        } catch (Exception e) {
+            promise.reject("DECODER_INFO_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Get comprehensive decoder status as a structured object.
+     */
+    @Override
+    @ReactMethod
+    public void getDecoderStatus(Promise promise) {
+        try {
+            int maxVp9 = SurfaceTextureVideoDecoder.getMaxInstances(SurfaceTextureVideoDecoder.MIME_VP9);
+            int maxAv1 = SurfaceTextureVideoDecoder.getMaxInstances(SurfaceTextureVideoDecoder.MIME_AV1);
+            int activeCount = SurfaceTextureVideoDecoder.getActiveDecoderCount();
+            boolean hasVp9Hw = SurfaceTextureVideoDecoder.isVp9HardwareDecoderAvailable();
+            boolean hasAv1Hw = SurfaceTextureVideoDecoder.isAv1HardwareDecoderAvailable();
+            
+            WritableMap result = new WritableNativeMap();
+            result.putInt("maxVp9Instances", maxVp9);
+            result.putInt("maxAv1Instances", maxAv1);
+            result.putBoolean("vp9HardwareAvailable", hasVp9Hw);
+            result.putBoolean("av1HardwareAvailable", hasAv1Hw);
+            result.putInt("activeDecoders", activeCount);
+            result.putInt("availableVp9Slots", Math.max(0, maxVp9 - activeCount));
+            result.putInt("maxDualStreamPlayers", Math.max(maxVp9, maxAv1) / 2);
+            result.putBoolean("canCreateMore", activeCount < Math.max(maxVp9, maxAv1) - 1);
+            WritableArray softwareDecoders = new WritableNativeArray();
+            for (String decoder : AlphaVideoCodecs.softwareDecoders()) softwareDecoders.pushString(decoder);
+            result.putArray("softwareDecoders", softwareDecoders);
+            
+            promise.resolve(result);
+        } catch (Exception e) {
+            promise.reject("DECODER_INFO_ERROR", e.getMessage());
+        }
+    }
+}

package/react-native/android/src/main/java/dev/mediacache/alphavideo/reactnative/AlphaVideoPackage.java

@@ -0,0 +1,50 @@
+package dev.mediacache.alphavideo.reactnative;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * React Native Package for WebM Alpha Player
+ */
+// TurboReactPackage is deprecated in favour of BaseReactPackage, which React Native before 0.74 lacks.
+@SuppressWarnings("deprecation")
+public class AlphaVideoPackage extends TurboReactPackage {
+
+    @Nullable
+    @Override
+    public NativeModule getModule(@NonNull String name, @NonNull ReactApplicationContext reactContext) {
+        return AlphaVideoModule.NAME.equals(name) ? new AlphaVideoModule(reactContext) : null;
+    }
+
+    @NonNull
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return () -> Collections.singletonMap(
+            AlphaVideoModule.NAME,
+            new ReactModuleInfo(
+                AlphaVideoModule.NAME,
+                AlphaVideoModule.class.getName(),
+                false, // canOverrideExistingModule
+                false, // needsEagerInit
+                false, // isCxxModule
+                BuildConfig.IS_NEW_ARCHITECTURE_ENABLED // isTurboModule
+            )
+        );
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.singletonList(new AlphaVideoViewManager(reactContext));
+    }
+}

package/react-native/android/src/main/java/dev/mediacache/alphavideo/reactnative/AlphaVideoViewManager.java

@@ -0,0 +1,317 @@
+package dev.mediacache.alphavideo.reactnative;
+
+import dev.mediacache.alphavideo.AlphaVideoView;
+
+import android.graphics.Color;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.ViewProps;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.EventDispatcher;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * React Native ViewManager for AlphaVideoView
+ * Uses TextureView for proper z-ordering and ScrollView compatibility
+ * 
+ * Props match WebMAlphaView interface:
+ * - source: { uri, headers?, dataSource? } or { path }, where uri is https://, file://, an
+ *   absolute path, asset:// or content://, or anything the named data source reads; headers come
+ *   as a flat [name, value, ...] array
+ * - autoPlay: boolean (default true)
+ * - loop: boolean (default true)
+ * - paused: boolean (default false)
+ * - playbackSpeed: double (default 1.0, changeable while playing)
+ * - cacheKey: string (what the store keeps the source under, instead of its URL)
+ * - storage: "auto" | "disk" | "memory" | "none"; maxStorageBytes: double (0 for 512 MB)
+ * 
+ * Commands: play, pause, stop, seekToFrame(frame), seekToTime(seconds). Events: onLoad, onError, onEnd, onPreloadComplete.
+ * Every prop and event is declared in the codegen spec, react-native/src/AlphaVideoViewNativeComponent.ts.
+ */
+public class AlphaVideoViewManager extends AlphaVideoViewManagerSpec<AlphaVideoView> {
+    
+    public static final String REACT_CLASS = "RNAlphaVideoView";
+    
+    public AlphaVideoViewManager(ReactApplicationContext context) {
+    }
+    
+    @NonNull
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+    
+    @NonNull
+    @Override
+    protected AlphaVideoView createViewInstance(@NonNull ThemedReactContext context) {
+        AlphaVideoView view = new AlphaVideoView(context);
+        view.setCallback(new EventForwarder(view));
+        return view;
+    }
+    
+    @Override
+    public void onDropViewInstance(@NonNull AlphaVideoView view) {
+        view.release();
+        super.onDropViewInstance(view);
+    }
+    
+    /**
+     * TextureView throws on a background drawable, so a backgroundColor style would crash the
+     * app. The view stays transparent; put a background on a parent view instead.
+     */
+    @Override
+    @ReactProp(name = ViewProps.BACKGROUND_COLOR, defaultInt = Color.TRANSPARENT, customType = "Color")
+    public void setBackgroundColor(@NonNull AlphaVideoView view, int backgroundColor) {
+    }
+    
+    @ReactProp(name = "source")
+    @Override
+    public void setSource(AlphaVideoView view, @Nullable ReadableMap source) {
+        String sourceUri = null;
+        if (source != null) {
+            if (source.hasKey("uri") && !source.isNull("uri")) {
+                sourceUri = source.getString("uri");
+            } else if (source.hasKey("path") && !source.isNull("path")) {
+                sourceUri = source.getString("path");
+            }
+        }
+        
+        if (sourceUri == null || sourceUri.isEmpty()) return;
+        Map<String, String> headers = new LinkedHashMap<>();
+        if (source.hasKey("headers") && !source.isNull("headers")) {
+            ReadableArray flat = source.getArray("headers");
+            for (int i = 0; flat != null && i + 1 < flat.size(); i += 2) {
+                headers.put(flat.getString(i), flat.getString(i + 1));
+            }
+        }
+        view.setHeaders(headers);
+        view.setDataSource(source.hasKey("dataSource") && !source.isNull("dataSource")
+            ? source.getString("dataSource") : null);
+        view.setSource(sourceUri);
+    }
+    
+    @ReactProp(name = "autoPlay", defaultBoolean = true)
+    @Override
+    public void setAutoPlay(AlphaVideoView view, boolean autoPlay) {
+        view.setAutoPlay(autoPlay);
+    }
+    
+    @ReactProp(name = "loop", defaultBoolean = true)
+    @Override
+    public void setLoop(AlphaVideoView view, boolean loop) {
+        view.setLoop(loop);
+    }
+    
+    @ReactProp(name = "paused", defaultBoolean = false)
+    @Override
+    public void setPaused(AlphaVideoView view, boolean paused) {
+        view.setPaused(paused);
+    }
+    
+    /**
+     * Playback rate. iOS and web have had this; Android had the plumbing but no prop, so the
+     * value never left JS.
+     */
+    @ReactProp(name = "playbackSpeed", defaultDouble = 1.0)
+    @Override
+    public void setPlaybackSpeed(AlphaVideoView view, double playbackSpeed) {
+        view.setPlaybackSpeed(playbackSpeed);
+    }
+    
+    @ReactProp(name = "cacheKey")
+    @Override
+    public void setCacheKey(AlphaVideoView view, @Nullable String cacheKey) {
+        view.setCacheKey(cacheKey);
+    }
+    
+    /** "auto" (default), "disk", "memory" or "none"; see AlphaVideoView.setStorage. */
+    @ReactProp(name = "storage")
+    @Override
+    public void setStorage(AlphaVideoView view, @Nullable String storage) {
+        view.setStorage(storage);
+    }
+    
+    /** 0 for the default, 512 MB. */
+    @ReactProp(name = "maxStorageBytes", defaultDouble = 0)
+    @Override
+    public void setMaxStorageBytes(AlphaVideoView view, double maxStorageBytes) {
+        view.setMaxStorageBytes((long) maxStorageBytes);
+    }
+    
+    /**
+     * Set the playback mode.
+     * - "preload": decode all frames upfront, then play
+     * - "stream" (default): decode on-demand with sliding window cache
+     * - "streamAndPreload": start playing immediately, cache all frames for smooth looping
+     */
+    @ReactProp(name = "mode")
+    @Override
+    public void setMode(AlphaVideoView view, @Nullable String mode) {
+        view.setMode(mode != null ? mode : "stream");
+    }
+    
+    /** "auto" (default), "mediacodec", "mediacodec-hw", "mediacodec-sw" or "software"; see AlphaVideoView.setDecoder. */
+    @ReactProp(name = "decoder")
+    @Override
+    public void setDecoder(AlphaVideoView view, @Nullable String decoder) {
+        view.setDecoder(decoder);
+    }
+    
+    /**
+     * Set how many frames to decode ahead of the shown one when streaming
+     * Default: 8 frames (about 0.27 seconds at 30fps)
+     */
+    @ReactProp(name = "streamPrefetchAhead", defaultInt = 8)
+    @Override
+    public void setStreamPrefetchAhead(AlphaVideoView view, int frames) {
+        view.setStreamPrefetchAhead(frames);
+    }
+    
+    /**
+     * Enable/disable global decode queue for preload/streamAndPreload modes.
+     * When true (default): decoding is serialized across all players, preventing CPU saturation
+     * When false: each player decodes independently (can freeze with many)
+     * Has no effect when mode='stream'.
+     */
+    @ReactProp(name = "useDecodeQueue", defaultBoolean = true)
+    @Override
+    public void setUseDecodeQueue(AlphaVideoView view, boolean use) {
+        view.setUseDecodeQueue(use);
+    }
+    
+    /**
+     * Enable verbose logging for debugging: lifecycle, performance, and per-frame events.
+     * When false (default): only warnings and errors.
+     */
+    @ReactProp(name = "verbose", defaultBoolean = false)
+    @Override
+    public void setVerbose(AlphaVideoView view, boolean verbose) {
+        view.setVerbose(verbose);
+    }
+    
+    @Override
+    public void play(AlphaVideoView view) {
+        view.play();
+    }
+
+    @Override
+    public void pause(AlphaVideoView view) {
+        view.pause();
+    }
+
+    @Override
+    public void stop(AlphaVideoView view) {
+        view.stop();
+    }
+
+    @Override
+    public void seekToFrame(AlphaVideoView view, int frame) {
+        view.seekToFrame(frame);
+    }
+
+    @Override
+    public void seekToTime(AlphaVideoView view, double seconds) {
+        view.seekToTime(seconds);
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        return MapBuilder.<String, Object>builder()
+            .put("onLoad", MapBuilder.of("registrationName", "onLoad"))
+            .put("onError", MapBuilder.of("registrationName", "onError"))
+            .put("onEnd", MapBuilder.of("registrationName", "onEnd"))
+            .put("onPreloadComplete", MapBuilder.of("registrationName", "onPreloadComplete"))
+            .build();
+    }
+    
+    /** Turns player callbacks into React events on the view. */
+    private static final class EventForwarder implements AlphaVideoView.PlayerCallback {
+        private final AlphaVideoView view;
+        
+        EventForwarder(AlphaVideoView view) {
+            this.view = view;
+        }
+        
+        @Override
+        public void onLoad(int totalFrames, int width, int height, String decoder) {
+            WritableMap event = Arguments.createMap();
+            event.putInt("totalFrames", totalFrames);
+            event.putInt("width", width);
+            event.putInt("height", height);
+            event.putString("decoder", decoder);
+            send("onLoad", event);
+        }
+        
+        @Override
+        public void onError(String error, String code) {
+            WritableMap event = Arguments.createMap();
+            event.putString("error", error);
+            if (code != null) event.putString("code", code);
+            send("onError", event);
+        }
+        
+        @Override
+        public void onEnd() {
+            send("onEnd", Arguments.createMap());
+        }
+        
+        @Override
+        public void onPreloadComplete(int frames, double timeMs) {
+            WritableMap event = Arguments.createMap();
+            event.putInt("totalFrames", frames);
+            event.putDouble("timeMs", timeMs);
+            send("onPreloadComplete", event);
+        }
+        
+        private void send(String eventName, WritableMap params) {
+            ReactContext context = (ReactContext) view.getContext();
+            EventDispatcher dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.getId());
+            if (dispatcher == null) return;
+            dispatcher.dispatchEvent(
+                new PlayerEvent(UIManagerHelper.getSurfaceId(view), view.getId(), eventName, params));
+        }
+    }
+    
+    private static final class PlayerEvent extends Event<PlayerEvent> {
+        private final String eventName;
+        private final WritableMap eventData;
+        
+        PlayerEvent(int surfaceId, int viewTag, String eventName, WritableMap eventData) {
+            super(surfaceId, viewTag);
+            this.eventName = eventName;
+            this.eventData = eventData;
+        }
+        
+        @NonNull
+        @Override
+        public String getEventName() {
+            return eventName;
+        }
+        
+        @Override
+        public boolean canCoalesce() {
+            return false;
+        }
+        
+        @Nullable
+        @Override
+        protected WritableMap getEventData() {
+            return eventData;
+        }
+    }
+}

package/react-native/android/src/newarch/java/dev/mediacache/alphavideo/reactnative/AlphaVideoModuleSpec.java

@@ -0,0 +1,10 @@
+package dev.mediacache.alphavideo.reactnative;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+
+/** New architecture: the TurboModule spec generated from NativeAlphaVideoModule.ts. */
+public abstract class AlphaVideoModuleSpec extends NativeAlphaVideoModuleSpec {
+    AlphaVideoModuleSpec(ReactApplicationContext context) {
+        super(context);
+    }
+}

package/react-native/android/src/newarch/java/dev/mediacache/alphavideo/reactnative/AlphaVideoViewManagerSpec.java

@@ -0,0 +1,23 @@
+package dev.mediacache.alphavideo.reactnative;
+
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ViewManagerDelegate;
+import com.facebook.react.viewmanagers.RNAlphaVideoViewManagerDelegate;
+import com.facebook.react.viewmanagers.RNAlphaVideoViewManagerInterface;
+
+/** New architecture: props and commands arrive through the delegate generated from the codegen spec. */
+public abstract class AlphaVideoViewManagerSpec<T extends View> extends SimpleViewManager<T>
+        implements RNAlphaVideoViewManagerInterface<T> {
+
+    private final ViewManagerDelegate<T> delegate = new RNAlphaVideoViewManagerDelegate<>(this);
+
+    @Nullable
+    @Override
+    protected ViewManagerDelegate<T> getDelegate() {
+        return delegate;
+    }
+}

package/react-native/android/src/norangesource/java/dev/mediacache/alphavideo/AppDataSource.java

@@ -0,0 +1,15 @@
+package dev.mediacache.alphavideo;
+
+/**
+ * Stands in for android/src/rangesource's AppDataSource when the app hasn't installed
+ * react-native-range-source, so the package builds without range-source's classes. Never
+ * reached: {@link RangeSourceLink#available()} is false without the add-on.
+ */
+final class AppDataSource {
+
+    private AppDataSource() {}
+
+    static Fetcher create(String name) {
+        return null;
+    }
+}