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

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

@@ -0,0 +1,30 @@
+package dev.mediacache.alphavideo.reactnative;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+
+/**
+ * Old architecture: the same methods as the spec codegen generates for the new one
+ * (NativeAlphaVideoModuleSpec), so the module compiles against either.
+ */
+public abstract class AlphaVideoModuleSpec extends ReactContextBaseJavaModule {
+    public static final String NAME = "RNAlphaVideo";
+
+    AlphaVideoModuleSpec(ReactApplicationContext context) {
+        super(context);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    public abstract void getDecoderInfo(Promise promise);
+    public abstract void getMaxDecoderInstances(String mimeType, Promise promise);
+    public abstract void getActiveDecoderCount(Promise promise);
+    public abstract void getDecoderStatus(Promise promise);
+}

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

@@ -0,0 +1,61 @@
+package dev.mediacache.alphavideo.reactnative;
+
+import android.util.Log;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.SimpleViewManager;
+
+/**
+ * Old architecture: the same methods as the interface codegen generates for the new one, so the
+ * manager compiles against either. Props arrive through its {@code @ReactProp} setters.
+ */
+public abstract class AlphaVideoViewManagerSpec<T extends View> extends SimpleViewManager<T> {
+
+    public abstract void setSource(T view, @Nullable ReadableMap value);
+    public abstract void setAutoPlay(T view, boolean value);
+    public abstract void setLoop(T view, boolean value);
+    public abstract void setPaused(T view, boolean value);
+    public abstract void setPlaybackSpeed(T view, double value);
+    public abstract void setCacheKey(T view, @Nullable String value);
+    public abstract void setStorage(T view, @Nullable String value);
+    public abstract void setMaxStorageBytes(T view, double value);
+    public abstract void setMode(T view, @Nullable String value);
+    public abstract void setDecoder(T view, @Nullable String value);
+    public abstract void setStreamPrefetchAhead(T view, int value);
+    public abstract void setUseDecodeQueue(T view, boolean value);
+    public abstract void setVerbose(T view, boolean value);
+
+    public abstract void play(T view);
+    public abstract void pause(T view);
+    public abstract void stop(T view);
+    public abstract void seekToFrame(T view, int frame);
+    public abstract void seekToTime(T view, double seconds);
+
+    @Override
+    public void receiveCommand(@NonNull T view, String commandName, @Nullable ReadableArray args) {
+        switch (commandName) {
+            case "play":
+                play(view);
+                break;
+            case "pause":
+                pause(view);
+                break;
+            case "stop":
+                stop(view);
+                break;
+            case "seekToFrame":
+                if (args != null && args.size() > 0) seekToFrame(view, args.getInt(0));
+                break;
+            case "seekToTime":
+                if (args != null && args.size() > 0) seekToTime(view, args.getDouble(0));
+                break;
+            default:
+                Log.w("AlphaVideoViewManager", "Unknown command: " + commandName);
+        }
+    }
+}

package/react-native/ios/RNAlphaVideoViewComponentView.mm

@@ -0,0 +1,173 @@
+//
+//  RNAlphaVideoViewComponentView.mm
+//  Fabric component view for AlphaVideoView (new architecture)
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTConversions.h>
+#import <React/RCTViewComponentView.h>
+
+#import <react/renderer/components/RNAlphaVideoSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNAlphaVideoSpec/EventEmitters.h>
+#import <react/renderer/components/RNAlphaVideoSpec/Props.h>
+#import <react/renderer/components/RNAlphaVideoSpec/RCTComponentViewHelpers.h>
+
+#import "AlphaVideo.h"
+
+using namespace facebook::react;
+
+static const std::shared_ptr<const RNAlphaVideoViewProps> &RNAlphaVideoViewDefaultProps()
+{
+  static const auto defaultProps = std::make_shared<const RNAlphaVideoViewProps>();
+  return defaultProps;
+}
+
+@interface RNAlphaVideoViewComponentView : RCTViewComponentView <RCTRNAlphaVideoViewViewProtocol, AlphaVideoViewDelegate>
+@end
+
+@implementation RNAlphaVideoViewComponentView {
+  AlphaVideoView *_player;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNAlphaVideoViewComponentDescriptor>();
+}
+
+// A player holds its decoded frames, so each mount gets a new one.
++ (BOOL)shouldBeRecycled
+{
+  return NO;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = RNAlphaVideoViewDefaultProps();
+    [self createPlayer];
+  }
+  return self;
+}
+
+- (void)createPlayer
+{
+  _player = [[AlphaVideoView alloc] initWithFrame:self.bounds];
+  _player.delegate = self;
+  self.contentView = _player;
+}
+
+// Older React Native versions ignore shouldBeRecycled and recycle every component view.
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  [_player stop];
+  [self createPlayer];
+  _props = RNAlphaVideoViewDefaultProps();
+}
+
+// Only the props that changed: the player's setters act (pause, play, reload), and its defaults
+// match the spec's.
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &previous = *std::static_pointer_cast<const RNAlphaVideoViewProps>(_props);
+  const auto &next = *std::static_pointer_cast<const RNAlphaVideoViewProps>(props);
+
+  if (previous.mode != next.mode) _player.mode = RCTNSStringFromString(toString(next.mode));
+  if (previous.streamPrefetchAhead != next.streamPrefetchAhead) _player.streamPrefetchAhead = next.streamPrefetchAhead;
+  if (previous.useDecodeQueue != next.useDecodeQueue) _player.useDecodeQueue = next.useDecodeQueue;
+  if (previous.verbose != next.verbose) _player.verbose = next.verbose;
+  if (previous.autoPlay != next.autoPlay) _player.autoPlay = next.autoPlay;
+  if (previous.loop != next.loop) _player.loop = next.loop;
+  if (previous.paused != next.paused) _player.paused = next.paused;
+  if (previous.playbackSpeed != next.playbackSpeed) _player.playbackSpeed = next.playbackSpeed;
+  if (previous.cacheKey != next.cacheKey) _player.cacheKey = RCTNSStringFromStringNilIfEmpty(next.cacheKey);
+  if (previous.storage != next.storage) _player.storage = RCTNSStringFromString(toString(next.storage));
+  if (previous.maxStorageBytes != next.maxStorageBytes) _player.maxStorageBytes = (int64_t)next.maxStorageBytes;
+  // Before the source, so a new source loads with them; a change on its own reloads it
+  if (previous.source.headers != next.source.headers) {
+    NSMutableDictionary<NSString *, NSString *> *headers = [NSMutableDictionary dictionary];
+    for (size_t i = 0; i + 1 < next.source.headers.size(); i += 2) {
+      headers[RCTNSStringFromString(next.source.headers[i])] = RCTNSStringFromString(next.source.headers[i + 1]);
+    }
+    _player.headers = headers;
+  }
+  if (previous.source.dataSource != next.source.dataSource) {
+    _player.dataSource = RCTNSStringFromStringNilIfEmpty(next.source.dataSource);
+  }
+  if (previous.source.uri != next.source.uri) _player.source = RCTNSStringFromStringNilIfEmpty(next.source.uri);
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+#pragma mark - AlphaVideoViewDelegate
+
+- (std::shared_ptr<const RNAlphaVideoViewEventEmitter>)playerEventEmitter
+{
+  return std::static_pointer_cast<const RNAlphaVideoViewEventEmitter>(_eventEmitter);
+}
+
+- (void)alphaVideoView:(AlphaVideoView *)view didLoadFrames:(int)totalFrames width:(int)width height:(int)height
+{
+  if (auto emitter = [self playerEventEmitter]) {
+    // iOS always decodes on the C++ core, so the decoder prop has nothing to choose
+    emitter->onLoad({.totalFrames = totalFrames, .width = width, .height = height,
+                     .decoder = RCTStringFromNSString(view.loadedDecoder)});
+  }
+}
+
+- (void)alphaVideoView:(AlphaVideoView *)view didFailWithError:(NSString *)error code:(NSString *)code
+{
+  if (auto emitter = [self playerEventEmitter]) {
+    emitter->onError({.error = RCTStringFromNSString(error), .code = RCTStringFromNSString(code ?: @"")});
+  }
+}
+
+- (void)alphaVideoViewDidEnd:(AlphaVideoView *)view
+{
+  if (auto emitter = [self playerEventEmitter]) {
+    emitter->onEnd({});
+  }
+}
+
+#pragma mark - Commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTRNAlphaVideoViewHandleCommand(self, commandName, args);
+}
+
+- (void)play
+{
+  [_player play];
+}
+
+- (void)pause
+{
+  [_player pause];
+}
+
+- (void)stop
+{
+  [_player stop];
+}
+
+- (void)seekToFrame:(NSInteger)frame
+{
+  [_player seekToFrame:(int)frame];
+}
+
+- (void)seekToTime:(double)seconds
+{
+  [_player seekToTime:seconds];
+}
+
+@end
+
+// Older React Native versions look the class up by this name instead of codegenConfig.ios.componentProvider.
+extern "C" Class<RCTComponentViewProtocol> RNAlphaVideoViewCls(void)
+{
+  return RNAlphaVideoViewComponentView.class;
+}
+
+#endif

package/react-native/ios/RNAlphaVideoViewManager.mm

@@ -0,0 +1,147 @@
+//
+//  RNAlphaVideoViewManager.mm
+//  React Native view manager for AlphaVideoView (old architecture; the new one uses
+//  RNAlphaVideoViewComponentView.mm)
+//
+
+#ifndef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewManager.h>
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import "AlphaVideo.h"
+
+#pragma mark - RNAlphaVideoView
+
+/** AlphaVideoView with the React Native props and events. */
+@interface RNAlphaVideoView : AlphaVideoView <AlphaVideoViewDelegate>
+
+// `source` prop: { uri, headers?: [name, value, ...], dataSource? }
+@property (nonatomic, copy) NSDictionary *reactSource;
+// `decoder` prop: accepted for the shared JS API; iOS always decodes on the C++ core
+@property (nonatomic, copy) NSString *decoder;
+
+@property (nonatomic, copy) RCTDirectEventBlock onLoad;
+@property (nonatomic, copy) RCTDirectEventBlock onError;
+@property (nonatomic, copy) RCTDirectEventBlock onEnd;
+
+@end
+
+@implementation RNAlphaVideoView
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    self = [super initWithFrame:frame];
+    if (self) {
+        self.delegate = self;
+    }
+    return self;
+}
+
+- (void)setReactSource:(NSDictionary *)reactSource {
+    _reactSource = [reactSource copy];
+    NSArray *flat = [reactSource[@"headers"] isKindOfClass:[NSArray class]] ? reactSource[@"headers"] : @[];
+    NSMutableDictionary<NSString *, NSString *> *headers = [NSMutableDictionary dictionary];
+    for (NSUInteger i = 0; i + 1 < flat.count; i += 2) {
+        if ([flat[i] isKindOfClass:[NSString class]] && [flat[i + 1] isKindOfClass:[NSString class]]) {
+            headers[flat[i]] = flat[i + 1];
+        }
+    }
+    id dataSource = reactSource[@"dataSource"];
+    // Before the source, so a new source loads with them; a change on its own reloads it
+    self.headers = headers;
+    self.dataSource = [dataSource isKindOfClass:[NSString class]] && [dataSource length] > 0 ? dataSource : nil;
+    self.source = reactSource[@"uri"];
+}
+
+- (void)alphaVideoView:(AlphaVideoView *)view didLoadFrames:(int)totalFrames width:(int)width height:(int)height {
+    if (self.onLoad) {
+        self.onLoad(@{
+            @"totalFrames": @(totalFrames),
+            @"width": @(width),
+            @"height": @(height),
+            @"decoder": view.loadedDecoder
+        });
+    }
+}
+
+- (void)alphaVideoView:(AlphaVideoView *)view didFailWithError:(NSString *)error code:(NSString *)code {
+    if (self.onError) {
+        self.onError(code ? @{@"error": error, @"code": code} : @{@"error": error});
+    }
+}
+
+- (void)alphaVideoViewDidEnd:(AlphaVideoView *)view {
+    if (self.onEnd) {
+        self.onEnd(@{});
+    }
+}
+
+@end
+
+#pragma mark - RNAlphaVideoViewManager
+
+@interface RNAlphaVideoViewManager : RCTViewManager
+@end
+
+@implementation RNAlphaVideoViewManager
+
+RCT_EXPORT_MODULE(RNAlphaVideoView)
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (UIView *)view {
+    return [[RNAlphaVideoView alloc] initWithFrame:CGRectZero];
+}
+
+RCT_REMAP_VIEW_PROPERTY(source, reactSource, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(autoPlay, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(loop, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(paused, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(playbackSpeed, double)
+RCT_EXPORT_VIEW_PROPERTY(cacheKey, NSString)
+RCT_EXPORT_VIEW_PROPERTY(storage, NSString)
+RCT_EXPORT_VIEW_PROPERTY(maxStorageBytes, int64_t)
+RCT_EXPORT_VIEW_PROPERTY(mode, NSString)
+RCT_EXPORT_VIEW_PROPERTY(decoder, NSString)
+RCT_EXPORT_VIEW_PROPERTY(streamPrefetchAhead, int)
+RCT_EXPORT_VIEW_PROPERTY(useDecodeQueue, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(verbose, BOOL)
+
+RCT_EXPORT_VIEW_PROPERTY(onLoad, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onError, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onEnd, RCTDirectEventBlock)
+
+- (void)withView:(NSNumber *)reactTag do:(void (^)(RNAlphaVideoView *view))block {
+    [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        RNAlphaVideoView *view = (RNAlphaVideoView *)viewRegistry[reactTag];
+        if ([view isKindOfClass:[RNAlphaVideoView class]]) {
+            block(view);
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(play:(nonnull NSNumber *)reactTag) {
+    [self withView:reactTag do:^(RNAlphaVideoView *view) { [view play]; }];
+}
+
+RCT_EXPORT_METHOD(pause:(nonnull NSNumber *)reactTag) {
+    [self withView:reactTag do:^(RNAlphaVideoView *view) { [view pause]; }];
+}
+
+RCT_EXPORT_METHOD(stop:(nonnull NSNumber *)reactTag) {
+    [self withView:reactTag do:^(RNAlphaVideoView *view) { [view stop]; }];
+}
+
+RCT_EXPORT_METHOD(seekToFrame:(nonnull NSNumber *)reactTag frame:(nonnull NSNumber *)frame) {
+    [self withView:reactTag do:^(RNAlphaVideoView *view) { [view seekToFrame:[frame intValue]]; }];
+}
+
+RCT_EXPORT_METHOD(seekToTime:(nonnull NSNumber *)reactTag seconds:(nonnull NSNumber *)seconds) {
+    [self withView:reactTag do:^(RNAlphaVideoView *view) { [view seekToTime:[seconds doubleValue]]; }];
+}
+
+@end
+
+#endif