Feature/mediacontrol api

CHANGELOG.md

@@ -7,8 +7,14 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+### Added
+
+- Added the `MediaControl` API for controlling the media session and lock screen controls with custom handlers.
+
 ### Changed
 
+- Deprecated `MediaControlConfiguration.convertSkipToSeek` in favor of custom `MediaControl` handlers.
+- Deprecated `MediaControlConfiguration.seekToLiveOnResume` in favor of custom `MediaControl` handlers.
 - Upgraded example app to React-Native v0.84.1.
 
 ## [10.13.0] - 26-03-27

README.md

@@ -186,6 +186,7 @@ This section gives an overview of features, limitations and known issues:
 - [Digital Rights Management (DRM)](./doc/drm.md)
 - [Expo](./doc/expo.md)
 - [Fullscreen presentation](./doc/fullscreen.md)
+- [Media Control](./doc/mediacontrol.md)
 - [Media Caching](./doc/media-caching.md)
 - [Migrating to THEOplayer 9.x](./doc/migrating-to-react-native-theoplayer-9.md)
 - [Migrating to THEOplayer 10.x🔥](./doc/migrating-to-react-native-theoplayer-10.md)

android/src/main/java/com/theoplayer/ReactTHEOplayerContext.kt

@@ -34,40 +34,24 @@ import com.theoplayer.android.api.millicast.MillicastIntegrationFactory
 import com.theoplayer.android.api.player.Player
 import com.theoplayer.android.api.player.RenderingTarget
 import com.theoplayer.android.connector.mediasession.MediaSessionConnector
-import com.theoplayer.android.connector.mediasession.MediaSessionListener
 import com.theoplayer.audio.AudioBecomingNoisyManager
 import com.theoplayer.audio.AudioFocusManager
 import com.theoplayer.audio.BackgroundAudioConfig
+import com.theoplayer.media.MediaControlProxy
 import com.theoplayer.media.MediaPlaybackService
-import com.theoplayer.media.MediaQueueNavigator
 import com.theoplayer.media.MediaSessionConfig
 import java.util.concurrent.atomic.AtomicBoolean
 
 private const val TAG = "ReactTHEOplayerContext"
 
-private const val ALLOWED_PLAYBACK_ACTIONS = (
-  PlaybackStateCompat.ACTION_PLAY_PAUSE or
-    PlaybackStateCompat.ACTION_PLAY or
-    PlaybackStateCompat.ACTION_PAUSE or
-    PlaybackStateCompat.ACTION_SEEK_TO or
-    PlaybackStateCompat.ACTION_FAST_FORWARD or
-    PlaybackStateCompat.ACTION_REWIND or
-    PlaybackStateCompat.ACTION_SET_PLAYBACK_SPEED)
-
-private const val ALLOWED_PLAY_PAUSE_ACTIONS = (
-  PlaybackStateCompat.ACTION_PLAY_PAUSE or
-    PlaybackStateCompat.ACTION_PLAY or
-    PlaybackStateCompat.ACTION_PAUSE)
-
-@Suppress("SimplifyBooleanWithConstants", "KotlinConstantConditions")
 class ReactTHEOplayerContext private constructor(
   private val reactContext: ThemedReactContext,
   private val configAdapter: PlayerConfigAdapter
 ) {
   private val mainHandler = Handler(Looper.getMainLooper())
   private var isBound = AtomicBoolean()
   private var binder: MediaPlaybackService.MediaPlaybackBinder? = null
-  private var mediaSessionConnector: MediaSessionConnector? = null
+
   private var audioBecomingNoisyManager = AudioBecomingNoisyManager(reactContext) {
     // Audio is about to become 'noisy' due to a change in audio outputs: pause the player
     player.pause()
@@ -80,11 +64,14 @@ class ReactTHEOplayerContext private constructor(
       field = value
     }
 
-  var mediaSessionConfig: MediaSessionConfig = configAdapter.mediaSessionConfig()
+  private var mediaSessionConnector: MediaSessionConnector? = null
+
+  private var mediaSessionConfig: MediaSessionConfig = configAdapter.mediaSessionConfig()
     set(value) {
       applyMediaSessionConfig(mediaSessionConnector, value)
       field = value
     }
+  var mediaControlProxy: MediaControlProxy = MediaControlProxy()
 
   lateinit var playerView: THEOplayerView
 
@@ -140,19 +127,6 @@ class ReactTHEOplayerContext private constructor(
     }
   }
 
-  private val mediaSessionListener = object : MediaSessionListener() {
-    override fun onStop() {
-      binder?.stopForegroundService()
-    }
-
-    override fun onPlay() {
-      // Optionally seek to live, if configured.
-      if (mediaSessionConfig.seekToLiveOnResume && player.duration.isInfinite()) {
-        player.currentTime = Double.POSITIVE_INFINITY
-      }
-    }
-  }
-
   private fun applyBackgroundPlaybackConfig(
     config: BackgroundAudioConfig,
     prevConfig: BackgroundAudioConfig?
@@ -184,21 +158,6 @@ class ReactTHEOplayerContext private constructor(
     }
   }
 
-  private fun applyAllowedMediaControls() {
-    // Reduce allowed set of remote control playback actions for ads & live streams.
-    val isLive = player.duration.isInfinite()
-    val isInAd = player.ads.isPlaying
-    mediaSessionConnector?.enabledPlaybackActions = when {
-      // Allow trick-play for live events if configured
-      isLive && mediaSessionConfig.allowLivePlayPause -> ALLOWED_PLAY_PAUSE_ACTIONS
-      isLive && !mediaSessionConfig.allowLivePlayPause -> 0
-      // Do not allow playback actions during ad play-out
-      isInAd -> 0
-
-      else -> ALLOWED_PLAYBACK_ACTIONS
-    }
-  }
-
   private fun bindMediaPlaybackService() {
     // Bind to an existing service, if available
     // A bound service runs only as long as another application component is bound to it.
@@ -279,15 +238,8 @@ class ReactTHEOplayerContext private constructor(
     // Destroy any existent media session
     mediaSessionConnector?.destroy()
 
-    // Create and initialize the media session
-    val mediaSession = MediaSessionCompat(reactContext, TAG)
-
-    // Do not let MediaButtons restart the player when media session is not active.
-    // https://developer.android.com/media/legacy/media-buttons#restarting-inactive-mediasessions
-    mediaSession.setMediaButtonReceiver(null)
-
     // Create a MediaSessionConnector and attach the THEOplayer instance.
-    mediaSessionConnector = MediaSessionConnector(mediaSession).also {
+    mediaSessionConnector = MediaSessionConnector(MediaSessionCompat(reactContext, TAG)).also {
       applyMediaSessionConfig(it, mediaSessionConfig)
     }
   }
@@ -297,30 +249,26 @@ class ReactTHEOplayerContext private constructor(
     config: MediaSessionConfig
   ) {
     connector?.apply {
+      mediaControlProxy.detach()
+
       debug = BuildConfig.LOG_MEDIASESSION_EVENTS
-      removeListener(mediaSessionListener)
 
       player = this@ReactTHEOplayerContext.player
 
       // Set mediaSession active and ready to receive media button events, but not if the player
       // is backgrounded.
       setActive(!isHostPaused && BuildConfig.EXTENSION_MEDIASESSION && config.mediaSessionEnabled)
 
-      skipForwardInterval = config.skipForwardInterval
-      skipBackwardsInterval = config.skipBackwardInterval
-
       // Pass metadata from source description
       setMediaSessionMetadata(player?.source)
 
       // Do not let MediaButtons restart the player when media session is not active.
       // https://developer.android.com/media/legacy/media-buttons#restarting-inactive-mediasessions
-      this.mediaSession.setMediaButtonReceiver(null)
+      mediaSession.setMediaButtonReceiver(null)
 
-      // Install a queue navigator, but only if we want to handle skip buttons.
-      if (mediaSessionConfig.convertSkipToSeek) {
-        queueNavigator = MediaQueueNavigator(mediaSessionConfig)
-      }
-      addListener(mediaSessionListener)
+      // Route all media control actions through the MediaControlProxy, which will decide whether to
+      // invoke the action or not.
+      mediaControlProxy.attach(player, this, binder, config)
     }
   }
 
@@ -390,27 +338,23 @@ class ReactTHEOplayerContext private constructor(
   private val onSourceChange = EventListener<SourceChangeEvent> {
     mediaSessionConnector?.setMediaSessionMetadata(player.source)
     binder?.updateNotification()
-    applyAllowedMediaControls()
   }
 
   private val onLoadedMetadata = EventListener<LoadedMetadataEvent> {
     binder?.updateNotification()
-    applyAllowedMediaControls()
   }
 
   private val onPlay = EventListener<PlayEvent> {
     if (BuildConfig.USE_PLAYBACK_SERVICE && isBackgroundAudioEnabled) {
       bindMediaPlaybackService()
     }
     binder?.updateNotification(PlaybackStateCompat.STATE_PLAYING)
-    applyAllowedMediaControls()
     audioBecomingNoisyManager.setEnabled(true)
     audioFocusManager?.requestAudioFocus()
   }
 
   private val onPause = EventListener<PauseEvent> {
     binder?.updateNotification(PlaybackStateCompat.STATE_PAUSED)
-    applyAllowedMediaControls()
     audioBecomingNoisyManager.setEnabled(false)
   }
 

android/src/main/java/com/theoplayer/ReactTHEOplayerPackage.kt

@@ -10,6 +10,7 @@ import com.theoplayer.cache.CacheModule
 import com.theoplayer.drm.ContentProtectionModule
 import com.theoplayer.cast.CastModule
 import com.theoplayer.broadcast.EventBroadcastModule
+import com.theoplayer.media.MediaControlModule
 import com.theoplayer.player.PlayerModule
 import com.theoplayer.theolive.THEOliveModule
 import com.theoplayer.theoads.THEOadsModule
@@ -26,6 +27,7 @@ class ReactTHEOplayerPackage : BaseReactPackage() {
       EventBroadcastModule.NAME -> EventBroadcastModule(reactContext)
       THEOliveModule.NAME -> THEOliveModule(reactContext)
       THEOadsModule.NAME -> THEOadsModule(reactContext)
+      MediaControlModule.NAME -> MediaControlModule(reactContext)
       else -> null
     }
   }
@@ -45,6 +47,7 @@ class ReactTHEOplayerPackage : BaseReactPackage() {
         EventBroadcastModule.NAME to EventBroadcastModule.INFO,
         THEOliveModule.NAME to THEOliveModule.INFO,
         THEOadsModule.NAME to THEOadsModule.INFO,
+        MediaControlModule.NAME to MediaControlModule.INFO,
       )
     }
   }

android/src/main/java/com/theoplayer/media/MediaControlModule.kt

@@ -0,0 +1,79 @@
+package com.theoplayer.media
+
+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
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.theoplayer.ReactTHEOplayerView
+import com.theoplayer.util.ViewResolver
+
+private const val PROP_TAG = "tag"
+private const val PROP_ACTION = "action"
+
+enum class MediaControlAction(val propName: String) {
+  PLAY("play"),
+  PAUSE("pause"),
+  SKIP_TO_NEXT("skipToNext"),
+  SKIP_TO_PREVIOUS("skipToPrevious");
+
+  companion object {
+    private val map = entries.associateBy(MediaControlAction::propName)
+    fun fromPropName(propName: String): MediaControlAction? = map[propName]
+  }
+}
+
+@Suppress("unused")
+@ReactModule(name = MediaControlModule.NAME)
+class MediaControlModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+  companion object {
+    const val NAME = "THEORCTMediaControlModule"
+    val INFO = ReactModuleInfo(
+      name = NAME,
+      className = NAME,
+      canOverrideExistingModule = false,
+      needsEagerInit = false,
+      isCxxModule = false,
+      isTurboModule = false,
+    )
+    const val MEDIA_CONTROL_EVENT = "MediaControlEvent"
+  }
+
+  private val viewResolver: ViewResolver = ViewResolver(context)
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun getConstants(): Map<String, Any> {
+    return mapOf("MEDIA_CONTROL_EVENT" to MEDIA_CONTROL_EVENT)
+  }
+
+  /**
+   * Register a handler for a media control action. Instead of storing the Callback, use event emitter for multiple notifications.
+   * When the action occurs, call sendEvent to notify JS listeners.
+   */
+  @ReactMethod
+  fun setHandler(tag: Int, action: String) {
+    val mediaControlAction = MediaControlAction.fromPropName(action)
+    if (mediaControlAction != null) {
+      viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
+        view?.playerContext?.mediaControlProxy?.setHandler(mediaControlAction, {
+          sendEvent(MEDIA_CONTROL_EVENT, Arguments.createMap().apply {
+            putInt(PROP_TAG, tag)
+            putString(PROP_ACTION, action)
+          })
+        })
+      }
+    }
+  }
+
+  private fun sendEvent(eventName: String, params: WritableMap?) {
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, params)
+  }
+}