npm - react-native-spalla-player - Versions diffs - 1.0.0 → 1.0.2 - Mend

react-native-spalla-player 1.0.0 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/android/src/main/java/com/spallaplayer/SpallaPlayerModule.kt CHANGED Viewed

@@ -1,204 +1,107 @@
 package com.spallaplayer
-import com.facebook.react.bridge.LifecycleEventListener
+import android.util.Log
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.UIManager
-import com.facebook.react.uimanager.NativeViewHierarchyManager
 import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.UIManagerModule
 import com.facebook.react.uimanager.common.UIManagerType
 import com.spalla.sdk.android.core.SpallaSDK
 import com.spalla.sdk.android.core.player.view.SpallaPlayerView
-class SpallaPlayerModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext),
-  LifecycleEventListener {
-  private val _reactContext: ReactApplicationContext
+class SpallaPlayerModule(
+  val reactContext: ReactApplicationContext
+): ReactContextBaseJavaModule(reactContext) {
   companion object {
-    const val NAME = "RNSpallaPlayer"
-  }
-  init {
-    reactContext.addLifecycleEventListener(this)
-    _reactContext = reactContext
-  }
-  private fun isFabric(): Boolean {
-    val uiManager = UIManagerHelper.getUIManager(this._reactContext, UIManagerType.FABRIC)
-    // In Fabric, the UIManager is an instance of "FabricUIManager"
-    return uiManager?.javaClass?.simpleName == "FabricUIManager"
-  }
-  override fun getName(): String {
-    return "RNSpallaPlayer"
-  }
-  override fun onHostResume() {
+    val REACT_NAME: String = "SpallaPlayerModule"
   }
-  override fun onHostPause() {
+  override fun getName() = REACT_NAME
+  @ReactMethod
+  fun play(tag: Double) {
+    reactContext.runOnUiQueueThread {
+      val view = getSpallaPlayerView(tag)
+      view?.play()
+    }
   }
-  override fun onHostDestroy() {
+  @ReactMethod
+  fun pause(tag: Double) {
+    reactContext.runOnUiQueueThread {
+      val view = getSpallaPlayerView(tag)
+      view?.pause()
+    }
   }
   @ReactMethod
-  fun play(tag: Int) {
-    if (isFabric()) {
-      val uiManager = UIManagerHelper.getUIManager(_reactContext, UIManagerType.FABRIC)
-      if (uiManager is UIManager) {
-        uiManager.resolveView(tag)?.let { view ->
-          if (view is SpallaPlayerView) {
-            view.play()
-          } else {
-            throw ClassCastException(
-              "Cannot play: view with tag #$tag is not a SpallaPlayerView"
-            )
-          }
-        }
-      }
-    } else {
-      val uiManager: UIManagerModule? =
-        _reactContext.getNativeModule(UIManagerModule::class.java)
-      uiManager?.prependUIBlock { nativeViewHierarchyManager: NativeViewHierarchyManager ->
-        val playerView = nativeViewHierarchyManager.resolveView(tag)
-        if (playerView is SpallaPlayerView) {
-          playerView.play()
-        } else {
-          throw ClassCastException(
-            String.format(
-              "Cannot play: view with tag #%d is not a SpallaPlayerView",
-              tag
-            )
-          )
-        }
-      }
+  fun seekTo(tag: Double, time: Double) {
+    reactContext.runOnUiQueueThread {
+      val view = getSpallaPlayerView(tag)
+      view?.seekTo(time)
     }
   }
   @ReactMethod
-  fun pause(tag: Int) {
-    if (isFabric()) {
-      val uiManager = UIManagerHelper.getUIManager(_reactContext, UIManagerType.FABRIC)
-      if (uiManager is UIManager) {
-        uiManager.resolveView(tag)?.let { view ->
-          if (view is SpallaPlayerView) {
-            view.pause()
-          } else {
-            throw ClassCastException(
-              "Cannot pause: view with tag #$tag is not a SpallaPlayerView"
-            )
-          }
-        }
-      }
-    } else {
-      val uiManager: UIManagerModule? =
-        _reactContext.getNativeModule(UIManagerModule::class.java)
-      uiManager?.prependUIBlock { nativeViewHierarchyManager: NativeViewHierarchyManager ->
-        val playerView = nativeViewHierarchyManager.resolveView(tag)
-        if (playerView is SpallaPlayerView) {
-          playerView.pause()
-        } else {
-          throw ClassCastException(
-            String.format(
-              "Cannot play: view with tag #%d is not a SpallaPplayerView",
-              tag
-            )
-          )
-        }
-      }
+  fun selectSubtitle(tag: Double, subtitle: String?) {
+    reactContext.runOnUiQueueThread {
+      val view = getSpallaPlayerView(tag)
+      view?.selectSubtitle(subtitle)
     }
   }
   @ReactMethod
-  fun seekTo(tag: Int, time: Double) {
-    _reactContext.getNativeModule(UIManagerModule::class.java)!!
-      .prependUIBlock { nativeViewHierarchyManager: NativeViewHierarchyManager ->
-        val playerView = nativeViewHierarchyManager.resolveView(tag)
-        if (playerView is SpallaPlayerView) {
-          playerView.seekTo(time)
-        } else {
-          throw ClassCastException(
-            String.format(
-              "Cannot play: view with tag #%d is not a SpallaPplayerView",
-              tag
-            )
-          )
-        }
-      }
+  fun selectPlaybackRate(tag: Double, rate: Double) {
+    reactContext.runOnUiQueueThread {
+      val view = getSpallaPlayerView(tag)
+      view?.selectPlaybackRate(rate)
+    }
   }
   @ReactMethod
-  fun selectSubtitle(tag: Int, subtitle: String?) {
-    _reactContext.getNativeModule(UIManagerModule::class.java)!!
-      .prependUIBlock { nativeViewHierarchyManager: NativeViewHierarchyManager ->
-        val playerView = nativeViewHierarchyManager.resolveView(tag)
-        if (playerView is SpallaPlayerView) {
-          playerView.selectSubtitle(subtitle)
-        } else {
-          throw ClassCastException(
-            String.format(
-              "Cannot play: view with tag #%d is not a SpallaPplayerView",
-              tag
-            )
-          )
-        }
-      }
+  fun unmount(tag: Double) {
+    try {
+      pause(tag)
+    } catch (e: Exception) {
+      Log.e("SpallaPlayerModule", "Error in unmount method", e)
+    }
   }
   @ReactMethod
-  fun selectPlaybackRate(tag: Int, rate: Double) {
-    _reactContext.getNativeModule(UIManagerModule::class.java)!!
-      .prependUIBlock { nativeViewHierarchyManager: NativeViewHierarchyManager ->
-        val playerView = nativeViewHierarchyManager.resolveView(tag)
-        if (playerView is SpallaPlayerView) {
-          playerView.selectPlaybackRate(rate)
-        } else {
-          throw ClassCastException(
-            String.format(
-              "Cannot play: view with tag #%d is not a SpallaPplayerView",
-              tag
-            )
-          )
-        }
+  fun initialize(token: String?, applicationId: String?) {
+    try {
+      if (token.isNullOrBlank()) {
+        throw IllegalArgumentException("Token cannot be null or empty")
       }
+      SpallaSDK.initialize(reactContext, token)
+    } catch (e: Exception) {
+      Log.e("SpallaPlayerModule", "Failed to initialize SpallaSDK", e)
+    }
   }
-  @ReactMethod
-  fun unmount(tag: Int) {
-    if (isFabric()) {
-      val uiManager = UIManagerHelper.getUIManager(_reactContext, UIManagerType.FABRIC)
+  fun getSpallaPlayerView(tag: Double): SpallaPlayerView? {
+    try {
+      val uiManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
       if (uiManager is UIManager) {
-        uiManager.resolveView(tag)?.let { view ->
-          if (view is SpallaPlayerView) {
-            view.pause()
-          }
-        }
-      }
-    } else {
-      val uiManager: UIManagerModule? =
-        _reactContext.getNativeModule(UIManagerModule::class.java)
-      uiManager?.prependUIBlock { nativeViewHierarchyManager: NativeViewHierarchyManager ->
-        val playerView = nativeViewHierarchyManager.resolveView(tag)
-        if (playerView is SpallaPlayerView) {
-          playerView.pause()
+        val view = uiManager.resolveView(tag.toInt())
+        if (view is SpallaPlayerView) {
+          return view
+        } else if (view != null) {
+          Log.e(
+            "SpallaPlayerModule",
+            "Cannot play: view with tag #$tag is not a SpallaPlayerView"
+          )
+        } else {
+          Log.e("SpallaPlayerModule", "Cannot find view with tag #$tag")
         }
+      } else {
+        Log.e("SpallaPlayerModule", "UIManager is not available")
       }
+    } catch (e: Exception) {
+      Log.e("SpallaPlayerModule", "Error in play method", e)
     }
+    return null
   }
-  @ReactMethod
-  fun initialize(token: String, applicationId: String?) {
-    SpallaSDK.initialize(_reactContext, token)
-  }
 }

package/android/src/main/java/com/spallaplayer/SpallaPlayerPackage.kt CHANGED Viewed

@@ -1,30 +1,44 @@
 package com.spallaplayer
-import com.facebook.react.ReactPackage
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.ModuleSpec
 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 com.spallaplayer.components.RNGoogleCastButtonManager
-import java.util.ArrayList
-class SpallaPlayerViewPackage : ReactPackage {
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    val viewManagers: MutableList<ViewManager<*, *>> = ArrayList()
-    viewManagers.add(SpallaPlayerViewManager())
-    viewManagers.add(RNGoogleCastButtonManager())
-    return viewManagers
-  }
+class SpallaPlayerViewPackage : BaseReactPackage() {
-  @Deprecated("Migrate to [BaseReactPackage] and implement [getModule] instead.")
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(SpallaPlayerModuleFabric(reactContext))
-  }
+  override fun getViewManagers(
+    reactContext: ReactApplicationContext
+  ): List<ModuleSpec> =
+    listOf(
+      ModuleSpec.viewManagerSpec {
+        SpallaPlayerViewManager()
+      },
+      ModuleSpec.viewManagerSpec {
+        RNGoogleCastButtonManager()
+      }
+    )
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider {
+      mapOf(
+        SpallaPlayerModule.REACT_NAME to ReactModuleInfo(
+          SpallaPlayerModule.REACT_NAME,
+          className = SpallaPlayerModule::class.java.name,
+          canOverrideExistingModule = false,
+          needsEagerInit = false,
+          isCxxModule = false,
+          isTurboModule = false
+        )
+      )
+    }
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
     return when (name) {
-      SpallaPlayerModule.NAME -> SpallaPlayerModuleFabric(reactContext)
+      SpallaPlayerModule.REACT_NAME -> SpallaPlayerModule(reactContext)
       else -> null
     }
   }

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

@@ -1,61 +1,92 @@
+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.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
+// 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): SpallaPlayerView {
     _reactContext = context
+    //val container = SpallaPlayerContainerView(context)
     val player = SpallaPlayerView(context)
-    _playerView = player
-    _playerView?.registerPlayerListener(this)
-    _playerView?.registerFullScreenListener(this)
-    return player
-  }
-  override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
-    val eventMap = mutableMapOf<String, Any>()
+    // 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)
+        }
+      }
-    eventMap["onPlayerEvent"] = mapOf(
-      "phasedRegistrationNames" to mapOf(
-        "bubbled" to "onPlayerEvent"
-      )
-    )
+      override fun onViewDetachedFromWindow(view: View) {
+        _playerView?.pause()
+      }
+    })
-    return eventMap
+    //this._container = container
+    //return container
+    return player
   }
   override fun onDropViewInstance(view: SpallaPlayerView) {
     Log.v("RNSpallaPlayerManager", "onDropViewInstance")
     try {
       view.onDestroy()
     } catch (e: Exception) {
@@ -64,83 +95,119 @@ class SpallaPlayerViewManager() : ViewGroupManager<SpallaPlayerView>(),
     super.onDropViewInstance(view)
   }
-  override fun addView(parent: SpallaPlayerView, child: View, index: Int) {
-    parent.addView(child, index)
-  }
-  override fun removeViewAt(parent: SpallaPlayerView, index: Int) {
-    parent.removeViewAt(index)
-  }
-  override fun getChildCount(parent: SpallaPlayerView): Int {
-    return parent.childCount
-  }
-  override fun getChildAt(parent: SpallaPlayerView, index: Int): View {
-    return parent.getChildAt(index)
-  }
+  // --- Prop Setters ---
   @ReactProp(name = "contentId")
-  fun setContentId(view: SpallaPlayerView, 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: SpallaPlayerView, muted: Boolean) {
-    _playerView?.setMuted(muted)
+  override fun setMuted(view: SpallaPlayerView, value: Boolean) {
+    _playerView?.setMuted(value)
   }
   @ReactProp(name = "startTime")
-  fun setStartTime(view: SpallaPlayerView, startTime: Double) {
-    this.startTime = startTime
+  override fun setStartTime(view: SpallaPlayerView, value: Double) {
+    this.startTime = value
     //checkAndLoadPlayer(view)
   }
   @ReactProp(name = "subtitle")
-  fun setSubtitle(view: SpallaPlayerView, subtitle: String?) {
-    this.subtitle = subtitle
+  override fun setSubtitle(view: SpallaPlayerView, value: String?) {
+    this.subtitle = value
     _playerView?.selectSubtitle(subtitle)
   }
   @ReactProp(name = "playbackRate")
-  fun setPlaybackRate(view: SpallaPlayerView, 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 setHideUI(view: SpallaPlayerView, hideUI: Boolean) {
-    this.hideUI = hideUI
-    checkAndLoadPlayer(view)
+  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) {
-    if (contentId != null && startTime != null && hideUI != null) {
-      view.load(contentId!!, true, startTime!!, subtitle, hideUI!!)
+    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)
     }
   }
-  private fun startLoadTimer(view: SpallaPlayerView) {
-    // Cancel any existing timer
-    loadTimer?.cancel()
+  // --- Command Handling ---
+  override fun receiveCommand(
+    root: SpallaPlayerView,
+    commandId: String,
+    args: ReadableArray?
+  ) {
+    mDelegate.receiveCommand(root, commandId, args)
+  }
-    // 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!!)
-      }
-    }, 300) // Delay of 200ms to allow all properties to be set
+  // --- 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) {
@@ -148,13 +215,11 @@ class SpallaPlayerViewManager() : ViewGroupManager<SpallaPlayerView>(),
         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")
@@ -162,69 +227,63 @@ class SpallaPlayerViewManager() : ViewGroupManager<SpallaPlayerView>(),
         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)
       }
     }
-    _playerView?.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")
-    _playerView?.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")
-    _playerView?.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/package.json CHANGED Viewed

@@ -1,12 +1,13 @@
 {
   "name": "react-native-spalla-player",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Spalla Player for React Native",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
   "exports": {
     ".": {
       "source": "./src/index.tsx",
+      "import": "./lib/module/index.js",
       "types": "./lib/typescript/src/index.d.ts",
       "default": "./lib/module/index.js"
     },

package/android/src/main/java/com/spallaplayer/SpallaPlayerModule.fabric.kt DELETED Viewed

@@ -1,103 +0,0 @@
-package com.spallaplayer
-import android.util.Log
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.UIManager
-import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.common.UIManagerType
-import com.spalla.sdk.android.core.SpallaSDK
-import com.spalla.sdk.android.core.player.view.SpallaPlayerView
-class SpallaPlayerModuleFabric(
-  val reactContext: ReactApplicationContext
-): ReactContextBaseJavaModule(reactContext) {
-  override fun getName() = "SpallaPlayerModule"
-  @ReactMethod
-  fun play(tag: Double) {
-    reactContext.runOnUiQueueThread {
-      val view = getSpallaPlayerView(tag)
-      view?.play()
-    }
-  }
-  @ReactMethod
-  fun pause(tag: Double) {
-    reactContext.runOnUiQueueThread {
-      val view = getSpallaPlayerView(tag)
-      view?.pause()
-    }
-  }
-  @ReactMethod
-  fun seekTo(tag: Double, time: Double) {
-    reactContext.runOnUiQueueThread {
-      val view = getSpallaPlayerView(tag)
-      view?.seekTo(time)
-    }
-  }
-  @ReactMethod
-  fun selectSubtitle(tag: Double, subtitle: String?) {
-    reactContext.runOnUiQueueThread {
-      val view = getSpallaPlayerView(tag)
-      view?.selectSubtitle(subtitle)
-    }
-  }
-  @ReactMethod
-  fun selectPlaybackRate(tag: Double, rate: Double) {
-    reactContext.runOnUiQueueThread {
-      val view = getSpallaPlayerView(tag)
-      view?.selectPlaybackRate(rate)
-    }
-  }
-  @ReactMethod
-  fun unmount(tag: Double) {
-    try {
-      pause(tag)
-    } catch (e: Exception) {
-      Log.e("SpallaPlayerModule", "Error in unmount method", e)
-    }
-  }
-  @ReactMethod
-  fun initialize(token: String?, applicationId: String?) {
-    try {
-      if (token.isNullOrBlank()) {
-        throw IllegalArgumentException("Token cannot be null or empty")
-      }
-      SpallaSDK.initialize(reactContext, token)
-    } catch (e: Exception) {
-      Log.e("SpallaPlayerModule", "Failed to initialize SpallaSDK", e)
-    }
-  }
-  fun getSpallaPlayerView(tag: Double): SpallaPlayerView? {
-    try {
-      val uiManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
-      if (uiManager is UIManager) {
-        val view = uiManager.resolveView(tag.toInt())
-        if (view is SpallaPlayerView) {
-          return view
-        } else if (view != null) {
-          Log.e(
-            "SpallaPlayerModule",
-            "Cannot play: view with tag #$tag is not a SpallaPlayerView"
-          )
-        } else {
-          Log.e("SpallaPlayerModule", "Cannot find view with tag #$tag")
-        }
-      } else {
-        Log.e("SpallaPlayerModule", "UIManager is not available")
-      }
-    } catch (e: Exception) {
-      Log.e("SpallaPlayerModule", "Error in play method", e)
-    }
-    return null
-  }
-}

package/android/src/main/java/com/spallaplayer/SpallaPlayerView.kt DELETED Viewed

@@ -1,15 +0,0 @@
-package com.spallaplayer
-import android.content.Context
-import android.util.AttributeSet
-import android.view.View
-class SpallaPlayerView : View {
-  constructor(context: Context?) : super(context)
-  constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
-  constructor(context: Context?, attrs: AttributeSet?, defStyleAttr: Int) : super(
-    context,
-    attrs,
-    defStyleAttr
-  )
-}

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

@@ -1,289 +0,0 @@
-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)
-          )
-        }
-      }
-    }
-  }
-}