react-native-spalla-player 0.13.3 → 1.0.1

package/android/src/main/java/com/spallaplayer/SpallaPlayerViewManager.kt

@@ -4,145 +4,210 @@ import android.util.Log
 import android.view.View
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewManagerDelegate
 import com.facebook.react.uimanager.annotations.ReactProp
-import com.facebook.react.uimanager.events.RCTEventEmitter
 import com.spalla.sdk.android.core.player.entities.SpallaPlayerEvent
 import com.spalla.sdk.android.core.player.entities.SpallaPlayerEvent.*
 import com.spalla.sdk.android.core.player.listeners.SpallaPlayerFullScreenListener
 import com.spalla.sdk.android.core.player.listeners.SpallaPlayerListener
 import com.spalla.sdk.android.core.player.view.SpallaPlayerView
 import java.util.Timer
-import java.util.TimerTask
 
-class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
+// These imports will work because Codegen runs for Fabric builds.
+// Your IDE will show errors on these lines until you build the project.
+import com.facebook.react.viewmanagers.SpallaPlayerViewManagerInterface
+import com.facebook.react.viewmanagers.SpallaPlayerViewManagerDelegate
+
+// Implement the Codegen interface for Fabric support
+@ReactModule(name = SpallaPlayerViewManager.REACT_CLASS)
+class SpallaPlayerViewManager() : ViewGroupManager<SpallaPlayerView>(),
+  SpallaPlayerViewManagerInterface<SpallaPlayerView>, // Fabric interface
   SpallaPlayerListener, SpallaPlayerFullScreenListener {
+
+  companion object {
+    const val REACT_CLASS = "SpallaPlayerView"
+  }
+
+  // The delegate is required for Fabric to handle props and commands.
+  private val mDelegate = SpallaPlayerViewManagerDelegate(this)
+
+  // This method is required by the Fabric architecture.
+  override fun getDelegate(): ViewManagerDelegate<SpallaPlayerView> = mDelegate
+
   private var _playerView: SpallaPlayerView? = null
   private var _reactContext: ReactContext? = null
-  private var _container: SpallaPlayerContainerView? = null
-
+  //private var _container: SpallaPlayerView? = null
   private var contentId: String? = null
   private var startTime: Double? = null
   private var subtitle: String? = null
   private var loadTimer: Timer? = null
   private var playbackRate: Double = 1.0
   private var hideUI: Boolean? = null
+  private var _viewTag: Int = -1
 
-  override fun getName() = "RNSpallaPlayer"
+  override fun getName() = REACT_CLASS
 
-  override fun createViewInstance(context: ThemedReactContext): SpallaPlayerContainerView {
+  override fun createViewInstance(context: ThemedReactContext): SpallaPlayerView {
     _reactContext = context
-    val container = SpallaPlayerContainerView(context)
-    _playerView = container.spallaPlayerView
-    _playerView?.registerPlayerListener(this)
-    _playerView?.registerFullScreenListener(this)
-    this._container = container
-
-    return container
-  }
+    //val container = SpallaPlayerContainerView(context)
+    val player = SpallaPlayerView(context)
+
+    // Defer initialization until view is attached to window
+    player.addOnAttachStateChangeListener(object : View.OnAttachStateChangeListener {
+      override fun onViewAttachedToWindow(view: View) {
+        try {
+          _playerView = player
+          _playerView?.registerPlayerListener(this@SpallaPlayerViewManager)
+          _playerView?.registerFullScreenListener(this@SpallaPlayerViewManager)
+          // Remove listener to avoid memory leaks
+          view.removeOnAttachStateChangeListener(this)
+
+          checkAndLoadPlayer(player)
+        } catch (e: Exception) {
+          Log.e("SpallaPlayerViewManager", "Error during view attachment", e)
+        }
+      }
 
-  override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
-    val eventMap = mutableMapOf<String, Any>()
+      override fun onViewDetachedFromWindow(view: View) {
+        _playerView?.pause()
 
-    eventMap["onPlayerEvent"] = mapOf(
-      "phasedRegistrationNames" to mapOf(
-        "bubbled" to "onPlayerEvent"
-      )
-    )
+      }
+    })
 
-    return eventMap
+    //this._container = container
+    //return container
+    return player
   }
 
-  override fun onDropViewInstance(view: SpallaPlayerContainerView) {
+  override fun onDropViewInstance(view: SpallaPlayerView) {
     Log.v("RNSpallaPlayerManager", "onDropViewInstance")
-
     try {
-      view.spallaPlayerView.onDestroy()
+      view.onDestroy()
     } catch (e: Exception) {
       e.printStackTrace()
     }
     super.onDropViewInstance(view)
   }
 
-  override fun addView(parent: SpallaPlayerContainerView, child: View, index: Int) {
-    parent.addView(child, index)
-  }
-
-  override fun removeViewAt(parent: SpallaPlayerContainerView, index: Int) {
-    parent.removeViewAt(index)
-  }
-
-  override fun getChildCount(parent: SpallaPlayerContainerView): Int {
-    return parent.childCount
-  }
-
-  override fun getChildAt(parent: SpallaPlayerContainerView, index: Int): View {
-    return parent.getChildAt(index)
-  }
-
+  // --- Prop Setters ---
   @ReactProp(name = "contentId")
-  fun setContentId(view: SpallaPlayerContainerView, contentId: String) {
-    this.contentId = contentId
-    checkAndLoadPlayer(view)
+  override fun setContentId(view: SpallaPlayerView, value: String?) {
+    _viewTag = view.tag as? Int ?: -1
+    if (value != null) {
+      this.contentId = value
+      //add a hacky delay here, so if content and starttime are changed at same time,
+      //start time is set first
+      view.postDelayed({
+        checkAndLoadPlayer(view)
+      }, 100L)
+    }
   }
 
   @ReactProp(name = "muted")
-  fun setMuted(view: SpallaPlayerContainerView, muted: Boolean) {
-    _playerView?.setMuted(muted)
+  override fun setMuted(view: SpallaPlayerView, value: Boolean) {
+    _playerView?.setMuted(value)
   }
 
   @ReactProp(name = "startTime")
-  fun setStartTime(view: SpallaPlayerContainerView, startTime: Double) {
-    this.startTime = startTime
+  override fun setStartTime(view: SpallaPlayerView, value: Double) {
+    this.startTime = value
     //checkAndLoadPlayer(view)
   }
 
   @ReactProp(name = "subtitle")
-  fun setSubtitle(view: SpallaPlayerContainerView, subtitle: String?) {
-    this.subtitle = subtitle
+  override fun setSubtitle(view: SpallaPlayerView, value: String?) {
+    this.subtitle = value
     _playerView?.selectSubtitle(subtitle)
   }
 
   @ReactProp(name = "playbackRate")
-  fun setPlaybackRate(view: SpallaPlayerContainerView, playbackRate: Double) {
-    if (playbackRate > 0) {
-      this.playbackRate = playbackRate
+  override fun setPlaybackRate(view: SpallaPlayerView, value: Float) {
+    if (value > 0) {
+      this.playbackRate = value.toDouble()
       _playerView?.selectPlaybackRate(playbackRate)
     }
   }
 
   @ReactProp(name = "hideUI")
-  fun setPlaybackRate(view: SpallaPlayerContainerView, hideUI: Boolean) {
-    this.hideUI = hideUI
-    checkAndLoadPlayer(view)
+  override fun setHideUI(view: SpallaPlayerView, value: Boolean) {
+    this.hideUI = value
+    //checkAndLoadPlayer(view)
   }
 
-  private fun checkAndLoadPlayer(view: SpallaPlayerContainerView) {
-    if (contentId != null && startTime != null && hideUI != null) {
-      view.spallaPlayerView.load(contentId!!, true, startTime!!, subtitle, hideUI!!)
-    }
+  override fun play(view: SpallaPlayerView?) {
+    view?.play()
+  }
+
+  override fun pause(view: SpallaPlayerView?) {
+    view?.pause()
+  }
+
+  override fun seekTo(
+    view: SpallaPlayerView?,
+    time: Double
+  ) {
+    view?.seekTo(time)
+  }
+
+  override fun selectSubtitle(
+    view: SpallaPlayerView?,
+    subtitle: String?
+  ) {
+    view?.selectSubtitle(subtitle)
   }
 
-  private fun startLoadTimer(view: SpallaPlayerView) {
-    // Cancel any existing timer
-    loadTimer?.cancel()
+  override fun selectPlaybackRate(
+    view: SpallaPlayerView?,
+    rate: Float
+  ) {
+    view?.selectPlaybackRate(rate.toDouble())
+  }
+
+  override fun unmount(view: SpallaPlayerView?) {
+    view?.pause()
+    view?.onDestroy()
+  }
 
-    // Start a new timer to check if all required properties are set
-    loadTimer = Timer()
-    loadTimer?.schedule(object : TimerTask() {
-      override fun run() {
-        loadTimer?.cancel()
-        loadTimer = null
-        // Call view.load with the required properties
-        view.load(contentId!!, true, startTime!!, subtitle = subtitle, hideUI!!)
+  private fun checkAndLoadPlayer(view: SpallaPlayerView) {
+    try {
+      // Only load if view is attached to window and all required props are set
+      if (contentId != null && startTime != null && hideUI != null && view.isAttachedToWindow) {
+        view.load(contentId!!, true, startTime!!, subtitle, hideUI!!)
       }
-    }, 300) // Delay of 200ms to allow all properties to be set
+    } catch (e: Exception) {
+      Log.e("SpallaPlayerViewManager", "Error loading player", e)
+    }
+  }
+
+  // --- Command Handling ---
+  override fun receiveCommand(
+    root: SpallaPlayerView,
+    commandId: String,
+    args: ReadableArray?
+  ) {
+    mDelegate.receiveCommand(root, commandId, args)
+  }
+
+  // --- Event Handling ---
+  override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
+    return mutableMapOf(
+      "onPlayerEvent" to mapOf(
+        "phasedRegistrationNames" to mapOf(
+          "bubbled" to "onPlayerEvent"
+        )
+      )
+    )
   }
 
   override fun onEvent(event: SpallaPlayerEvent) {
     val map: WritableMap = Arguments.createMap()
+    val eventName = "onPlayerEvent"
 
     Log.v("RNSpallaPlayerManager", "onEvent: $event")
     when (event) {
@@ -150,13 +215,11 @@ class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
         map.putString("event", "durationUpdate")
         map.putDouble("duration", event.duration)
       }
-
       Ended -> map.putString("event", "ended")
       is Error -> {
         map.putString("event", "error")
         map.putString("message", event.message)
       }
-
       Pause -> map.putString("event", "pause")
       Play -> map.putString("event", "play")
       Playing -> map.putString("event", "playing")
@@ -164,69 +227,63 @@ class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
         map.putString("event", "timeUpdate")
         map.putDouble("time", event.currentTime)
       }
-
       Waiting -> map.putString("event", "buffering")
       is SubtitlesAvailable -> {
         map.putString("event", "subtitlesAvailable")
-
-        var subs = Arguments.createArray()
-        event.subtitles.forEach {
-          subs.pushString(it)
-        }
+        val subs = Arguments.createArray()
+        event.subtitles.forEach { subs.pushString(it) }
         map.putArray("subtitles", subs)
       }
-
       is SubtitleSelected -> {
         map.putString("event", "subtitleSelected")
         map.putString("subtitle", event.subtitle)
       }
-
       is MetadataLoaded -> {
         map.putString("event", "metadataLoaded")
         map.putBoolean("isLive", event.metadata.isLive)
         map.putDouble("duration", event.metadata.duration)
-
-        // make sure current playback rate is applied if set initially
         _playerView?.selectPlaybackRate(playbackRate)
       }
-
       is PlaybackRateSelected -> {
         map.putString("event", "playbackRateSelected")
         map.putDouble("rate", event.rate)
       }
-
     }
-    _container?.let { container ->
-      _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
-        container.id,
-        "onPlayerEvent",
-        map
-      )
+
+    _playerView?.let { view ->
+      _reactContext?.let { reactContext ->
+        val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+        val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id)
+        eventDispatcher?.dispatchEvent(
+          RNSpallaPlayerEvent(surfaceId, view.id, eventName, map)
+        )
+      }
     }
   }
 
   override fun onEnterFullScreen() {
-    Log.v("SpallaPlayerViewManager", "onEnterFullScreen")
     val map: WritableMap = Arguments.createMap()
     map.putString("event", "enterFullScreen")
-    _container?.let { container ->
-      _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
-        container.id,
-        "onPlayerEvent",
-        map
-      )
-    }
+    dispatchEvent("onPlayerEvent", map)
   }
 
   override fun onExitFullScreen() {
     val map: WritableMap = Arguments.createMap()
     map.putString("event", "exitFullScreen")
-    _container?.let { container ->
-      _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
-        container.id,
-        "onPlayerEvent",
-        map
-      )
+    dispatchEvent("onPlayerEvent", map)
+  }
+
+  private fun dispatchEvent(eventName: String, eventData: WritableMap) {
+    _playerView?.let { view ->
+      _reactContext?.let { reactContext ->
+        if (_viewTag != -1) {
+          val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+          val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id)
+          eventDispatcher?.dispatchEvent(
+            RNSpallaPlayerEvent(surfaceId, _viewTag, eventName, eventData)
+          )
+        }
+      }
     }
   }
 

package/ios/SpallaPlayerModule.h

@@ -0,0 +1,17 @@
+//
+//  SpallaPlayerModule.h
+//  Pods
+//
+//  Created by Rogerio Shimizu on 12/19/25.
+//
+
+#import <Foundation/Foundation.h>
+#import <SpallaPlayerViewSpec/SpallaPlayerViewSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SpallaPlayerModule : NSObject <NativeSpallaPlayerModuleSpec>
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SpallaPlayerModule.mm

@@ -0,0 +1,59 @@
+//
+//  SpallaPlayerModule.mm
+//  Pods
+//
+//  Created by Rogerio Shimizu on 12/19/25.
+//
+
+#import "SpallaPlayerModule.h"
+#import "SpallaPlayer-Swift.h"
+
+@interface SpallaPlayerModule ()
+
+@end
+
+@implementation SpallaPlayerModule
+
++ (NSString *)moduleName
+{
+  return @"SpallaPlayerModule";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params { 
+  return std::make_shared<facebook::react::NativeSpallaPlayerModuleSpecJSI>(params);
+}
+
+- (void)initialize:(nonnull NSString *)token applicationId:(nonnull NSString *)applicationId {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [SpallaPlayerWrapper initializeWithToken: token applicationId: applicationId];
+  });
+}
+
+- (void)pause:(NSInteger)tag { 
+  
+}
+
+- (void)play:(NSInteger)tag { 
+  
+}
+
+- (void)seekTo:(NSInteger)tag time:(double)time { 
+  
+}
+
+- (void)selectPlaybackRate:(NSInteger)tag rate:(double)rate { 
+  
+}
+
+- (void)selectSubtitle:(NSInteger)tag subtitle:(NSString * _Nullable)subtitle { 
+  
+}
+
+- (void)unmount:(NSInteger)tag { 
+  
+}
+
+
+@end
+
+

package/ios/SpallaPlayerView.h

@@ -0,0 +1,14 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+#ifndef SpallaPlayerViewNativeComponent_h
+#define SpallaPlayerViewNativeComponent_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SpallaPlayerView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* SpallaPlayerViewNativeComponent_h */

package/ios/SpallaPlayerView.mm

@@ -0,0 +1,158 @@
+#import "SpallaPlayerView.h"
+
+#import <react/renderer/components/SpallaPlayerViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/SpallaPlayerViewSpec/EventEmitters.h>
+#import <react/renderer/components/SpallaPlayerViewSpec/Props.h>
+#import <react/renderer/components/SpallaPlayerViewSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#import "SpallaPlayer-Swift.h"
+
+
+using namespace facebook::react;
+
+@interface SpallaPlayerView () <RCTSpallaPlayerViewViewProtocol>
+
+@end
+
+@implementation SpallaPlayerView {
+    SpallaPlayerWrapper * _view;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+    return concreteComponentDescriptorProvider<SpallaPlayerViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const SpallaPlayerViewProps>();
+    _props = defaultProps;
+
+    [self ensureFreshWrapper];
+  }
+
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &oldViewProps = *std::static_pointer_cast<SpallaPlayerViewProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<SpallaPlayerViewProps const>(props);
+  
+  BOOL didRefresh = [self ensureFreshWrapper];
+  
+  if (oldViewProps.contentId != newViewProps.contentId || didRefresh) {
+    [_view setContentId: [[NSString alloc] initWithUTF8String: newViewProps.contentId.c_str()]];
+  }
+  
+  if (oldViewProps.startTime != newViewProps.startTime || didRefresh) {
+    [_view setStartTime: [NSNumber numberWithDouble: newViewProps.startTime]];
+  }
+  
+  if (oldViewProps.hideUI != newViewProps.hideUI || didRefresh) {
+    [_view setHideUI: newViewProps.hideUI];
+  }
+  
+  if (oldViewProps.muted != newViewProps.muted || didRefresh) {
+    [_view setMuted: newViewProps.muted];
+  }
+  
+  if (oldViewProps.playbackRate != newViewProps.playbackRate || didRefresh) {
+    [_view setPlaybackRate: [NSNumber numberWithDouble: newViewProps.playbackRate]];
+  }
+  
+  if (oldViewProps.subtitle != newViewProps.subtitle || didRefresh) {
+    // SpallaPlayerViewProps::subtitle is a std::string (not an optional), so use empty() to check for "no subtitle".
+    if (!newViewProps.subtitle.empty()) {
+      [_view setSubtitle: [[NSString alloc] initWithUTF8String: newViewProps.subtitle.c_str()]];
+    } else {
+      [_view setSubtitle: nil];
+    }
+  }
+
+  [super updateProps:props oldProps:oldProps];
+  
+}
+
+- (BOOL)ensureFreshWrapper {
+  if (_view == nil) {
+    _view = [[SpallaPlayerWrapper alloc] init];
+    
+    __weak __typeof(self) weakSelf = self;
+    [_view setOnPlayerEvent:^(NSDictionary<NSString *,id> * _Nonnull value) {
+      SpallaPlayerViewEventEmitter::OnPlayerEvent event = SpallaPlayerViewEventEmitter::OnPlayerEvent{
+        .event = std::string([[value objectForKey:@"event"] UTF8String]),
+        .duration = value[@"duration"] != nil ? [value[@"duration"] doubleValue] : 0.0,
+        .time = value[@"time"] != nil ? [value[@"time"] doubleValue] : 0.0,
+        .rate = value[@"rate"] != nil ? [value[@"rate"] doubleValue] : 0.0,
+        .subtitle = value[@"subtitle"] != nil ? std::string([value[@"subtitle"] UTF8String]) : std::string(),
+        .isLive = value[@"isLive"] != nil ? [value[@"isLive"] boolValue] : false,
+        .error = value[@"error"] != nil ? std::string([value[@"error"] UTF8String]) : std::string()
+         
+      };
+      weakSelf.eventEmitter.onPlayerEvent(event);
+    }];
+    
+    self.contentView = _view;
+    return YES;
+  }
+  return NO;
+  
+}
+
+- (void)updateState:(const facebook::react::State::Shared &)state
+           oldState:(const facebook::react::State::Shared &)oldState {
+  [super updateState:state oldState:oldState];
+  
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTSpallaPlayerViewHandleCommand(self, commandName, args);
+}
+
+- (void)pause {
+  [_view pause];
+}
+
+- (void)play {
+  [_view play];
+}
+
+- (void) seekTo:(double)time {
+  [_view seekToTime: time];
+}
+
+- (void) selectPlaybackRate:(float)rate {
+  [_view selectPlaybackRate: rate];
+}
+
+- (void) selectSubtitle:(NSString *)subtitle {
+  [_view selectSubtitle: subtitle];
+}
+
+- (void) unmount {
+  [_view unmount];
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+
+  [_view setOnPlayerEvent: nil];
+  [_view unmount];
+  _view = nil;
+}
+
+- (const SpallaPlayerViewEventEmitter &)eventEmitter
+{
+  return static_cast<const SpallaPlayerViewEventEmitter &>(*_eventEmitter);
+}
+
+Class<RCTComponentViewProtocol> SpallaPlayerViewCls(void)
+{
+    return SpallaPlayerView.class;
+}
+
+@end