react-native-theoplayer 1.6.1 → 1.7.0

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

@@ -0,0 +1,269 @@
+package com.theoplayer.drm
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Base64
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import com.theoplayer.BuildConfig
+import com.theoplayer.android.api.THEOplayerGlobal
+import com.theoplayer.android.api.contentprotection.*
+import com.theoplayer.android.api.error.ErrorCode
+import com.theoplayer.android.api.error.THEOplayerException
+import com.theoplayer.android.api.source.drm.DRMConfiguration
+import com.theoplayer.drm.ContentProtectionAdapter.fromDRMConfiguration
+
+data class BridgeRequest(
+  val onResult: HashMap<String, (result: ReadableMap) -> Unit>,
+  val onError: (exception: THEOplayerException) -> Unit,
+  val onTimeout: Runnable
+)
+
+private const val TAG = "ContentProtectionModule"
+
+private const val EVENT_CERTIFICATE_REQUEST = "onCertificateRequest"
+private const val EVENT_CERTIFICATE_REQUEST_PROCESSED_AS_REQUEST = "onCertificateRequestProcessedAsRequest"
+private const val EVENT_CERTIFICATE_REQUEST_PROCESSED_AS_CERTIFICATE = "onCertificateRequestProcessedAsCertificate"
+private const val EVENT_CERTIFICATE_RESPONSE = "onCertificateResponse"
+private const val EVENT_CERTIFICATE_RESPONSE_PROCESSED = "onCertificateResponseProcessed"
+private const val EVENT_BUILD_INTEGRATION = "onBuildIntegration"
+private const val EVENT_BUILD_PROCESSED = "onBuildProcessed"
+private const val EVENT_LICENSE_REQUEST = "onLicenseRequest"
+private const val EVENT_LICENSE_REQUEST_PROCESSED_AS_REQUEST = "onLicenseRequestProcessedAsRequest"
+private const val EVENT_LICENSE_REQUEST_PROCESSED_AS_LICENSE = "onLicenseRequestProcessedAsLicense"
+private const val EVENT_LICENSE_RESPONSE = "onLicenseResponse"
+private const val EVENT_LICENSE_RESPONSE_PROCESSED = "onLicenseResponseProcessed"
+
+class ContentProtectionModule(private val context: ReactApplicationContext) :
+  ReactContextBaseJavaModule(context) {
+
+  companion object {
+    const val REQUEST_TIMEOUT_MS = 10000L
+  }
+
+  private val handler = Handler(Looper.getMainLooper())
+
+  private var requestId: Int = 0
+
+  private val requestQueue: HashMap<String, BridgeRequest> = HashMap()
+
+  override fun getName(): String {
+    return TAG
+  }
+
+  @ReactMethod
+  fun registerContentProtectionIntegration(integrationId: String, keySystemIdStr: String) {
+    val keySystemId = KeySystemAdapter.fromString(keySystemIdStr)
+    if (keySystemId != null) {
+      handler.post {
+        val factory = ProxyContentProtectionIntegrationFactory(integrationId, keySystemId, this)
+        THEOplayerGlobal.getSharedInstance(context.applicationContext)
+          .registerContentProtectionIntegration(integrationId, keySystemId, factory)
+      }
+    } else {
+      Log.e(TAG, "Invalid keySystemId $keySystemIdStr")
+    }
+  }
+
+  @ReactMethod
+  fun onBuildProcessed(payload: ReadableMap) {
+    receive(EVENT_BUILD_PROCESSED, payload)
+  }
+
+  @ReactMethod
+  fun onCertificateRequestProcessedAsCertificate(payload: ReadableMap) {
+    receive(EVENT_CERTIFICATE_REQUEST_PROCESSED_AS_CERTIFICATE, payload)
+  }
+
+  @ReactMethod
+  fun onCertificateRequestProcessedAsRequest(payload: ReadableMap) {
+    receive(EVENT_CERTIFICATE_REQUEST_PROCESSED_AS_REQUEST, payload)
+  }
+
+  @ReactMethod
+  fun onCertificateResponseProcessed(payload: ReadableMap) {
+    receive(EVENT_CERTIFICATE_RESPONSE_PROCESSED, payload)
+  }
+
+  @ReactMethod
+  fun onLicenseRequestProcessedAsLicense(payload: ReadableMap) {
+    receive(EVENT_LICENSE_REQUEST_PROCESSED_AS_LICENSE, payload)
+  }
+
+  @ReactMethod
+  fun onLicenseRequestProcessedAsRequest(payload: ReadableMap) {
+    receive(EVENT_LICENSE_REQUEST_PROCESSED_AS_REQUEST, payload)
+  }
+
+  @ReactMethod
+  fun onLicenseResponseProcessed(payload: ReadableMap) {
+    receive(EVENT_LICENSE_RESPONSE_PROCESSED, payload)
+  }
+
+  fun onBuild(integrationId: String, keySystemId: KeySystemId, config: DRMConfiguration?) {
+    val payload = createBridgeData(integrationId, keySystemId)
+    if (config != null) {
+      payload.putMap(PROP_DRM_CONFIG, fromDRMConfiguration(config))
+    }
+    emit(
+      EVENT_BUILD_INTEGRATION, payload,
+      onResult = hashMapOf(),
+      onError = {}
+    )
+  }
+
+  fun onCertificateRequest(
+    integrationId: String,
+    keySystemId: KeySystemId,
+    request: Request,
+    callback: CertificateRequestCallback
+  ) {
+    val payload = ContentProtectionAdapter.fromRequest(integrationId, keySystemId, request)
+    emit(
+      EVENT_CERTIFICATE_REQUEST, payload,
+      onResult = hashMapOf(
+        // Pass modified request
+        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>
+          request.body = Base64.decode(result.getString(PROP_BASE64_BODY), Base64.DEFAULT)
+          callback.request(request)
+        },
+        // Pass response
+        EVENT_CERTIFICATE_REQUEST_PROCESSED_AS_CERTIFICATE to { result ->
+          callback.respond(Base64.decode(result.getString(PROP_BASE64_BODY), Base64.DEFAULT))
+        }
+      ),
+      onError = { error -> callback.error(error) }
+    )
+  }
+
+  fun onCertificateResponse(
+    integrationId: String,
+    keySystemId: KeySystemId,
+    response: Response,
+    callback: CertificateResponseCallback
+  ) {
+    val payload = ContentProtectionAdapter.fromResponse(integrationId, keySystemId, response)
+    emit(
+      EVENT_CERTIFICATE_RESPONSE, payload,
+      onResult = hashMapOf(
+        EVENT_CERTIFICATE_RESPONSE_PROCESSED to { result ->
+          val body = Base64.decode(result.getString(PROP_BASE64_BODY), Base64.DEFAULT)
+          callback.respond(body)
+        },
+      ),
+      onError = { error -> callback.error(error) }
+    )
+  }
+
+  fun onLicenseRequest(
+    integrationId: String,
+    keySystemId: KeySystemId,
+    request: Request,
+    callback: LicenseRequestCallback
+  ) {
+    val payload = ContentProtectionAdapter.fromRequest(integrationId, keySystemId, request)
+    emit(
+      EVENT_LICENSE_REQUEST, payload,
+      onResult = hashMapOf(
+        // Pass modified request
+        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>
+          request.body = Base64.decode(result.getString(PROP_BASE64_BODY), Base64.DEFAULT)
+          callback.request(request)
+        },
+        // Pass license response
+        EVENT_LICENSE_REQUEST_PROCESSED_AS_LICENSE to { result ->
+          callback.respond(Base64.decode(result.getString(PROP_BASE64_BODY), Base64.DEFAULT))
+        }
+      ),
+      onError = { error -> callback.error(error) }
+    )
+  }
+
+  fun onLicenseResponse(
+    integrationId: String,
+    keySystemId: KeySystemId,
+    response: Response,
+    callback: LicenseResponseCallback
+  ) {
+    val payload = ContentProtectionAdapter.fromResponse(integrationId, keySystemId, response)
+    emit(
+      EVENT_LICENSE_RESPONSE, payload,
+      onResult = hashMapOf(
+        // Pass response
+        EVENT_LICENSE_RESPONSE_PROCESSED to { result ->
+          val body = Base64.decode(result.getString(PROP_BASE64_BODY), Base64.DEFAULT)
+          callback.respond(body)
+        }
+      ),
+      onError = { error -> callback.error(error) }
+    )
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String?) {
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int?) {
+  }
+
+  private fun emit(
+    eventName: String,
+    payload: WritableMap,
+    onResult: HashMap<String, (result: ReadableMap) -> Unit>,
+    onError: (error: THEOplayerException) -> Unit
+  ) {
+    val requestId = createRequestId()
+    if (BuildConfig.DEBUG) {
+      Log.d(TAG, "emit $eventName ($requestId)")
+    }
+    payload.putString(PROP_REQUEST_ID, requestId)
+    val onTimeout = {
+      onError(
+        THEOplayerException(ErrorCode.CONTENT_PROTECTION_ERROR, "$eventName time-out.")
+      )
+    }
+    requestQueue[requestId] = BridgeRequest(onResult, onError, onTimeout)
+    handler.postDelayed(onTimeout, REQUEST_TIMEOUT_MS)
+    context
+      .getJSModule(RCTDeviceEventEmitter::class.java)
+      .emit(eventName, payload)
+  }
+
+  private fun receive(eventName: String, payload: ReadableMap) {
+    val requestId = payload.getString(PROP_REQUEST_ID)
+    if (BuildConfig.DEBUG) {
+      Log.d(TAG, "receive $eventName ($requestId)")
+    }
+    val request = requestQueue.remove(requestId)
+    if (request != null) {
+      handler.removeCallbacks(request.onTimeout)
+      val onEventResult = request.onResult[eventName]
+      if (onEventResult != null) {
+        onEventResult(payload)
+      } else {
+        request.onError(
+          THEOplayerException(ErrorCode.CONTENT_PROTECTION_ERROR, "Unknown bridge event: $eventName.")
+        )
+      }
+    }
+  }
+
+  private fun createRequestId(): String {
+    return (requestId++).toString()
+  }
+
+  private fun createBridgeData(integrationId: String, keySystemId: KeySystemId): WritableMap {
+    return Arguments.createMap().apply {
+      putString(PROP_INTEGRATION_ID, integrationId)
+      putString(PROP_KEYSYSTEM_ID, KeySystemAdapter.toString(keySystemId))
+    }
+  }
+}

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

@@ -0,0 +1,22 @@
+package com.theoplayer.drm
+
+import com.theoplayer.android.api.contentprotection.KeySystemId
+
+object KeySystemAdapter {
+  fun fromString(keySystemStr: String): KeySystemId? {
+    return when (keySystemStr) {
+      "widevine" -> KeySystemId.WIDEVINE
+      "playready" -> KeySystemId.PLAYREADY
+      "fairplay" -> KeySystemId.FAIRPLAY
+      else -> null
+    }
+  }
+
+  fun toString(keySystemId: KeySystemId): String {
+    return when (keySystemId) {
+      KeySystemId.WIDEVINE -> "widevine"
+      KeySystemId.PLAYREADY -> "playready"
+      KeySystemId.FAIRPLAY -> "fairplay"
+    }
+  }
+}

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

@@ -0,0 +1,33 @@
+package com.theoplayer.drm
+
+import com.theoplayer.android.api.contentprotection.*
+import com.theoplayer.android.api.source.drm.DRMConfiguration
+
+class ProxyContentProtectionIntegration(
+  private val integrationId: String,
+  private val keySystemId: KeySystemId,
+  config: DRMConfiguration?,
+  private val module: ContentProtectionModule
+) :
+  ContentProtectionIntegration() {
+
+  init {
+    module.onBuild(integrationId, keySystemId, config)
+  }
+
+  override fun onCertificateRequest(request: Request, callback: CertificateRequestCallback) {
+    module.onCertificateRequest(integrationId, keySystemId, request, callback)
+  }
+
+  override fun onCertificateResponse(response: Response, callback: CertificateResponseCallback) {
+    module.onCertificateResponse(integrationId, keySystemId, response, callback)
+  }
+
+  override fun onLicenseRequest(request: Request, callback: LicenseRequestCallback) {
+    module.onLicenseRequest(integrationId, keySystemId, request, callback)
+  }
+
+  override fun onLicenseResponse(response: Response, callback: LicenseResponseCallback) {
+    module.onLicenseResponse(integrationId, keySystemId, response, callback)
+  }
+}

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

@@ -0,0 +1,19 @@
+package com.theoplayer.drm
+
+import com.theoplayer.android.api.contentprotection.ContentProtectionIntegration
+import com.theoplayer.android.api.contentprotection.ContentProtectionIntegrationFactory
+import com.theoplayer.android.api.contentprotection.KeySystemId
+import com.theoplayer.android.api.source.drm.DRMConfiguration
+
+class ProxyContentProtectionIntegrationFactory(
+  private val integrationId: String,
+  private val keySystemId: KeySystemId,
+  private val module: ContentProtectionModule
+) :
+  ContentProtectionIntegrationFactory {
+  override fun build(
+    config: DRMConfiguration?
+  ): ContentProtectionIntegration {
+    return ProxyContentProtectionIntegration(integrationId, keySystemId, config, module)
+  }
+}

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

@@ -0,0 +1,28 @@
+package com.theoplayer.drm
+
+import com.theoplayer.android.api.contentprotection.RequestMethod
+
+object RequestMethodAdapter {
+  fun fromString(requestMethod: String?): RequestMethod {
+    return when (requestMethod?.lowercase()) {
+      "get" -> RequestMethod.GET
+      "post" -> RequestMethod.POST
+      "put" -> RequestMethod.PUT
+      "delete" -> RequestMethod.DELETE
+      "head" -> RequestMethod.HEAD
+      "options" -> RequestMethod.OPTIONS
+      else -> RequestMethod.GET
+    }
+  }
+
+  fun toString(requestMethod: RequestMethod): String {
+    return when (requestMethod) {
+      RequestMethod.GET -> "get"
+      RequestMethod.POST -> "post"
+      RequestMethod.PUT -> "put"
+      RequestMethod.DELETE -> "delete"
+      RequestMethod.HEAD -> "head"
+      RequestMethod.OPTIONS -> "options"
+    }
+  }
+}

package/android/src/main/java/com/theoplayer/track/QualityListAdapter.java

@@ -0,0 +1,54 @@
+package com.theoplayer.track;
+
+import androidx.annotation.NonNull;
+
+import com.theoplayer.android.api.player.track.mediatrack.quality.Quality;
+import com.theoplayer.android.api.player.track.mediatrack.quality.QualityList;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Adapts an Android List to a QualityList.
+ */
+public class QualityListAdapter<Q extends Quality> implements QualityList<Q> {
+  private List<Q> qualities;
+
+  public QualityListAdapter(@NonNull List<Q> qualities) {
+    this.qualities = qualities;
+  }
+
+  public QualityListAdapter(@NonNull QualityList<Q> qualities) {
+    this.qualities = new ArrayList<Q>();
+    for (final Q quality : qualities) {
+      this.qualities.add(quality);
+    }
+  }
+
+  @Override
+  public int length() {
+    return qualities.size();
+  }
+
+  @Override
+  public Q getItem(int i) {
+    return (i >= 0 && i < length()) ? qualities.get(i) : null;
+  }
+
+  @NonNull
+  @Override
+  public Iterator<Q> iterator() {
+    return qualities.iterator();
+  }
+
+  public List<Q> asList() {
+    return qualities;
+  }
+
+  public void sort(Comparator<Q> comparator) {
+    Collections.sort(qualities, comparator);
+  }
+}

package/android/src/main/java/com/theoplayer/track/QualityListFilter.java

@@ -0,0 +1,40 @@
+package com.theoplayer.track;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.theoplayer.android.api.player.track.mediatrack.quality.Quality;
+import com.theoplayer.android.api.player.track.mediatrack.quality.QualityList;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * QualityListFilter allows filtering a QualityList.
+ */
+public class QualityListFilter<Q extends Quality> {
+
+  private final QualityList<Q> qualities;
+
+  public QualityListFilter(QualityList<Q> qualities) {
+    this.qualities = qualities;
+  }
+
+  @NonNull
+  public QualityList<Q> filterQualityList(ReadableArray uids) {
+    return new QualityListAdapter<Q>(filterList(uids));
+  }
+
+  @NonNull
+  public List<Q> filterList(ReadableArray uids) {
+    final List<Q> filteredQualities = new ArrayList<>();
+    for (int q = 0; q < uids.size(); q++) {
+      for (final Q quality : qualities) {
+        if (uids.getInt(q) == quality.getUid()) {
+          filteredQualities.add(quality);
+        }
+      }
+    }
+    return filteredQualities;
+  }
+}

package/android/src/main/java/com/theoplayer/track/TrackListInfo.java

@@ -159,9 +159,17 @@ public class TrackListInfo {
 
       final QualityList<VideoQuality> qualityList = videoTrack.getQualities();
       WritableArray qualities = Arguments.createArray();
+
       if (qualityList != null) {
-        for (int j = 0; j < qualityList.length(); j++) {
-          final VideoQuality quality = qualityList.getItem(j);
+        // Sort qualities according to (height, bandwidth)
+        final QualityListAdapter<VideoQuality> sortedQualityList = new QualityListAdapter<>(qualityList);
+        sortedQualityList.sort(
+          (o, t1) ->
+            (o.getHeight() == t1.getHeight()) ?
+              Long.compare(t1.getBandwidth(), o.getBandwidth()) : Integer.compare(t1.getHeight(), o.getHeight())
+        );
+
+        for (final VideoQuality quality : sortedQualityList) {
           WritableMap videoQualityPayload = Arguments.createMap();
           videoQualityPayload.putString(PROP_ID, quality.getId());
           videoQualityPayload.putInt(PROP_UID, quality.getUid());

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

@@ -0,0 +1,17 @@
+package com.theoplayer.util
+
+const val NAN_VALUE: Double = -1.0
+const val POS_INF_VALUE: Double = -2.0
+
+object TypeUtils {
+  // Make sure we do not send INF or NaN double values over the bridge. It will break debug sessions.
+  fun encodeInfNan(v: Double): Double {
+    return when (v) {
+      Double.NaN -> NAN_VALUE
+      Double.POSITIVE_INFINITY -> POS_INF_VALUE
+      else -> {
+        return v
+      }
+    }
+  }
+}

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

@@ -0,0 +1,42 @@
+package com.theoplayer.util;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.theoplayer.ReactTHEOplayerView;
+
+public class ViewResolver {
+  private UIManagerModule uiManager;
+
+  private Handler handler = new Handler(Looper.getMainLooper());
+
+  private final ReactApplicationContext reactContext;
+
+  public interface Callback {
+    void onResolved(@Nullable ReactTHEOplayerView view);
+  }
+
+  public ViewResolver(ReactApplicationContext reactContext) {
+    this.reactContext = reactContext;
+  }
+
+  public void resolveViewByTag(final Integer tag, Callback callback) {
+    if (tag == null) {
+      callback.onResolved(null);
+    }
+    if (uiManager == null) {
+      uiManager = reactContext.getNativeModule(UIManagerModule.class);
+    }
+    if (uiManager == null) {
+      callback.onResolved(null);
+    }
+    handler.post(() -> {
+      callback.onResolved((ReactTHEOplayerView)uiManager.resolveView(tag));
+    });
+  }
+}