@takeoffmedia/react-native-penthera 0.8.8 → 0.8.9

package/android/src/main/java/com/takeoffmediareactnativepenthera/PentheraModule.kt

@@ -7,6 +7,7 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.UiThreadUtil
 import com.takeoffmediareactnativepenthera.virtuoso.OfflineVideoEngine
 import com.facebook.react.uimanager.UIManagerModule
 
@@ -75,11 +76,34 @@ class PentheraModule(val reactContext: ReactApplicationContext) : ReactContextBa
   }
 
   @ReactMethod
-  fun loadBitmovinSourceManager(assetId: String, nativeId: String, startOffset: Double?, ancillaryFiles: String, promise: Promise) {
-    uiManager()?.addUIBlock {
-      val bitmovinSourceItem =
-        offlineVideoEngine.loadBitmovinSourceManager(assetId, nativeId, startOffset, ancillaryFiles, promise)
-      promise.resolve(bitmovinSourceItem)
+  fun loadBitmovinSourceManager(
+    assetId: String,
+    nativeId: String,
+    startOffset: Double?,
+    ancillaryFiles: String?,
+    promise: Promise
+  ) {
+    val manager = uiManager()
+    if (manager == null) {
+      UiThreadUtil.runOnUiThread {
+        offlineVideoEngine.loadBitmovinSourceManager(
+          assetId,
+          nativeId,
+          startOffset,
+          ancillaryFiles,
+          promise
+        )
+      }
+      return
+    }
+    manager.addUIBlock {
+      offlineVideoEngine.loadBitmovinSourceManager(
+        assetId,
+        nativeId,
+        startOffset,
+        ancillaryFiles,
+        promise
+      )
     }
   }
 

package/android/src/main/java/com/takeoffmediareactnativepenthera/virtuoso/OfflineVideoEngine.kt

@@ -2,6 +2,7 @@ package com.takeoffmediareactnativepenthera.virtuoso
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.os.SystemClock
 import android.util.Log
 import com.bitmovin.player.api.media.subtitle.SubtitleTrack
 import com.bitmovin.player.reactnative.PlayerRegistry
@@ -423,81 +424,144 @@ class OfflineVideoEngine(private val context: ReactApplicationContext) {
     )
   }
 
+  private fun waitForPlayer(nativeId: String, timeoutMs: Long = 3000L) =
+    run {
+      val deadline = SystemClock.elapsedRealtime() + timeoutMs
+      var player = PlayerRegistry.getPlayer(nativeId)
+      while (player == null && SystemClock.elapsedRealtime() < deadline) {
+        SystemClock.sleep(50)
+        player = PlayerRegistry.getPlayer(nativeId)
+      }
+      player
+    }
+
+  private fun parseSubtitles(metadata: JSONObject): JSONArray {
+    if (!metadata.has("subtitles")) {
+      return JSONArray()
+    }
+    return try {
+      when (val raw = metadata.get("subtitles")) {
+        is JSONArray -> raw
+        is String -> if (raw.isNotBlank()) JSONArray(raw) else JSONArray()
+        else -> JSONArray()
+      }
+    } catch (_: Exception) {
+      JSONArray()
+    }
+  }
+
+  private fun parseAncillaryFiles(ancillaries: String?): JSONArray {
+    if (ancillaries.isNullOrBlank()) {
+      return JSONArray()
+    }
+    return try {
+      JSONArray(ancillaries)
+    } catch (_: Exception) {
+      JSONArray()
+    }
+  }
+
+  private fun findAncillaryPlaybackUrl(ancillaryFiles: JSONArray, language: String): String? {
+    for (j in 0 until ancillaryFiles.length()) {
+      val ancillary = ancillaryFiles.optJSONObject(j) ?: continue
+      if (ancillary.optString("description") == language) {
+        val playbackUrl = ancillary.optString("playbackUrl")
+        if (playbackUrl.isNotBlank()) {
+          return playbackUrl
+        }
+      }
+    }
+    return null
+  }
+
   fun loadBitmovinSourceManager(
     assetId: String,
     nativeId: String,
     startOffset: Double?,
-    ancillaries: String,
+    ancillaries: String?,
     promise: Promise
   ) {
-    virtuoso.assetManager.getByAssetId(assetId)?.firstOrNull()?.let { asset ->
+    try {
+      val asset = virtuoso.assetManager.getByAssetId(assetId)?.firstOrNull()
+      if (asset == null) {
+        promise.reject("Error", "Asset not found")
+        return
+      }
+
       val sourceManager = BitmovinSourceManager(context, asset as ISegmentedAsset)
       val sourceItem = sourceManager.bitmovinSourceItem
-      if (sourceItem != null) {
-        var player = PlayerRegistry.getPlayer(nativeId)
-        while (player == null) {
-          Thread.sleep(100)
-          player = PlayerRegistry.getPlayer(nativeId)
-        }
-        val metadata = JSONObject(asset.metadata)
-        val subtitles = JSONArray(metadata["subtitles"] as String)
-        val ancillaryFiles = JSONArray(ancillaries)
-        for (i in 0 until subtitles.length()) {
-          val subtitleMap = Arguments.createMap()
-          val subtitle = subtitles.getJSONObject(i)
-
-          for (j in 0 until ancillaryFiles.length()) {
-            val ancillary = ancillaryFiles.getJSONObject(j)
-            if (ancillary.getString("description") == subtitle.getString("language")) {
-              subtitleMap.putString("url", ancillary.getString("playbackUrl").toString())
-            }
-          }
-          subtitleMap.putString("language", subtitle.getString("language"))
-          subtitleMap.putString("label", subtitle.getString("label"))
-          subtitleMap.putString("format", "vtt")
+      if (sourceItem == null) {
+        promise.reject("Error", "Source item is null")
+        return
+      }
 
-          toSubtitleTrack(subtitleMap)?.let {
-            sourceItem.addSubtitleTrack(it)
-          }
+      val player = waitForPlayer(nativeId)
+      if (player == null) {
+        promise.reject("Error", "Player not ready")
+        return
+      }
+
+      val metadata = JSONObject(asset.metadata)
+      val subtitles = parseSubtitles(metadata)
+      val ancillaryFiles = parseAncillaryFiles(ancillaries)
+      for (i in 0 until subtitles.length()) {
+        val subtitle = subtitles.optJSONObject(i) ?: continue
+        val language = subtitle.optString("language")
+        if (language.isBlank()) {
+          continue
         }
-        if (startOffset != null) {
-          sourceItem.options.startOffset = startOffset
+        val label = subtitle.optString("label", language)
+        val subtitleMap = Arguments.createMap()
+        findAncillaryPlaybackUrl(ancillaryFiles, language)?.let { url ->
+          subtitleMap.putString("url", url)
         }
-        val metaDataMap = mutableMapOf<String, String>()
+        subtitleMap.putString("language", language)
+        subtitleMap.putString("label", label)
+        subtitleMap.putString("format", "vtt")
 
-        val data = metadata.getJSONObject("data")
-        val infoVideoPlayer = data.getJSONObject("infoVideoPlayer")
-
-        infoVideoPlayer.optString("title").let { title ->
-          if (title.isNotBlank()) {
-            sourceItem.title = title
-          }
+        toSubtitleTrack(subtitleMap)?.let {
+          sourceItem.addSubtitleTrack(it)
         }
+      }
 
-        infoVideoPlayer.optString("description").let { description ->
-          if (description.isNotBlank()) {
-            metaDataMap["description"] = description
-          }
+      if (startOffset != null) {
+        sourceItem.options.startOffset = startOffset
+      }
+
+      val metaDataMap = mutableMapOf<String, String>()
+      val data = metadata.optJSONObject("data")
+      val infoVideoPlayer = data?.optJSONObject("infoVideoPlayer")
+
+      infoVideoPlayer?.optString("title")?.let { title ->
+        if (title.isNotBlank()) {
+          sourceItem.title = title
         }
+      }
 
-        infoVideoPlayer.optString("advisoryClassification").let { advisoryClassification ->
-          if (advisoryClassification.isNotBlank()) {
-            metaDataMap["advisoryClassification"] = advisoryClassification
-          }
+      infoVideoPlayer?.optString("description")?.let { description ->
+        if (description.isNotBlank()) {
+          metaDataMap["description"] = description
         }
+      }
 
-        infoVideoPlayer.optString("advisoryDescription").let { advisoryDescription ->
-          if (advisoryDescription.isNotBlank()) {
-            metaDataMap["advisoryDescription"] = advisoryDescription
-          }
+      infoVideoPlayer?.optString("advisoryClassification")?.let { advisoryClassification ->
+        if (advisoryClassification.isNotBlank()) {
+          metaDataMap["advisoryClassification"] = advisoryClassification
         }
+      }
 
-        sourceItem.metadata = metaDataMap
-        player?.load(sourceItem)
-        promise.resolve(true)
+      infoVideoPlayer?.optString("advisoryDescription")?.let { advisoryDescription ->
+        if (advisoryDescription.isNotBlank()) {
+          metaDataMap["advisoryDescription"] = advisoryDescription
+        }
       }
+
+      sourceItem.metadata = metaDataMap
+      player.load(sourceItem)
+      promise.resolve(true)
+    } catch (e: Exception) {
+      promise.reject("Error", e.message ?: "Error loading asset")
     }
-    promise.reject("Error", "Error loading asset")
   }
 
   fun getAuthenticationStatus(promise: Promise) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeoffmedia/react-native-penthera",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "description": "test",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",