react-native-theoplayer 1.8.2 → 2.0.0

package/android/src/main/java/com/theoplayer/util/PayloadBuilder.kt

@@ -0,0 +1,242 @@
+package com.theoplayer.util
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.theoplayer.android.api.player.PresentationMode
+import com.theoplayer.android.api.player.ReadyState
+import com.theoplayer.android.api.player.track.mediatrack.MediaTrack
+import com.theoplayer.android.api.player.track.mediatrack.MediaTrackList
+import com.theoplayer.android.api.player.track.mediatrack.quality.AudioQuality
+import com.theoplayer.android.api.player.track.mediatrack.quality.Quality
+import com.theoplayer.android.api.player.track.mediatrack.quality.VideoQuality
+import com.theoplayer.android.api.player.track.texttrack.TextTrack
+import com.theoplayer.android.api.player.track.texttrack.TextTrackList
+import com.theoplayer.android.api.player.track.texttrack.cue.TextTrackCue
+import com.theoplayer.android.api.source.SourceDescription
+import com.theoplayer.android.api.timerange.TimeRanges
+import com.theoplayer.presentation.PresentationModeChangeContext
+import com.theoplayer.presentation.PresentationModeChangePipContext
+import com.theoplayer.track.MediaTrackType
+import com.theoplayer.track.TrackListAdapter
+import java.util.*
+
+private const val EVENT_PROP_SOURCE = "source"
+private const val EVENT_PROP_CURRENT_TIME = "currentTime"
+private const val EVENT_PROP_PRESENTATION_MODE = "presentationMode"
+private const val EVENT_PROP_PREV_PRESENTATION_MODE = "previousPresentationMode"
+private const val EVENT_PROP_CONTEXT = "context"
+private const val EVENT_PROP_PIP = "pip"
+private const val EVENT_PROP_CURRENT_PROGRAM_DATE_TIME = "currentProgramDateTime"
+private const val EVENT_PROP_SEEKABLE = "seekable"
+private const val EVENT_PROP_BUFFERED = "buffered"
+private const val EVENT_PROP_START = "start"
+private const val EVENT_PROP_END = "end"
+private const val EVENT_PROP_PAUSED = "paused"
+private const val EVENT_PROP_DURATION = "duration"
+private const val EVENT_PROP_TEXT_TRACKS = "textTracks"
+private const val EVENT_PROP_AUDIO_TRACKS = "audioTracks"
+private const val EVENT_PROP_VIDEO_TRACKS = "videoTracks"
+private const val EVENT_PROP_SELECTED_TEXT_TRACK = "selectedTextTrack"
+private const val EVENT_PROP_SELECTED_AUDIO_TRACK = "selectedAudioTrack"
+private const val EVENT_PROP_SELECTED_VIDEO_TRACK = "selectedVideoTrack"
+private const val EVENT_PROP_ERROR = "error"
+private const val EVENT_PROP_ERROR_CODE = "errorCode"
+private const val EVENT_PROP_ERROR_MESSAGE = "errorMessage"
+private const val EVENT_PROP_RATE = "playbackRate"
+private const val EVENT_PROP_READYSTATE = "readyState"
+private const val EVENT_PROP_RETRYCOUNT = "retryCount"
+private const val EVENT_PROP_SEGMENTSTARTTIME = "segmentStartTime"
+private const val EVENT_PROP_TRACK = "track"
+private const val EVENT_PROP_TRACK_UID = "trackUid"
+private const val EVENT_PROP_TRACK_TYPE = "trackType"
+private const val EVENT_PROP_CUE = "cue"
+private const val EVENT_PROP_QUALITIES = "qualities"
+private const val EVENT_PROP_VOLUME = "volume"
+private const val EVENT_PROP_MUTED = "muted"
+
+class PayloadBuilder {
+  private val payload: WritableMap = Arguments.createMap()
+
+  fun source(source: SourceDescription?) = apply {
+    if (source != null) {
+      val sourcePayload = Arguments.createMap()
+      // TODO: fill in source properties
+      payload.putMap(EVENT_PROP_SOURCE, sourcePayload)
+    }
+  }
+
+  fun currentTime(timeInSec: Double) = apply {
+    payload.putDouble(EVENT_PROP_CURRENT_TIME, (1e03 * timeInSec).toLong().toDouble())
+  }
+
+  fun currentProgramDateTime(currentProgramDateTime: Date?) = apply {
+    currentProgramDateTime?.let {
+      payload.putDouble(
+        EVENT_PROP_CURRENT_PROGRAM_DATE_TIME,
+        (1e03 * currentProgramDateTime.time).toLong().toDouble()
+      )
+    }
+  }
+
+  fun presentationMode(presentationMode: PresentationMode, prevPresentationMode: PresentationMode?, context: PresentationModeChangeContext?) =
+    apply {
+      payload.putString(
+        EVENT_PROP_PRESENTATION_MODE,
+        presentationModeToString(presentationMode)
+      )
+      payload.putString(
+        EVENT_PROP_PREV_PRESENTATION_MODE,
+        presentationModeToString(prevPresentationMode ?: PresentationMode.INLINE)
+      )
+      if (context != null) {
+        presentationModeChangedContext(context)
+      }
+    }
+
+  private fun presentationModeToString(presentationMode: PresentationMode): String {
+    return when (presentationMode) {
+      PresentationMode.PICTURE_IN_PICTURE -> "picture-in-picture"
+      PresentationMode.FULLSCREEN -> "fullscreen"
+      else -> "inline"
+    }
+  }
+
+  private fun presentationModeChangedContext(context: PresentationModeChangeContext) = apply {
+    val contextPayload = Arguments.createMap()
+    context.pip?.let { pipCtx ->
+      contextPayload.putString(EVENT_PROP_PIP, when (pipCtx) {
+        PresentationModeChangePipContext.RESTORED -> "restored"
+        else -> "closed"
+      })
+    }
+    payload.putMap(EVENT_PROP_CONTEXT, contextPayload)
+  }
+
+  fun paused(paused: Boolean) = apply {
+    payload.putBoolean(EVENT_PROP_PAUSED, paused)
+  }
+
+  fun playbackRate(playbackRate: Double) = apply {
+    payload.putDouble(EVENT_PROP_RATE, playbackRate)
+  }
+
+  fun duration(durationInSec: Double) = apply {
+    payload.putDouble(EVENT_PROP_DURATION, TypeUtils.encodeInfNan(1e03 * durationInSec))
+  }
+
+  fun volume(volume: Double, muted: Boolean) = apply {
+    payload.putDouble(EVENT_PROP_VOLUME, volume)
+    payload.putBoolean(EVENT_PROP_MUTED, muted)
+  }
+
+  fun seekable(ranges: TimeRanges?) = apply {
+    payload.putArray(EVENT_PROP_SEEKABLE, fromTimeRanges(ranges))
+  }
+
+  fun buffered(ranges: TimeRanges?) = apply {
+    payload.putArray(EVENT_PROP_BUFFERED, fromTimeRanges(ranges))
+  }
+
+  fun error(message: String?) = apply {
+    val error = Arguments.createMap()
+    error.putString(EVENT_PROP_ERROR_MESSAGE, message ?: "")
+    payload.putMap(EVENT_PROP_ERROR, error)
+  }
+
+  fun error(code: String, message: String?) = apply {
+    val error = Arguments.createMap()
+    error.putString(EVENT_PROP_ERROR_CODE, code)
+    error.putString(EVENT_PROP_ERROR_MESSAGE, message ?: "")
+    payload.putMap(EVENT_PROP_ERROR, error)
+  }
+
+  fun readyState(readyState: ReadyState) = apply {
+    payload.putInt(EVENT_PROP_READYSTATE, readyState.ordinal)
+  }
+
+  fun textTracks(textTrackList: TextTrackList?) = apply {
+    payload.putArray(
+      EVENT_PROP_TEXT_TRACKS,
+      TrackListAdapter.fromTextTrackList(textTrackList)
+    )
+  }
+
+  fun audioTracks(audioTrackList: MediaTrackList<AudioQuality>?) = apply {
+    payload.putArray(
+      EVENT_PROP_AUDIO_TRACKS,
+      TrackListAdapter.fromAudioTrackList(audioTrackList)
+    )
+  }
+
+  fun videoTracks(videoTrackList: MediaTrackList<VideoQuality>?) = apply {
+    payload.putArray(
+      EVENT_PROP_VIDEO_TRACKS,
+      TrackListAdapter.fromVideoTrackList(videoTrackList)
+    )
+  }
+
+  fun selectedTextTrack(selectedTextTrack: TextTrack?) = apply {
+    selectedTextTrack?.let {
+      payload.putInt(EVENT_PROP_SELECTED_TEXT_TRACK, selectedTextTrack.uid)
+    }
+  }
+
+  fun selectedAudioTrack(selectedAudioTrack: MediaTrack<AudioQuality>?) = apply {
+    selectedAudioTrack?.let {
+      payload.putInt(EVENT_PROP_SELECTED_AUDIO_TRACK, selectedAudioTrack.uid)
+    }
+  }
+
+  fun selectedVideoTrack(selectedVideoTrack: MediaTrack<VideoQuality>?) = apply {
+    selectedVideoTrack?.let {
+      payload.putInt(EVENT_PROP_SELECTED_VIDEO_TRACK, selectedVideoTrack.uid)
+    }
+  }
+
+  fun segmentNotFound(segmentStartTime: Double, error: String, retryCount: Int) = apply {
+    payload.putDouble(EVENT_PROP_SEGMENTSTARTTIME, 1e03 * segmentStartTime)
+    payload.putString(EVENT_PROP_ERROR, error)
+    payload.putInt(EVENT_PROP_RETRYCOUNT, retryCount)
+  }
+
+  fun textTrack(textTrack: TextTrack) = apply {
+    payload.putMap(EVENT_PROP_TRACK, TrackListAdapter.fromTextTrack(textTrack))
+  }
+
+  fun textTrackCue(cue: TextTrackCue, textTrack: TextTrack?) = apply {
+    textTrack?.let {
+      payload.putInt(EVENT_PROP_TRACK_UID, textTrack.uid)
+    }
+    payload.putMap(EVENT_PROP_CUE, TrackListAdapter.fromTextTrackCue(cue))
+  }
+
+  fun mediaTrack(trackType: MediaTrackType, track: MediaTrack<*>) = apply {
+    payload.putInt(EVENT_PROP_TRACK_TYPE, trackType.type)
+    payload.putMap(EVENT_PROP_TRACK, TrackListAdapter.fromMediaTrack(track, trackType))
+  }
+
+  fun mediaTrackQualities(quality: Quality, activeTrack: MediaTrack<*>?) = apply {
+    val trackType = if (quality is AudioQuality) MediaTrackType.AUDIO else MediaTrackType.VIDEO
+    payload.putInt(EVENT_PROP_TRACK_TYPE, trackType.type)
+    if (activeTrack != null) {
+      payload.putInt(EVENT_PROP_TRACK_UID, activeTrack.uid)
+    }
+    payload.putMap(EVENT_PROP_QUALITIES, TrackListAdapter.fromQuality(quality))
+  }
+
+  private fun fromTimeRanges(timeRanges: TimeRanges?): WritableArray {
+    val payload = Arguments.createArray()
+    timeRanges?.forEach { timeRange ->
+      val range = Arguments.createMap()
+      range.putDouble(EVENT_PROP_START, 1e03 * timeRange.start)
+      range.putDouble(EVENT_PROP_END, 1e03 * timeRange.end)
+      payload.pushMap(range)
+    }
+    return payload
+  }
+
+  fun build(): WritableMap {
+    return payload
+  }
+}

package/android/src/main/java/com/theoplayer/util/ViewResolver.kt

@@ -1,19 +1,18 @@
 package com.theoplayer.util
 
-import android.os.Handler
-import android.os.Looper
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.UIManagerModule
 import com.theoplayer.ReactTHEOplayerView
 
 class ViewResolver(private val reactContext: ReactApplicationContext) {
   private var uiManager: UIManagerModule? = null
-  private val handler = Handler(Looper.getMainLooper())
 
   fun resolveViewByTag(tag: Int, onResolved: (view: ReactTHEOplayerView?) -> Unit) {
     if (uiManager == null) {
       uiManager = reactContext.getNativeModule(UIManagerModule::class.java)
     }
-    handler.post { onResolved(uiManager?.resolveView(tag) as ReactTHEOplayerView) }
+    uiManager?.addUIBlock {
+      onResolved(it.resolveView(tag) as ReactTHEOplayerView)
+    }
   }
 }

package/android/src/main/res/drawable/ic_close.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="#000000"
+        android:pathData="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z" />
+    <path
+        android:pathData="M0 0h24v24H0z" />
+</vector>

package/android/src/main/res/drawable/ic_notification_small.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0">
+    <path
+        android:fillColor="#FF000000"
+        android:pathData="M12,3v10.55c-0.59,-0.34 -1.27,-0.55 -2,-0.55 -2.21,0 -4,1.79 -4,4s1.79,4 4,4 4,-1.79 4,-4V7h4V3h-6z"/>
+</vector>

package/android/src/main/res/drawable/ic_pause.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="#000000"
+        android:pathData="M6 19h4V5H6v14zm8-14v14h4V5h-4z" />
+    <path
+        android:pathData="M0 0h24v24H0z" />
+</vector>

package/android/src/main/res/drawable/ic_play.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="#000000"
+        android:pathData="M8 5v14l11-7z" />
+    <path
+        android:pathData="M0 0h24v24H0z" />
+</vector>

package/android/src/main/res/values/colors.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="app_primary_color">#ffc713</color>
+</resources>

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <string name="pause">Pause</string>
+  <string name="play">Play</string>
+
+  <string name="background_playback_service_description">THEOplayer service providing background playback.</string>
+  <string name="notification_channel_id">theoplayer_default_channel</string>
+  <string name="notification_channel_name" translatable="true">THEOplayer default channel</string>
+</resources>

package/ios/THEOplayerRCTBridge.m

@@ -15,17 +15,8 @@
 // ----------------------------------------------------------------------------
 @interface RCT_EXTERN_MODULE(THEOplayerRCTViewManager, RCTViewManager)
 
-RCT_EXPORT_VIEW_PROPERTY(src, NSDictionary);
 RCT_EXPORT_VIEW_PROPERTY(config, NSDictionary);
-RCT_EXPORT_VIEW_PROPERTY(paused, BOOL);
-RCT_EXPORT_VIEW_PROPERTY(volume, NSNumber);
-RCT_EXPORT_VIEW_PROPERTY(muted, BOOL);
-RCT_EXPORT_VIEW_PROPERTY(playbackRate, NSNumber);
-RCT_EXPORT_VIEW_PROPERTY(selectedTextTrack, NSNumber);
-RCT_EXPORT_VIEW_PROPERTY(selectedAudioTrack, NSNumber);
-RCT_EXPORT_VIEW_PROPERTY(selectedVideoTrack, NSNumber);
-RCT_EXPORT_VIEW_PROPERTY(seek, NSNumber);
-RCT_EXPORT_VIEW_PROPERTY(fullscreen, BOOL);
+
 RCT_EXPORT_VIEW_PROPERTY(onNativePause, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativePlay, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeSourceChange, RCTDirectEventBlock);
@@ -40,16 +31,21 @@ RCT_EXPORT_VIEW_PROPERTY(onNativeSeeked, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeEnded, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeError, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeLoadedData, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeRateChange, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeVolumeChange, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeLoadedMetadata, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerWillPresent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerDidPresent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerWillDismiss, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerDidDismiss, RCTDirectEventBlock);
-
+RCT_EXPORT_VIEW_PROPERTY(onNativeWaiting, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeCanPlay, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeTextTrackListEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeTextTrackEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeMediaTrackListEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeMediaTrackEvent, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativePlayerReady, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativePresentationModeChange, RCTDirectEventBlock);
 
 RCT_EXPORT_VIEW_PROPERTY(onNativeAdEvent, RCTDirectEventBlock);
 
@@ -59,6 +55,58 @@ RCT_EXTERN_METHOD(destroy:(nonnull NSNumber *)node);
 
 @end
 
+// ----------------------------------------------------------------------------
+// Player Module
+// ----------------------------------------------------------------------------
+@interface RCT_EXTERN_REMAP_MODULE(PlayerModule, THEOplayerRCTPlayerAPI, NSObject)
+
+RCT_EXTERN_METHOD(setPaused:(nonnull NSNumber *)node
+                  paused:(BOOL)paused)
+
+RCT_EXTERN_METHOD(setSource:(nonnull NSNumber *)node
+                  src:(NSDictionary)src)
+
+RCT_EXTERN_METHOD(setABRConfig:(nonnull NSNumber *)node
+                  abrConfig:(NSDictionary)abrConfig)
+
+RCT_EXTERN_METHOD(setCurrentTime:(nonnull NSNumber *)node
+                  time:(nonnull NSNumber *)time)
+
+RCT_EXTERN_METHOD(setMuted:(nonnull NSNumber *)node
+                  muted:(BOOL)muted)
+
+RCT_EXTERN_METHOD(setVolume:(nonnull NSNumber *)node
+                  volume:(nonnull NSNumber *)volume)
+
+RCT_EXTERN_METHOD(setPlaybackRate:(nonnull NSNumber *)node
+                  playbackRate:(nonnull NSNumber *)playbackRate)
+
+RCT_EXTERN_METHOD(setPresentationMode:(nonnull NSNumber *)node
+                  presentationMode:(nonnull NSString *)presentationMode)
+
+RCT_EXTERN_METHOD(setPipConfig:(nonnull NSNumber *)node
+                  pipConfig:(NSDictionary)pipConfig)
+
+RCT_EXTERN_METHOD(setBackgroundAudioConfig:(nonnull NSNumber *)node
+                  backgroundAudioConfig:(NSDictionary)backgroundAudioConfig)
+
+RCT_EXTERN_METHOD(setSelectedTextTrack:(nonnull NSNumber *)node
+                  uid:(nonnull NSNumber *)uid)
+
+RCT_EXTERN_METHOD(setSelectedAudioTrack:(nonnull NSNumber *)node
+                  uid:(nonnull NSNumber *)uid)
+
+RCT_EXTERN_METHOD(setSelectedVideoTrack:(nonnull NSNumber *)node
+                  uid:(nonnull NSNumber *)uid)
+
+RCT_EXTERN_METHOD(setTargetVideoQuality:(nonnull NSNumber *)node
+                  uid:(nonnull NSNumber *)uid)
+
+RCT_EXTERN_METHOD(setPreload:(nonnull NSNumber *)node
+                  type:(nonnull NSString *)type)
+
+@end
+
 // ----------------------------------------------------------------------------
 // Ads Module
 // ----------------------------------------------------------------------------
@@ -84,7 +132,7 @@ RCT_EXTERN_METHOD(scheduledAdBreaks:(nonnull NSNumber *)node
                   rejecter:(RCTPromiseRejectBlock)reject)
 
 RCT_EXTERN_METHOD(schedule:(nonnull NSNumber *)node
-                  ad: NSDictionary)
+                  ad:(NSDictionary)ad)
 
 RCT_EXTERN_METHOD(daiSnapback:(nonnull NSNumber *)node
                   resolver:(RCTPromiseResolveBlock)resolve

package/ios/THEOplayerRCTDebug.swift

@@ -16,7 +16,7 @@ let DEBUG_THEOPLAYER_INTERACTION = DEBUG && false
 let DEBUG_CONTENT_PROTECTION_API = DEBUG && false
 
 // Debug flag to monitor all updates made  on bridged properties
-let DEBUG_PROP_UPDATES = DEBUG && false
+let DEBUG_VIEW = DEBUG && false
 
 // Debug flag to monitor correct SourceDescription buildup
 let DEBUG_SOURCE_DESCRIPTION_BUIDER = DEBUG && false
@@ -26,3 +26,15 @@ let DEBUG_ADS_API = DEBUG && false
 
 // Debug flag to monitor cast API usage
 let DEBUG_CAST_API = DEBUG && false
+
+// Debug flag to monitor player API usage
+let DEBUG_PLAYER_API = DEBUG && false
+
+// Debug flag to monitor Now Playing Info updates
+let DEBUG_NOWINFO = DEBUG && false
+
+// Debug flag to monitor Remote Commands updates
+let DEBUG_REMOTECOMMANDS = DEBUG && false
+
+// Debug flag to monitor PIP Controls updates
+let DEBUG_PIPCONTROLS = DEBUG && false