react-native-theoplayer 1.8.2 → 2.0.0

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

@@ -0,0 +1,301 @@
+package com.theoplayer
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.content.pm.PackageManager
+import android.os.Handler
+import android.os.IBinder
+import android.os.Looper
+import android.support.v4.media.session.MediaSessionCompat
+import android.support.v4.media.session.PlaybackStateCompat
+import com.facebook.react.uimanager.ThemedReactContext
+import com.google.ads.interactivemedia.v3.api.AdsRenderingSettings
+import com.google.ads.interactivemedia.v3.api.ImaSdkFactory
+import com.theoplayer.android.api.THEOplayerConfig
+import com.theoplayer.android.api.THEOplayerView
+import com.theoplayer.android.api.ads.dai.GoogleDaiIntegration
+import com.theoplayer.android.api.ads.dai.GoogleDaiIntegrationFactory
+import com.theoplayer.android.api.ads.ima.GoogleImaIntegration
+import com.theoplayer.android.api.ads.ima.GoogleImaIntegrationFactory
+import com.theoplayer.android.api.cast.CastIntegration
+import com.theoplayer.android.api.cast.CastIntegrationFactory
+import com.theoplayer.android.api.event.EventListener
+import com.theoplayer.android.api.event.player.*
+import com.theoplayer.android.api.player.Player
+import com.theoplayer.android.connector.mediasession.MediaSessionConnector
+import com.theoplayer.audio.BackgroundAudioConfig
+import com.theoplayer.audio.MediaPlaybackService
+import java.util.concurrent.atomic.AtomicBoolean
+
+private const val TAG = "ReactTHEOplayerContext"
+
+class ReactTHEOplayerContext private constructor(
+  private val reactContext: ThemedReactContext
+) {
+  private val mainHandler = Handler(Looper.getMainLooper())
+  private var isBound = AtomicBoolean()
+  private var binder: MediaPlaybackService.MediaPlaybackBinder? = null
+  private var mediaSessionConnector: MediaSessionConnector? = null
+
+  var backgroundAudioConfig: BackgroundAudioConfig = BackgroundAudioConfig(
+    enabled = false,
+    mediaPlaybackServiceEnabled = true
+  )
+    set(value) {
+      applyBackgroundPlaybackConfig(value)
+      field = value
+    }
+
+  lateinit var playerView: THEOplayerView
+
+  val player: Player
+    get() = playerView.player
+
+  var daiIntegration: GoogleDaiIntegration? = null
+  var imaIntegration: GoogleImaIntegration? = null
+  var castIntegration: CastIntegration? = null
+
+  private val isBackgroundAudioEnabled: Boolean
+    get() = backgroundAudioConfig.enabled && backgroundAudioConfig.mediaPlaybackServiceEnabled
+
+  companion object {
+    private var mediaControlledInstance: ReactTHEOplayerContext? = null
+
+    fun create(reactContext: ThemedReactContext, playerConfig: THEOplayerConfig): ReactTHEOplayerContext {
+      return ReactTHEOplayerContext(reactContext).apply {
+        initializePlayerView(playerConfig)
+      }
+    }
+  }
+
+  private val connection = object : ServiceConnection {
+    override fun onServiceConnected(className: ComponentName, service: IBinder) {
+      binder = service as MediaPlaybackService.MediaPlaybackBinder
+
+      // Get media session
+      mediaSessionConnector = binder?.mediaSessionConnector
+      mediaSessionConnector?.player = player
+      mediaSessionConnector?.setMediaSessionMetadata(player.source)
+
+      // Pass player context
+      binder?.setPlayerContext(this@ReactTHEOplayerContext)
+
+      // Apply background audio config
+      binder?.setEnablePlaybackControls(backgroundAudioConfig.enabled)
+    }
+
+    override fun onServiceDisconnected(className: ComponentName?) {
+      binder = null
+    }
+  }
+
+  private fun applyBackgroundPlaybackConfig(config: BackgroundAudioConfig) {
+    if (BuildConfig.USE_PLAYBACK_SERVICE) {
+      reactContext.applicationContext.packageManager.setComponentEnabledSetting(
+        ComponentName(reactContext.applicationContext, MediaPlaybackService::class.java),
+        if (config.mediaPlaybackServiceEnabled) PackageManager.COMPONENT_ENABLED_STATE_ENABLED
+        else PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
+        PackageManager.DONT_KILL_APP
+      )
+    }
+
+    binder?.setEnablePlaybackControls(config.enabled)
+  }
+
+  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.
+    // Multiple components can bind to the service at once, but when all of them unbind, the
+    // service is destroyed.
+    if (!isBound.get()) {
+      isBound.set(
+        reactContext.bindService(
+          Intent(reactContext, MediaPlaybackService::class.java),
+          connection,
+          Context.BIND_AUTO_CREATE
+        )
+      )
+    }
+  }
+
+  private fun unbindMediaPlaybackService() {
+    // This client is done interacting with the service: unbind.
+    // When there are no clients bound to the service, the system destroys the service.
+    if (binder?.isBinderAlive == true) {
+      if (isBound.getAndSet(false)) {
+        reactContext.unbindService(connection)
+      }
+    }
+  }
+
+  private fun initializePlayerView(playerConfig: THEOplayerConfig) {
+    playerView = object : THEOplayerView(reactContext.currentActivity!!, playerConfig) {
+      private fun measureAndLayout() {
+        measure(
+          MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY),
+          MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY)
+        )
+        layout(left, top, right, bottom)
+      }
+
+      override fun requestLayout() {
+        super.requestLayout()
+
+        // schedule a forced layout
+        mainHandler.post { measureAndLayout() }
+      }
+    }
+
+    // By default, the screen should remain on.
+    playerView.keepScreenOn = true
+
+    addIntegrations(playerConfig)
+    addListeners()
+
+    if (mediaControlledInstance == null) {
+      mediaControlledInstance = this
+      if (!BuildConfig.USE_PLAYBACK_SERVICE) {
+        initDefaultMediaSession()
+      }
+    }
+
+    // Apply initial backgroundPlayback config
+    applyBackgroundPlaybackConfig(backgroundAudioConfig)
+  }
+
+  private fun initDefaultMediaSession() {
+    // 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 the app is not visible
+    mediaSession.setMediaButtonReceiver(null)
+
+    // Create a MediaSessionConnector and attach the THEOplayer instance.
+    mediaSessionConnector = MediaSessionConnector(mediaSession).apply {
+      debug = BuildConfig.LOG_MEDIASESSION_EVENTS
+      player = this@ReactTHEOplayerContext.player
+
+      // Set mediaSession active
+      setActive(true)
+    }
+  }
+
+  private fun addIntegrations(playerConfig: THEOplayerConfig) {
+    try {
+      if (BuildConfig.EXTENSION_GOOGLE_IMA) {
+        imaIntegration = GoogleImaIntegrationFactory.createGoogleImaIntegration(playerView).apply {
+          setAdsRenderingSettings(createRenderSettings(playerConfig))
+          playerView.player.addIntegration(this)
+        }
+      }
+    } catch (ignore: Exception) {
+    }
+    try {
+      if (BuildConfig.EXTENSION_GOOGLE_DAI) {
+        daiIntegration = GoogleDaiIntegrationFactory.createGoogleDaiIntegration(playerView).apply {
+          setAdsRenderingSettings(createRenderSettings(playerConfig))
+          playerView.player.addIntegration(this)
+        }
+      }
+    } catch (ignore: Exception) {
+    }
+    try {
+      if (BuildConfig.EXTENSION_CAST) {
+        castIntegration = CastIntegrationFactory.createCastIntegration(playerView).apply {
+          playerView.player.addIntegration(this)
+        }
+      }
+      // Add other future integrations here.
+    } catch (ignore: Exception) {
+    }
+  }
+
+  private val onSourceChange = EventListener<SourceChangeEvent> {
+    mediaSessionConnector?.setMediaSessionMetadata(player.source)
+    binder?.updateNotification()
+  }
+
+  private val onLoadedMetadata = EventListener<LoadedMetadataEvent> {
+    binder?.updateNotification()
+  }
+
+  private val onPlay = EventListener<PlayEvent> {
+    if (BuildConfig.USE_PLAYBACK_SERVICE) {
+      bindMediaPlaybackService()
+    }
+    binder?.updateNotification(PlaybackStateCompat.STATE_PLAYING)
+  }
+
+  private val onPause = EventListener<PauseEvent> {
+    binder?.updateNotification(PlaybackStateCompat.STATE_PAUSED)
+  }
+
+  private fun addListeners() {
+    player.apply {
+      addEventListener(PlayerEventTypes.SOURCECHANGE, onSourceChange)
+      addEventListener(PlayerEventTypes.LOADEDMETADATA, onLoadedMetadata)
+      addEventListener(PlayerEventTypes.PAUSE, onPause)
+      addEventListener(PlayerEventTypes.PLAY, onPlay)
+    }
+  }
+
+  private fun removeListeners() {
+    player.apply {
+      removeEventListener(PlayerEventTypes.SOURCECHANGE, onSourceChange)
+      removeEventListener(PlayerEventTypes.LOADEDMETADATA, onLoadedMetadata)
+      removeEventListener(PlayerEventTypes.PAUSE, onPause)
+      removeEventListener(PlayerEventTypes.PLAY, onPlay)
+    }
+  }
+
+  private fun createRenderSettings(playerConfig: THEOplayerConfig): AdsRenderingSettings {
+    val renderingSettings = ImaSdkFactory.getInstance().createAdsRenderingSettings()
+    if (playerConfig.ads != null && !playerConfig.ads!!.isShowCountdown) {
+      renderingSettings.setUiElements(emptySet())
+      renderingSettings.disableUi = true
+    }
+    return renderingSettings
+  }
+
+  /**
+   * The host activity is paused.
+   */
+  fun onHostPause() {
+    if (!isBackgroundAudioEnabled) {
+      mediaSessionConnector?.setActive(false)
+      playerView.onPause()
+    }
+  }
+
+  /**
+   * The host activity is resumed.
+   */
+  fun onHostResume() {
+    if (!isBackgroundAudioEnabled) {
+      mediaSessionConnector?.setActive(true)
+      playerView.onResume()
+    }
+  }
+
+  fun destroy() {
+    if (mediaControlledInstance == this) {
+      if (BuildConfig.USE_PLAYBACK_SERVICE) {
+        removeListeners()
+
+        // Remove service from foreground
+        binder?.stopForegroundService()
+
+        // Unbind client from background service so it can stop
+        unbindMediaPlaybackService()
+      }
+      mediaControlledInstance = null
+    }
+    mediaSessionConnector?.destroy()
+    playerView.onDestroy()
+  }
+}

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

@@ -7,10 +7,12 @@ import com.facebook.react.uimanager.ViewManager
 import com.theoplayer.ads.AdsModule
 import com.theoplayer.drm.ContentProtectionModule
 import com.theoplayer.cast.CastModule
+import com.theoplayer.player.PlayerModule
 
 class ReactTHEOplayerPackage : ReactPackage {
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
     return listOf(
+      PlayerModule(reactContext),
       AdsModule(reactContext),
       ContentProtectionModule(reactContext),
       CastModule(reactContext)