react-native-theoplayer 1.8.2 → 2.0.0

package/android/src/main/java/com/theoplayer/audio/BackgroundAudioConfig.kt

@@ -0,0 +1,17 @@
+package com.theoplayer.audio
+
+data class BackgroundAudioConfig(
+  /**
+   * Set whether background audio playback is enabled.
+   *
+   * @defaultValue `false`
+   */
+  val enabled: Boolean,
+
+  /**
+   * Set whether the mediaPlaybackService is enabled.
+   *
+   * @defaultValue `true`
+   */
+  val mediaPlaybackServiceEnabled: Boolean
+)

package/android/src/main/java/com/theoplayer/audio/BackgroundAudioConfigAdapter.kt

@@ -0,0 +1,19 @@
+package com.theoplayer.audio
+
+import com.facebook.react.bridge.ReadableMap
+
+object BackgroundAudioConfigAdapter {
+  private const val PROP_ENABLED = "enabled"
+  private const val PROP_SERVICE_ENABLED = "mediaPlaybackServiceEnabled"
+
+  private const val DEFAULT_ENABLED = false
+  private const val DEFAULT_SERVICE_ENABLED = true
+
+  fun fromProps(props: ReadableMap?): BackgroundAudioConfig {
+    val enabled =
+      if (props?.hasKey(PROP_ENABLED) == true) props.getBoolean(PROP_ENABLED) else DEFAULT_ENABLED
+    val serviceEnabled =
+      if (props?.hasKey(PROP_SERVICE_ENABLED) == true) props.getBoolean(PROP_SERVICE_ENABLED) else DEFAULT_SERVICE_ENABLED
+    return BackgroundAudioConfig(enabled, serviceEnabled)
+  }
+}

package/android/src/main/java/com/theoplayer/audio/MediaNotificationBuilder.kt

@@ -0,0 +1,194 @@
+package com.theoplayer.audio
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.graphics.Bitmap
+import android.net.Uri
+import android.os.Build
+import android.support.v4.media.session.MediaSessionCompat
+import android.support.v4.media.session.PlaybackStateCompat
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
+import androidx.media.session.MediaButtonReceiver
+import com.facebook.common.executors.UiThreadImmediateExecutorService
+import com.facebook.common.references.CloseableReference
+import com.facebook.datasource.DataSource
+import com.facebook.drawee.backends.pipeline.Fresco
+import com.facebook.imagepipeline.datasource.BaseBitmapDataSubscriber
+import com.facebook.imagepipeline.image.CloseableImage
+import com.facebook.imagepipeline.request.ImageRequest
+import com.theoplayer.R
+
+private const val TAG = "MediaNotification"
+
+class MediaNotificationBuilder(
+  private val context: Context,
+  private val notificationManager: NotificationManager,
+  private val mediaSession: MediaSessionCompat
+) {
+
+  private var channel: NotificationChannel? = null
+  private var channelId: String? = null
+
+  init {
+    channelId = context.getString(R.string.notification_channel_id)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      channel = NotificationChannel(
+        channelId,
+        context.getString(R.string.notification_channel_name),
+        NotificationManager.IMPORTANCE_DEFAULT
+      ).apply {
+        setShowBadge(false)
+        lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+        setSound(null, null)
+        notificationManager.createNotificationChannel(this)
+      }
+    }
+  }
+
+  private val playAction = NotificationCompat.Action(
+    R.drawable.ic_play, context.getString(R.string.play),
+    MediaButtonReceiver.buildMediaButtonPendingIntent(
+      context,
+      PlaybackStateCompat.ACTION_PLAY_PAUSE
+    )
+  )
+
+  private val pauseAction = NotificationCompat.Action(
+    R.drawable.ic_pause, context.getString(R.string.pause),
+    MediaButtonReceiver.buildMediaButtonPendingIntent(
+      context,
+      PlaybackStateCompat.ACTION_PLAY_PAUSE
+    )
+  )
+
+  fun build(
+    @PlaybackStateCompat.State playbackState: Int,
+    largeIcon: Bitmap?,
+    enableMediaControls: Boolean = true,
+    enableContentIntent: Boolean = true,
+    enableCancelButton: Boolean = true
+  ): Notification {
+    val builder = channelId.let {
+      if (it != null) {
+        NotificationCompat.Builder(context, it)
+      } else {
+        @Suppress("DEPRECATION") NotificationCompat.Builder(context)
+      }
+    }
+    builder.apply {
+
+      // Add the metadata for the currently playing track
+      mediaSession.controller.metadata?.description?.let {
+        setContentTitle(it.title)
+        setContentText(it.subtitle)
+        setSubText(it.description)
+      }
+
+      // Enable launching the session activity by clicking the notification
+      if (enableContentIntent) {
+        setContentIntent(mediaSession.controller.sessionActivity)
+      }
+
+      // Stop the service when the notification is swiped to dismiss
+      setDeleteIntent(
+        MediaButtonReceiver.buildMediaButtonPendingIntent(
+          context,
+          PlaybackStateCompat.ACTION_STOP
+        )
+      )
+
+      // Notification category: media transport control for playback.
+      setCategory(NotificationCompat.CATEGORY_TRANSPORT)
+
+      // The UI may choose to show these items smaller, or at a different position in the
+      // list, compared with your app's PRIORITY_DEFAULT items
+      priority = NotificationCompat.PRIORITY_DEFAULT
+
+      // Make the transport controls visible on the lockscreen
+      setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+
+      // Add an app icon and set its accent color
+      setSmallIcon(R.drawable.ic_notification_small)
+
+      // Set the large icon that is shown in the notification
+      setLargeIcon(largeIcon)
+
+      // Be careful when you set the background color. In an ordinary notification in
+      // Android version 5.0 or later, the color is applied only to the background of the
+      // small app icon. But for MediaStyle notifications prior to Android 7.0, the color is
+      // used for the entire notification background. Test your background color. Go gentle
+      // on the eyes and avoid extremely bright or fluorescent colors.
+      color = ContextCompat.getColor(context, R.color.app_primary_color)
+
+      // Add a play/pause button
+      if (enableMediaControls) {
+        if (playbackState == PlaybackStateCompat.STATE_PAUSED) {
+          addAction(playAction)
+        } else if (playbackState == PlaybackStateCompat.STATE_PLAYING) {
+          addAction(pauseAction)
+        }
+      } else {
+        // Add empty placeholder action as clearActions() does not work.
+        addAction(0, null, null)
+      }
+
+      // Take advantage of MediaStyle features
+      val style = androidx.media.app.NotificationCompat.MediaStyle()
+
+      // Associate the notification with your session. This allows third-party apps and
+      // companion devices to access and control the session.
+      if (enableMediaControls) {
+        style.setMediaSession(mediaSession.sessionToken)
+      }
+
+      // Add up to 3 actions to be shown in the notification's standard-sized contentView.
+      style.setShowActionsInCompactView(0)
+
+      if (enableCancelButton) {
+        // In Android 5.0 (API level 21) and later you can swipe away a notification to
+        // stop the player once the service is no longer running in the foreground.
+        style.setShowCancelButton(true)
+        style.setCancelButtonIntent(
+          MediaButtonReceiver.buildMediaButtonPendingIntent(
+            context,
+            PlaybackStateCompat.ACTION_STOP
+          )
+        )
+      }
+      setStyle(style)
+    }
+    return builder.build()
+  }
+}
+
+fun fetchImageFromUri(uri: Uri?, block: (Bitmap?) -> Unit) {
+  if (uri == null) {
+    block(null)
+    return
+  }
+
+  val imageRequest = ImageRequest.fromUri(uri)
+  val imagePipeline = Fresco.getImagePipeline()
+
+  imagePipeline.fetchDecodedImage(imageRequest, null).also {
+    it.subscribe(
+      object : BaseBitmapDataSubscriber() {
+        override fun onNewResultImpl(bitmap: Bitmap?) {
+          block(bitmap)
+        }
+
+        override fun onFailureImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
+          if (dataSource.failureCause != null) {
+            Log.w(TAG, "Failed to get image $uri")
+          }
+          block(null)
+        }
+      },
+      UiThreadImmediateExecutorService.getInstance()
+    )
+  }
+}

package/android/src/main/java/com/theoplayer/audio/MediaPlaybackService.kt

@@ -0,0 +1,278 @@
+package com.theoplayer.audio
+
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Intent
+import android.os.Binder
+import android.os.Build
+import android.os.Bundle
+import android.os.IBinder
+import android.support.v4.media.MediaBrowserCompat
+import android.support.v4.media.session.MediaSessionCompat
+import android.support.v4.media.session.PlaybackStateCompat
+import android.text.TextUtils
+import androidx.core.content.ContextCompat
+import androidx.media.MediaBrowserServiceCompat
+import androidx.media.session.MediaButtonReceiver
+import com.theoplayer.BuildConfig
+import com.theoplayer.ReactTHEOplayerContext
+import com.theoplayer.android.api.player.Player
+import com.theoplayer.android.connector.mediasession.MediaSessionConnector
+import com.theoplayer.android.connector.mediasession.MediaSessionListener
+
+private const val BROWSABLE_ROOT = "/"
+private const val EMPTY_ROOT = "@empty@"
+private const val STOP_SERVICE_IF_APP_REMOVED = true
+
+private const val NOTIFICATION_ID = 1
+
+private const val TAG = "MediaPlaybackService"
+
+class MediaPlaybackService : MediaBrowserServiceCompat() {
+
+  private lateinit var notificationManager: NotificationManager
+  private lateinit var notificationBuilder: MediaNotificationBuilder
+
+  private var playerContext: ReactTHEOplayerContext? = null
+
+  private var enableMediaControls: Boolean = true
+
+  private val player: Player?
+    get() = playerContext?.player
+
+  private lateinit var mediaSessionConnector: MediaSessionConnector
+  private val mediaSession: MediaSessionCompat
+    get() =  mediaSessionConnector.mediaSession
+
+  inner class MediaPlaybackBinder : Binder() {
+    private val service: MediaPlaybackService
+      get() = this@MediaPlaybackService
+
+    val mediaSessionConnector: MediaSessionConnector
+      get() = service.mediaSessionConnector
+
+    fun setPlayerContext(playerContext: ReactTHEOplayerContext) {
+      service.connectPlayerContext(playerContext)
+    }
+
+    fun setEnablePlaybackControls(enable: Boolean) {
+      enableMediaControls = enable
+      updateNotification()
+    }
+
+    fun updateNotification() {
+      service.updateNotification()
+    }
+
+    fun updateNotification(@PlaybackStateCompat.State playbackState: Int) {
+      service.updateNotification(playbackState)
+    }
+
+    fun stopForegroundService() {
+      service.stopForegroundService()
+    }
+  }
+
+  private val binder: MediaPlaybackBinder by lazy { MediaPlaybackBinder() }
+
+  override fun onCreate() {
+    super.onCreate()
+    initMediaSession()
+
+    notificationManager = (getSystemService(NOTIFICATION_SERVICE) as NotificationManager)
+    notificationBuilder = MediaNotificationBuilder(this, notificationManager, mediaSession)
+
+    // This ensures that the service starts and continues to run, even when all
+    // UI MediaBrowser activities that are bound to it unbind.
+    ContextCompat.startForegroundService(
+      applicationContext,
+      Intent(applicationContext, MediaPlaybackService::class.java)
+    )
+
+    updateNotification(PlaybackStateCompat.STATE_PLAYING)
+  }
+
+  override fun onBind(intent: Intent): IBinder {
+    return binder
+  }
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    MediaButtonReceiver.handleIntent(mediaSession, intent)
+    return super.onStartCommand(intent, flags, startId)
+  }
+
+  override fun onTaskRemoved(rootIntent: Intent?) {
+    super.onTaskRemoved(rootIntent)
+    if (STOP_SERVICE_IF_APP_REMOVED) {
+      notificationManager.cancel(NOTIFICATION_ID)
+      stopSelf()
+    }
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    removeListeners()
+    mediaSessionConnector.destroy()
+    playerContext = null
+  }
+
+  private fun initMediaSession() {
+    // Sets an intent for launching UI for this Session. This can be used as a quick link to
+    // an ongoing media screen. The intent should be for an activity that may be started using
+    // Activity.startActivity(Intent).
+    val intentFlags =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0
+    val sessionActivityPendingIntent = packageManager
+      ?.getLaunchIntentForPackage(packageName)
+      ?.let { sessionIntent ->
+        PendingIntent.getActivity(
+          this@MediaPlaybackService,
+          0,
+          sessionIntent,
+          intentFlags
+        )
+      }
+
+    // Sets a pending intent for your media button receiver to allow restarting playback after
+    // the session has been stopped.
+    val mediaButtonPendingIntent = PendingIntent.getBroadcast(
+      this@MediaPlaybackService,
+      0,
+      Intent(
+        Intent.ACTION_MEDIA_BUTTON, null, applicationContext, MediaButtonReceiver::class.java
+      ),
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        PendingIntent.FLAG_IMMUTABLE
+      } else {
+        PendingIntent.FLAG_ONE_SHOT
+      }
+    )
+
+    // Create and initialize the media session
+    val mediaSession = MediaSessionCompat(this, TAG).apply {
+      setSessionActivity(sessionActivityPendingIntent)
+      setMediaButtonReceiver(mediaButtonPendingIntent)
+    }
+
+    // Create a MediaSessionConnector and attach the THEOplayer instance.
+    mediaSessionConnector = MediaSessionConnector(mediaSession).apply {
+      debug = BuildConfig.LOG_MEDIASESSION_EVENTS
+
+      // Set mediaSession active
+      setActive(true)
+    }
+  }
+
+  private fun stopForegroundService() {
+    player?.pause()
+    updateNotification(PlaybackStateCompat.STATE_STOPPED)
+    stopSelf()
+  }
+
+  private fun connectPlayerContext(playerContext: ReactTHEOplayerContext) {
+    if (this.playerContext != null) {
+      removeListeners()
+    }
+    this.playerContext = playerContext
+    addListeners()
+    updateNotification()
+  }
+
+  private val mediaSessionListener = object : MediaSessionListener() {
+    override fun onStop() {
+      stopForegroundService()
+    }
+  }
+
+  private fun addListeners() {
+    mediaSessionConnector.addListener(mediaSessionListener)
+  }
+
+  private fun removeListeners() {
+    mediaSessionConnector.removeListener(mediaSessionListener)
+  }
+
+  override fun onGetRoot(
+    clientPackageName: String,
+    clientUid: Int,
+    rootHints: Bundle?
+  ): BrowserRoot {
+    // (Optional) Control the level of access for the specified package name.
+    // You'll need to write your own logic to do this.
+    return if (allowBrowsing(clientPackageName, clientUid)) {
+      // Returns a root ID that clients can use with onLoadChildren() to retrieve
+      // the content hierarchy.
+      BrowserRoot(BROWSABLE_ROOT, null)
+    } else {
+      // Clients can connect, but this BrowserRoot is an empty hierachy
+      // so onLoadChildren returns nothing. This disables the ability to browse for content.
+      BrowserRoot(EMPTY_ROOT, null)
+    }
+  }
+
+  private fun allowBrowsing(clientPackageName: String, clientUid: Int): Boolean {
+    // Only allow browsing from the same package
+    return TextUtils.equals(clientPackageName, packageName)
+  }
+
+  override fun onLoadChildren(
+    parentId: String,
+    result: Result<List<MediaBrowserCompat.MediaItem>>
+  ) {
+    if (parentId == EMPTY_ROOT) {
+      result.sendResult(null)
+      return
+    }
+    result.sendResult(emptyList())
+  }
+
+  private fun updateNotification() {
+    player?.let {
+      if (it.isPaused) {
+        updateNotification(PlaybackStateCompat.STATE_PAUSED)
+      } else {
+        updateNotification(PlaybackStateCompat.STATE_PLAYING)
+      }
+    }
+  }
+
+  private fun updateNotification(@PlaybackStateCompat.State playbackState: Int) {
+
+    // When a service is playing, it should be running in the foreground.
+    // This lets the system know that the service is performing a useful function and should
+    // not be killed if the system is low on memory.
+    when (playbackState) {
+      PlaybackStateCompat.STATE_PAUSED -> {
+        // Fetch large icon asynchronously
+        fetchImageFromUri(mediaSession.controller.metadata?.description?.iconUri) { largeIcon ->
+          notificationManager.notify(NOTIFICATION_ID, notificationBuilder.build(playbackState, largeIcon, enableMediaControls))
+        }
+      }
+      PlaybackStateCompat.STATE_PLAYING -> {
+        // When a service runs in the foreground, it must display a notification, ideally
+        // with one or more transport controls. The notification should also include useful
+        // information from the session's metadata.
+        // Fetch large icon asynchronously
+        fetchImageFromUri(mediaSession.controller.metadata?.description?.iconUri) { largeIcon ->
+          startForeground(NOTIFICATION_ID, notificationBuilder.build(playbackState, largeIcon, enableMediaControls))
+        }
+      }
+      PlaybackStateCompat.STATE_STOPPED -> {
+        // Remove this service from foreground state, allowing it to be killed if more memory is
+        // needed. This does not stop the service from running (for that you use stopSelf()
+        // or related methods), just takes it out of the foreground state.
+        // Also remove the notification.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+          stopForeground(Service.STOP_FOREGROUND_REMOVE)
+        } else {
+          @Suppress("DEPRECATION")
+          stopForeground(true)
+        }
+      }
+      else -> {
+        // Ignore
+      }
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/cast/CastModule.kt

@@ -1,4 +1,5 @@
 @file:Suppress("unused")
+
 package com.theoplayer.cast
 
 import com.facebook.react.bridge.ReactApplicationContext
@@ -19,7 +20,7 @@ class CastModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(
   @ReactMethod
   fun casting(tag: Int, promise: Promise) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
-      promise.resolve(view?.castIntegration?.isCasting() ?: false)
+      promise.resolve(view?.playerContext?.castIntegration?.isCasting() ?: false)
     }
   }
 
@@ -31,7 +32,11 @@ class CastModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(
   @ReactMethod
   fun chromecastState(tag: Int, promise: Promise) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
-      promise.resolve(castStateToString(view?.castIntegration?.getState() ?: PlayerCastState.UNAVAILABLE))
+      promise.resolve(
+        castStateToString(
+          view?.playerContext?.castIntegration?.getState() ?: PlayerCastState.UNAVAILABLE
+        )
+      )
     }
   }
 
@@ -48,28 +53,28 @@ class CastModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(
   @ReactMethod
   fun chromecastStart(tag: Int) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
-      view?.castIntegration?.start()
+      view?.playerContext?.castIntegration?.start()
     }
   }
 
   @ReactMethod
   fun chromecastStop(tag: Int) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
-      view?.castIntegration?.stop()
+      view?.playerContext?.castIntegration?.stop()
     }
   }
 
   @ReactMethod
   fun chromecastJoin(tag: Int) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
-      view?.castIntegration?.join()
+      view?.playerContext?.castIntegration?.join()
     }
   }
 
   @ReactMethod
   fun chromecastLeave(tag: Int) {
     viewResolver.resolveViewByTag(tag) { view: ReactTHEOplayerView? ->
-      view?.castIntegration?.leave()
+      view?.playerContext?.castIntegration?.leave()
     }
   }
 }

package/android/src/main/java/com/theoplayer/drm/ContentProtectionModule.kt

@@ -130,7 +130,10 @@ class ContentProtectionModule(private val context: ReactApplicationContext) :
         EVENT_CERTIFICATE_REQUEST_PROCESSED_AS_REQUEST to { result ->
           request.url = result.getString(PROP_URL)!!
           request.method = RequestMethodAdapter.fromString(result.getString(PROP_METHOD))
-          request.headers = result.getMap(PROP_HEADERS)?.toHashMap() as HashMap<String, String>
+          val headers = result.getMap(PROP_HEADERS)?.toHashMap()?.mapValues { entry -> entry.value as? String }
+          if (headers != null) {
+            request.headers = headers
+          }
           request.body = Base64.decode(result.getString(PROP_BASE64_BODY), Base64.DEFAULT)
           callback.request(request)
         },
@@ -176,7 +179,10 @@ class ContentProtectionModule(private val context: ReactApplicationContext) :
         EVENT_LICENSE_REQUEST_PROCESSED_AS_REQUEST to { result ->
           request.url = result.getString(PROP_URL)!!
           request.method = RequestMethodAdapter.fromString(result.getString(PROP_METHOD))
-          request.headers = result.getMap(PROP_HEADERS)?.toHashMap() as HashMap<String, String>
+          val headers = result.getMap(PROP_HEADERS)?.toHashMap()?.mapValues { entry -> entry.value as? String }
+          if (headers != null) {
+            request.headers = headers
+          }
           request.body = Base64.decode(result.getString(PROP_BASE64_BODY), Base64.DEFAULT)
           callback.request(request)
         },