react-native-spalla-player 0.16.0 → 0.16.2

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

@@ -9,7 +9,10 @@ import com.spallaplayer.components.RNGoogleCastButtonManager
 
 class SpallaPlayerPackage : ReactPackage {
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(SpallaPlayerModule(reactContext))
+    return listOf(
+      SpallaPlayerModule(reactContext),
+      SpallaPlayerPipModule(reactContext)
+    )
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {

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

@@ -0,0 +1,32 @@
+package com.spallaplayer
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = SpallaPlayerPipModule.NAME)
+class SpallaPlayerPipModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+  companion object {
+    const val NAME = "SpallaPlayerPipModule"
+    private var activePlayerManager: RNSpallaPlayerManager? = null
+
+    fun registerPlayerManager(manager: RNSpallaPlayerManager) {
+      activePlayerManager = manager
+    }
+
+    fun unregisterPlayerManager(manager: RNSpallaPlayerManager) {
+      if (activePlayerManager == manager) {
+        activePlayerManager = null
+      }
+    }
+  }
+
+  override fun getName(): String = NAME
+
+  @ReactMethod
+  fun onUserLeaveHint() {
+    activePlayerManager?.triggerPipImmediate()
+  }
+}

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

@@ -3,7 +3,6 @@ package com.spallaplayer
 import android.util.Log
 import android.view.View
 import androidx.appcompat.app.AppCompatActivity
-import androidx.core.app.ComponentActivity
 import androidx.core.app.PictureInPictureModeChangedInfo
 import androidx.core.util.Consumer
 import com.facebook.react.bridge.Arguments
@@ -23,26 +22,30 @@ import java.util.Timer
 import java.util.TimerTask
 
 class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
-    SpallaPlayerListener, SpallaPlayerFullScreenListener, LifecycleEventListener {
-    private var _playerView: SpallaPlayerView? = null
-    private var _reactContext: ReactContext? = null
-    private var _container: SpallaPlayerContainerView? = 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 isPlaying: Boolean = false
-
-    override fun getName() = "RNSpallaPlayer"
+  SpallaPlayerListener, SpallaPlayerFullScreenListener {
+  private var _playerView: SpallaPlayerView? = null
+  private var _reactContext: ReactContext? = null
+  private var _container: SpallaPlayerContainerView? = 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 isPlaying: Boolean = false
+  private var pipTriggered: Boolean = false
+
+  override fun getName() = "RNSpallaPlayer"
 
   private val pipModeListener = Consumer<PictureInPictureModeChangedInfo> { info ->
     val map: WritableMap = Arguments.createMap()
     map.putString("event", if (info.isInPictureInPictureMode) "enterPiP" else "exitPiP")
     map.putBoolean("isInPictureInPictureMode", info.isInPictureInPictureMode)
 
+    // Reset the flag when PiP mode changes
+    pipTriggered = false
+
     _container?.let { container ->
       _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
         container.id,
@@ -53,15 +56,16 @@ class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
     _reactContext?.currentActivity?.let { activity ->
       _playerView?.onPictureInPictureModeChanged(activity, info.isInPictureInPictureMode)
     }
-
-
   }
 
   override fun createViewInstance(context: ThemedReactContext): SpallaPlayerContainerView {
     _reactContext = context
-    context.addLifecycleEventListener(this)
+    //context.addLifecycleEventListener(this)
+
+    // Register this manager for direct PiP access
+    SpallaPlayerPipModule.registerPlayerManager(this)
 
-    if(_reactContext?.currentActivity is AppCompatActivity) {
+    if (_reactContext?.currentActivity is AppCompatActivity) {
       val activity = _reactContext?.currentActivity as? AppCompatActivity
       activity?.addOnPictureInPictureModeChangedListener(pipModeListener)
     }
@@ -75,242 +79,241 @@ class RNSpallaPlayerManager() : ViewGroupManager<SpallaPlayerContainerView>(),
     return container
   }
 
-    override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
-        val eventMap = mutableMapOf<String, Any>()
+  override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
+    val eventMap = mutableMapOf<String, Any>()
 
-        eventMap["onPlayerEvent"] = mapOf(
-            "phasedRegistrationNames" to mapOf(
-                "bubbled" to "onPlayerEvent"
-            )
-        )
+    eventMap["onPlayerEvent"] = mapOf(
+      "phasedRegistrationNames" to mapOf(
+        "bubbled" to "onPlayerEvent"
+      )
+    )
 
-        return eventMap
-    }
+    return eventMap
+  }
 
-    override fun onDropViewInstance(view: SpallaPlayerContainerView) {
-        Log.v("RNSpallaPlayerManager", "onDropViewInstance")
-      _reactContext?.removeLifecycleEventListener(this)
+  override fun onDropViewInstance(view: SpallaPlayerContainerView) {
+    Log.v("RNSpallaPlayerManager", "onDropViewInstance")
+    //_reactContext?.removeLifecycleEventListener(this)
 
-      view.post {
-            try {
-                loadTimer?.cancel()
-                view.spallaPlayerView.onDestroy()
-            } catch (e: Exception) {
-                e.printStackTrace()
-            }
-        }
-        super.onDropViewInstance(view)
-    }
+    // Unregister this manager
+    SpallaPlayerPipModule.unregisterPlayerManager(this)
 
-    override fun addView(parent: SpallaPlayerContainerView, child: View, index: Int) {
-        parent.addView(child, index)
+    view.post {
+      try {
+        loadTimer?.cancel()
+        view.spallaPlayerView.onDestroy()
+      } catch (e: Exception) {
+        e.printStackTrace()
+      }
     }
+    super.onDropViewInstance(view)
+  }
 
-    override fun removeViewAt(parent: SpallaPlayerContainerView, index: Int) {
-        parent.removeViewAt(index)
-    }
+  override fun addView(parent: SpallaPlayerContainerView, child: View, index: Int) {
+    parent.addView(child, index)
+  }
 
-    override fun getChildCount(parent: SpallaPlayerContainerView): Int {
-        return parent.childCount
-    }
+  override fun removeViewAt(parent: SpallaPlayerContainerView, index: Int) {
+    parent.removeViewAt(index)
+  }
 
-    override fun getChildAt(parent: SpallaPlayerContainerView, index: Int): View {
-        return parent.getChildAt(index)
-    }
+  override fun getChildCount(parent: SpallaPlayerContainerView): Int {
+    return parent.childCount
+  }
 
-    @ReactProp(name = "contentId")
-    fun setContentId(view: SpallaPlayerContainerView, contentId: String) {
-        this.contentId = contentId
-        //delay initialization for a bit
-        loadTimer?.cancel()
-        loadTimer = Timer()
-        loadTimer?.schedule(object : TimerTask() {
-            override fun run() {
-                checkAndLoadPlayer(view)
-            }
-        }, 100)
-    }
+  override fun getChildAt(parent: SpallaPlayerContainerView, index: Int): View {
+    return parent.getChildAt(index)
+  }
 
-    @ReactProp(name = "muted")
-    fun setMuted(view: SpallaPlayerContainerView, muted: Boolean) {
-        _playerView?.setMuted(muted)
-    }
+  @ReactProp(name = "contentId")
+  fun setContentId(view: SpallaPlayerContainerView, contentId: String) {
+    this.contentId = contentId
+    //delay initialization for a bit
+    loadTimer?.cancel()
+    loadTimer = Timer()
+    loadTimer?.schedule(object : TimerTask() {
+      override fun run() {
+        checkAndLoadPlayer(view)
+      }
+    }, 100)
+  }
 
-    @ReactProp(name = "startTime")
-    fun setStartTime(view: SpallaPlayerContainerView, startTime: Double) {
-        this.startTime = startTime
-        //checkAndLoadPlayer(view)
-    }
+  @ReactProp(name = "muted")
+  fun setMuted(view: SpallaPlayerContainerView, muted: Boolean) {
+    _playerView?.setMuted(muted)
+  }
 
-    @ReactProp(name = "subtitle")
-    fun setSubtitle(view: SpallaPlayerContainerView, subtitle: String?) {
-        this.subtitle = subtitle
-        _playerView?.selectSubtitle(subtitle)
-    }
+  @ReactProp(name = "startTime")
+  fun setStartTime(view: SpallaPlayerContainerView, startTime: Double) {
+    this.startTime = startTime
+    //checkAndLoadPlayer(view)
+  }
 
-    @ReactProp(name = "playbackRate")
-    fun setPlaybackRate(view: SpallaPlayerContainerView, playbackRate: Double) {
-        if (playbackRate > 0) {
-            this.playbackRate = playbackRate
-            _playerView?.selectPlaybackRate(playbackRate)
-        }
-    }
+  @ReactProp(name = "subtitle")
+  fun setSubtitle(view: SpallaPlayerContainerView, subtitle: String?) {
+    this.subtitle = subtitle
+    _playerView?.selectSubtitle(subtitle)
+  }
 
-    @ReactProp(name = "hideUI")
-    fun setHideUI(view: SpallaPlayerContainerView, hideUI: Boolean) {
-        this.hideUI = hideUI
+  @ReactProp(name = "playbackRate")
+  fun setPlaybackRate(view: SpallaPlayerContainerView, playbackRate: Double) {
+    if (playbackRate > 0) {
+      this.playbackRate = playbackRate
+      _playerView?.selectPlaybackRate(playbackRate)
     }
+  }
 
-    private fun checkAndLoadPlayer(view: SpallaPlayerContainerView) {
-        if (contentId != null && startTime != null && hideUI != null) {
-            view.post {
-                view.spallaPlayerView.load(contentId!!, true, startTime!!, subtitle, hideUI!!)
-            }
-        }
+  @ReactProp(name = "hideUI")
+  fun setHideUI(view: SpallaPlayerContainerView, hideUI: Boolean) {
+    this.hideUI = hideUI
+  }
+
+  private fun checkAndLoadPlayer(view: SpallaPlayerContainerView) {
+    if (contentId != null && startTime != null && hideUI != null) {
+      view.post {
+        view.spallaPlayerView.load(contentId!!, true, startTime!!, subtitle, hideUI!!)
+      }
     }
+  }
 
-    override fun onEvent(event: SpallaPlayerEvent) {
-        val map: WritableMap = Arguments.createMap()
-
-        //Log.v("RNSpallaPlayerManager", "onEvent: $event")
-        when (event) {
-            is DurationUpdate -> {
-                map.putString("event", "durationUpdate")
-                map.putDouble("duration", event.duration)
-                requestLayout()
-            }
-
-            Ended -> {
-              map.putString("event", "ended")
-              isPlaying = false
-            }
-            is Error -> {
-                map.putString("event", "error")
-                map.putString("message", event.message)
-                isPlaying = false
-            }
-
-            Pause -> {
-              map.putString("event", "pause")
-              isPlaying = false
-            }
-            Play -> {
-              map.putString("event", "play")
-              isPlaying = false
-            }
-            Playing -> {
-              map.putString("event", "playing")
-              isPlaying = true
-            }
-            is TimeUpdate -> {
-                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)
-                }
-                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)
-                requestLayout()
-            }
-
-            is PlaybackRateSelected -> {
-                map.putString("event", "playbackRateSelected")
-                map.putDouble("rate", event.rate)
-                requestLayout()
-            }
+  override fun onEvent(event: SpallaPlayerEvent) {
+    val map: WritableMap = Arguments.createMap()
 
-        }
-        _container?.let { container ->
-            _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
-                container.id,
-                "onPlayerEvent",
-                map
-            )
-        }
-    }
+    //Log.v("RNSpallaPlayerManager", "onEvent: $event")
+    when (event) {
+      is DurationUpdate -> {
+        map.putString("event", "durationUpdate")
+        map.putDouble("duration", event.duration)
+        requestLayout()
+      }
 
-    override fun onEnterFullScreen() {
+      Ended -> {
+        map.putString("event", "ended")
+        isPlaying = false
+      }
 
-        val map: WritableMap = Arguments.createMap()
-        map.putString("event", "enterFullScreen")
-        _container?.let { container ->
-            _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
-                container.id,
-                "onPlayerEvent",
-                map
-            )
-        }
-    }
+      is Error -> {
+        map.putString("event", "error")
+        map.putString("message", event.message)
+        isPlaying = false
+      }
 
-    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
-            )
+      Pause -> {
+        map.putString("event", "pause")
+        isPlaying = false
+      }
+
+      Play -> {
+        map.putString("event", "play")
+        isPlaying = false
+      }
+
+      Playing -> {
+        map.putString("event", "playing")
+        isPlaying = true
+      }
+
+      is TimeUpdate -> {
+        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)
         }
+        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)
+        requestLayout()
+      }
+
+      is PlaybackRateSelected -> {
+        map.putString("event", "playbackRateSelected")
+        map.putDouble("rate", event.rate)
+        requestLayout()
+      }
+
+    }
+    _container?.let { container ->
+      _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
+        container.id,
+        "onPlayerEvent",
+        map
+      )
     }
+  }
 
-    fun requestLayout() {
-        _playerView?.post(measureAndLayout)
+  override fun onEnterFullScreen() {
+
+    val map: WritableMap = Arguments.createMap()
+    map.putString("event", "enterFullScreen")
+    _container?.let { container ->
+      _reactContext?.getJSModule(RCTEventEmitter::class.java)?.receiveEvent(
+        container.id,
+        "onPlayerEvent",
+        map
+      )
     }
+  }
 
-    private val measureAndLayout = Runnable {
-        _playerView?.let {
-            it.measure(
-                View.MeasureSpec.makeMeasureSpec(it.width, View.MeasureSpec.EXACTLY),
-                View.MeasureSpec.makeMeasureSpec(it.height, View.MeasureSpec.EXACTLY)
-            )
-            it.layout(
-                it.left,
-                it.top,
-                it.right,
-                it.bottom
-            )
-        }
+  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
+      )
     }
+  }
 
-  //lifecycle events
-  override fun onHostResume() {
-    _playerView?.let { player ->
+  fun requestLayout() {
+    _playerView?.post(measureAndLayout)
+  }
 
+  private val measureAndLayout = Runnable {
+    _playerView?.let {
+      it.measure(
+        View.MeasureSpec.makeMeasureSpec(it.width, View.MeasureSpec.EXACTLY),
+        View.MeasureSpec.makeMeasureSpec(it.height, View.MeasureSpec.EXACTLY)
+      )
+      it.layout(
+        it.left,
+        it.top,
+        it.right,
+        it.bottom
+      )
     }
   }
 
-  override fun onHostPause() {
+  fun triggerPipImmediate() {
+    if (pipTriggered) return
+
     _playerView?.let { player ->
       val activity = _reactContext?.currentActivity
       if (activity != null && isPlaying) {
+        pipTriggered = true
         player.enterPictureInPictureMode(activity = activity)
       }
     }
   }
 
-  override fun onHostDestroy() {
-    _reactContext?.removeLifecycleEventListener(this)
-  }
-
 }

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/withPipAndroid');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-spalla-player",
-  "version": "0.16.0",
+  "version": "0.16.2",
   "description": "Spalla SDK for RN",
   "source": "./src/index.tsx",
   "main": "./lib/commonjs/index.js",
@@ -15,7 +15,8 @@
         "types": "./lib/typescript/commonjs/src/index.d.ts",
         "default": "./lib/commonjs/index.js"
       }
-    }
+    },
+    "./app.plugin.js": "./app.plugin.js"
   },
   "files": [
     "src",
@@ -23,6 +24,8 @@
     "android",
     "ios",
     "cpp",
+    "plugin",
+    "app.plugin.js",
     "*.podspec",
     "!ios/build",
     "!android/build",
@@ -79,6 +82,7 @@
     "react": "18.3.1",
     "react-native": "0.75.4",
     "react-native-builder-bob": "^0.30.2",
+    "react-native-safe-area-context": "^5.4.1",
     "release-it": "^15.0.0",
     "turbo": "^1.10.7",
     "typescript": "^5.2.2"
@@ -88,7 +92,8 @@
   },
   "peerDependencies": {
     "react": "*",
-    "react-native": "*"
+    "react-native": "*",
+    "react-native-safe-area-context": "*"
   },
   "workspaces": [
     "example"
@@ -183,5 +188,11 @@
     "type": "view-legacy",
     "languages": "kotlin-swift",
     "version": "0.41.2"
+  },
+  "expo": {
+    "plugin": "./app.plugin.js"
+  },
+  "dependencies": {
+    "@expo/config-plugins": "^54.0.4"
   }
 }

package/plugin/index.js

@@ -0,0 +1,2 @@
+module.exports = require('./withPipAndroid');
+module.exports.default = module.exports;

package/plugin/withPipAndroid.js

@@ -0,0 +1,70 @@
+const {
+  withAndroidManifest,
+  withMainActivity,
+} = require('@expo/config-plugins');
+
+/**
+ * Adds supportsPictureInPicture="true" to MainActivity
+ */
+function withPipManifest(config) {
+  return withAndroidManifest(config, (config) => {
+    const manifest = config.modResults.manifest;
+    const app = manifest.application?.[0];
+
+    if (!app?.activity) return config;
+
+    const mainActivity = app.activity.find(
+      (activity) => activity.$?.['android:name'] === '.MainActivity'
+    );
+
+    if (!mainActivity) return config;
+
+    mainActivity.$['android:supportsPictureInPicture'] = 'true';
+    return config;
+  });
+}
+
+/**
+ * Injects onUserLeaveHint() into MainActivity.kt
+ */
+function withPipMainActivity(config) {
+  return withMainActivity(config, (config) => {
+    let contents = config.modResults.contents;
+
+    if (contents.includes('override fun onUserLeaveHint()')) {
+      return config;
+    }
+
+    // Add necessary imports
+    if (!contents.includes('import com.spallaplayer.SpallaPlayerPipModule')) {
+      contents = contents.replace(
+        /import\s+android\.os\.Bundle/,
+        `import android.os.Bundle
+import com.spallaplayer.SpallaPlayerPipModule`
+      );
+    }
+
+    const method = `
+  override fun onUserLeaveHint() {
+    super.onUserLeaveHint()
+    reactNativeHost.reactInstanceManager.currentReactContext?.let { context ->
+      context.getNativeModule(SpallaPlayerPipModule::class.java)?.onUserLeaveHint()
+    }
+  }
+`;
+
+    contents = contents.replace(
+      /class MainActivity[^{]*\{/,
+      (match) => `${match}${method}`
+    );
+
+    config.modResults.contents = contents;
+    return config;
+  });
+}
+
+module.exports = function withPipAndroid(config) {
+  config = withPipManifest(config);
+  config = withPipMainActivity(config);
+  return config;
+};