react-native-spalla-player 0.13.3 → 1.0.0

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

@@ -0,0 +1,289 @@
+package com.spallaplayer
+
+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.annotations.ReactProp
+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
+
+// 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() = mDelegate
+
+  private var _playerView: SpallaPlayerView? = null
+  private var _reactContext: ReactContext? = 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() = REACT_CLASS
+
+  override fun createViewInstance(context: ThemedReactContext): SpallaPlayerView {
+    _reactContext = context
+    //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 onViewDetachedFromWindow(view: View) {
+        _playerView?.pause()
+
+      }
+    })
+
+    //this._container = container
+    //return container
+    return player
+  }
+
+  override fun onDropViewInstance(view: SpallaPlayerView) {
+    Log.v("RNSpallaPlayerManager", "onDropViewInstance")
+    try {
+      view.onDestroy()
+    } catch (e: Exception) {
+      e.printStackTrace()
+    }
+    super.onDropViewInstance(view)
+  }
+
+  // --- Prop Setters ---
+  @ReactProp(name = "contentId")
+  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")
+  override fun setMuted(view: SpallaPlayerView, value: Boolean) {
+    _playerView?.setMuted(value)
+  }
+
+  @ReactProp(name = "startTime")
+  override fun setStartTime(view: SpallaPlayerView, value: Double) {
+    this.startTime = value
+    //checkAndLoadPlayer(view)
+  }
+
+  @ReactProp(name = "subtitle")
+  override fun setSubtitle(view: SpallaPlayerView, value: String?) {
+    this.subtitle = value
+    _playerView?.selectSubtitle(subtitle)
+  }
+
+  @ReactProp(name = "playbackRate")
+  override fun setPlaybackRate(view: SpallaPlayerView, value: Float) {
+    if (value > 0) {
+      this.playbackRate = value.toDouble()
+      _playerView?.selectPlaybackRate(playbackRate)
+    }
+  }
+
+  @ReactProp(name = "hideUI")
+  override fun setHideUI(view: SpallaPlayerView, value: Boolean) {
+    this.hideUI = value
+    //checkAndLoadPlayer(view)
+  }
+
+  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)
+  }
+
+  override fun selectPlaybackRate(
+    view: SpallaPlayerView?,
+    rate: Float
+  ) {
+    view?.selectPlaybackRate(rate.toDouble())
+  }
+
+  override fun unmount(view: SpallaPlayerView?) {
+    view?.pause()
+    view?.onDestroy()
+  }
+
+  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!!)
+      }
+    } 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) {
+      is DurationUpdate -> {
+        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")
+      is TimeUpdate -> {
+        map.putString("event", "timeUpdate")
+        map.putDouble("time", event.currentTime)
+      }
+      Waiting -> map.putString("event", "buffering")
+      is SubtitlesAvailable -> {
+        map.putString("event", "subtitlesAvailable")
+        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)
+        _playerView?.selectPlaybackRate(playbackRate)
+      }
+      is PlaybackRateSelected -> {
+        map.putString("event", "playbackRateSelected")
+        map.putDouble("rate", event.rate)
+      }
+    }
+
+    _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() {
+    val map: WritableMap = Arguments.createMap()
+    map.putString("event", "enterFullScreen")
+    dispatchEvent("onPlayerEvent", map)
+  }
+
+  override fun onExitFullScreen() {
+    val map: WritableMap = Arguments.createMap()
+    map.putString("event", "exitFullScreen")
+    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/android/src/main/java/com/spallaplayer/SpallaPlayerViewManager.kt

@@ -1,5 +1,3 @@
-package com.spallaplayer
-
 import android.util.Log
 import android.view.View
 import com.facebook.react.bridge.Arguments
@@ -14,14 +12,16 @@ 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>(),
+class SpallaPlayerViewManager() : ViewGroupManager<SpallaPlayerView>(),
   SpallaPlayerListener, SpallaPlayerFullScreenListener {
   private var _playerView: SpallaPlayerView? = null
   private var _reactContext: ReactContext? = null
-  private var _container: SpallaPlayerContainerView? = null
+  //private var _container: SpallaPlayerContainerView? = null
 
   private var contentId: String? = null
   private var startTime: Double? = null
@@ -32,15 +32,13 @@ class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
 
   override fun getName() = "RNSpallaPlayer"
 
-  override fun createViewInstance(context: ThemedReactContext): SpallaPlayerContainerView {
+  override fun createViewInstance(context: ThemedReactContext): SpallaPlayerView {
     _reactContext = context
-    val container = SpallaPlayerContainerView(context)
-    _playerView = container.spallaPlayerView
+    val player = SpallaPlayerView(context)
+    _playerView = player
     _playerView?.registerPlayerListener(this)
     _playerView?.registerFullScreenListener(this)
-    this._container = container
-
-    return container
+    return player
   }
 
   override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
@@ -55,58 +53,58 @@ class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
     return eventMap
   }
 
-  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) {
+  override fun addView(parent: SpallaPlayerView, child: View, index: Int) {
     parent.addView(child, index)
   }
 
-  override fun removeViewAt(parent: SpallaPlayerContainerView, index: Int) {
+  override fun removeViewAt(parent: SpallaPlayerView, index: Int) {
     parent.removeViewAt(index)
   }
 
-  override fun getChildCount(parent: SpallaPlayerContainerView): Int {
+  override fun getChildCount(parent: SpallaPlayerView): Int {
     return parent.childCount
   }
 
-  override fun getChildAt(parent: SpallaPlayerContainerView, index: Int): View {
+  override fun getChildAt(parent: SpallaPlayerView, index: Int): View {
     return parent.getChildAt(index)
   }
 
   @ReactProp(name = "contentId")
-  fun setContentId(view: SpallaPlayerContainerView, contentId: String) {
+  fun setContentId(view: SpallaPlayerView, contentId: String) {
     this.contentId = contentId
     checkAndLoadPlayer(view)
   }
 
   @ReactProp(name = "muted")
-  fun setMuted(view: SpallaPlayerContainerView, muted: Boolean) {
+  fun setMuted(view: SpallaPlayerView, muted: Boolean) {
     _playerView?.setMuted(muted)
   }
 
   @ReactProp(name = "startTime")
-  fun setStartTime(view: SpallaPlayerContainerView, startTime: Double) {
+  fun setStartTime(view: SpallaPlayerView, startTime: Double) {
     this.startTime = startTime
     //checkAndLoadPlayer(view)
   }
 
   @ReactProp(name = "subtitle")
-  fun setSubtitle(view: SpallaPlayerContainerView, subtitle: String?) {
+  fun setSubtitle(view: SpallaPlayerView, subtitle: String?) {
     this.subtitle = subtitle
     _playerView?.selectSubtitle(subtitle)
   }
 
   @ReactProp(name = "playbackRate")
-  fun setPlaybackRate(view: SpallaPlayerContainerView, playbackRate: Double) {
+  fun setPlaybackRate(view: SpallaPlayerView, playbackRate: Double) {
     if (playbackRate > 0) {
       this.playbackRate = playbackRate
       _playerView?.selectPlaybackRate(playbackRate)
@@ -114,14 +112,14 @@ class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
   }
 
   @ReactProp(name = "hideUI")
-  fun setPlaybackRate(view: SpallaPlayerContainerView, hideUI: Boolean) {
+  fun setHideUI(view: SpallaPlayerView, hideUI: Boolean) {
     this.hideUI = hideUI
     checkAndLoadPlayer(view)
   }
 
-  private fun checkAndLoadPlayer(view: SpallaPlayerContainerView) {
+  private fun checkAndLoadPlayer(view: SpallaPlayerView) {
     if (contentId != null && startTime != null && hideUI != null) {
-      view.spallaPlayerView.load(contentId!!, true, startTime!!, subtitle, hideUI!!)
+      view.load(contentId!!, true, startTime!!, subtitle, hideUI!!)
     }
   }
 
@@ -196,7 +194,7 @@ class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
       }
 
     }
-    _container?.let { container ->
+    _playerView?.let { container ->
       _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
         container.id,
         "onPlayerEvent",
@@ -209,7 +207,7 @@ class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
     Log.v("SpallaPlayerViewManager", "onEnterFullScreen")
     val map: WritableMap = Arguments.createMap()
     map.putString("event", "enterFullScreen")
-    _container?.let { container ->
+    _playerView?.let { container ->
       _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
         container.id,
         "onPlayerEvent",
@@ -221,7 +219,7 @@ class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
   override fun onExitFullScreen() {
     val map: WritableMap = Arguments.createMap()
     map.putString("event", "exitFullScreen")
-    _container?.let { container ->
+    _playerView?.let { container ->
       _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
         container.id,
         "onPlayerEvent",

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