@takeoffmedia/react-native-penthera 0.1.0

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

@@ -0,0 +1,16 @@
+package com.takeoffmediareactnativepenthera
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PentheraPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(PentheraModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

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

@@ -0,0 +1,14 @@
+package com.takeoffmediareactnativepenthera
+import androidx.appcompat.app.AppCompatActivity
+import com.bitmovin.player.api.Player
+
+class YourPlayerActivity : AppCompatActivity() {
+
+  private lateinit var player: Player
+
+  // ...
+
+  fun getPlayerInstance(): Player {
+    return player
+  }
+}

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

@@ -0,0 +1,50 @@
+/*
+    Created by Penthera.
+    Copyright © 2020 penthera. All rights reserved.
+
+    This source file contains a very basic example showing how to use the Penthera Download2Go SDK.
+    Pay close attention to code comments marked IMPORTANT
+*/
+package com.takeoffmediareactnativepenthera.virtuoso
+
+import com.google.gson.Gson
+import com.penthera.virtuososdk.client.drm.LicenseManager
+import com.takeoffmediareactnativepenthera.virtuoso.data.Drm
+import com.takeoffmediareactnativepenthera.virtuoso.data.Item
+
+// Used if implementing executeKeyRequest
+/**
+ * A basic license manager implementation which provides the widevine url.
+ *
+ * Note: For this LicenseManager implementation to be used the class must be specified in the manifest metadata
+ * e.g.:
+ * <meta-data tools:replace="android:value" android:name="com.penthera.virtuososdk.license.manager.impl" android:value="com.penthera.download2go8.DemoLicenseManager"></meta-data>
+ * for the above to work you will need to add the tools name space
+ * xmlns:tools="http://schemas.android.com/tools"
+ */
+class DemoLicenseManager : LicenseManager() {
+    override fun getLicenseAcquistionUrl(): String {
+        // This demonstration uses the Google UAT server
+      val item = Gson().fromJson(this.mAsset.metadata, Item::class.java)
+      val drm = Gson().fromJson(item.drm, Drm::class.java)
+      return drm.licence_server ?: ""
+    }
+
+  override fun getKeyRequestProperties(): Map<String, String> {
+    val item = Gson().fromJson(this.mAsset.metadata, Item::class.java)
+    val drm = Gson().fromJson(item.drm, Drm::class.java)
+    return drm?.headers ?: mapOf()
+  }
+
+
+
+    // Override the following to perform more complex manipulation of the request and response,
+    // for instance if you need to parse a json response to retrieve the key response in base64
+    // You will also need to implement a post request method to support this implementation.
+    /*
+    public byte[] executeKeyRequest(UUID uuid, MediaDrm.KeyRequest request) throws IOException {
+        String url = getLicenseAcquistionUrl();
+        return post(url, request.getData(), getKeyRequestProperties());
+    }
+    */
+}

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

@@ -0,0 +1,227 @@
+package com.takeoffmediareactnativepenthera.virtuoso
+
+import EventEmitter
+import PentheraEvent
+import com.bitmovin.player.util.ParcelUtil
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.Context
+import android.util.Log
+import android.widget.Toast
+import com.bitmovin.player.PlayerView
+import com.bitmovin.player.api.Player
+import com.bitmovin.player.reactnative.PlayerModule
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.google.gson.Gson
+import com.penthera.common.Common.AuthenticationStatus
+import com.penthera.virtuososdk.client.EngineObserver
+import com.penthera.virtuososdk.client.IAsset
+import com.penthera.virtuososdk.client.IIdentifier
+import com.penthera.virtuososdk.client.IPushRegistrationObserver
+import com.penthera.virtuososdk.client.ISegmentedAsset
+import com.penthera.virtuososdk.client.ISegmentedAssetFromParserObserver
+import com.penthera.virtuososdk.client.Observers
+import com.penthera.virtuososdk.client.Virtuoso
+import com.penthera.virtuososdk.client.bitmovin.BitmovinSourceManager
+import com.penthera.virtuososdk.client.builders.MPDAssetBuilder
+import com.penthera.virtuososdk.interfaces.toolkit.VirtuosoSegmentedFile
+import com.takeoffmediareactnativepenthera.AssetQueueObserver
+import com.takeoffmediareactnativepenthera.YourPlayerActivity
+import com.takeoffmediareactnativepenthera.virtuoso.data.Item
+import java.net.URL
+import java.util.UUID
+import com.bitmovin.player.reactnative.SourceModule
+import com.bitmovin.player.reactnative.converter.JsonConverter
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.UIManagerModule
+
+class OfflineVideoEngine(private val context: ReactApplicationContext) {
+
+  var virtuoso: Virtuoso? = null
+  private lateinit var queueObserver: AssetQueueObserver
+
+  var asset: IAsset? = null
+  var assetId: String = ""
+
+  private val enginePauseObserver: Observers.IEngineObserver = object : EngineObserver() {
+    override fun engineStatusChanged(status: Int) {
+      Log.e("MiModulo", "<<<<<<<<<<status $status>>>>>>>>>>>>")
+    }
+  }
+
+  private fun getVirtuoso(activity: Activity): Virtuoso {
+    virtuoso = Virtuoso(context)
+    queueObserver = AssetQueueObserver(this)
+    onResume()
+    return virtuoso!!
+  }
+
+  fun onResume() {
+    virtuoso?.onResume()
+    virtuoso?.addObserver(queueObserver)
+    virtuoso?.addObserver(enginePauseObserver)
+  }
+
+  fun onPause() {
+    virtuoso?.onPause()
+    virtuoso?.removeObserver(queueObserver)
+    virtuoso?.removeObserver(enginePauseObserver)
+  }
+
+  fun setup(
+    user: String,
+    backplaneUrl: String,
+    publicKey: String,
+    privateKey: String,
+    activity: Activity
+  ): String {
+    Log.e("MiModulo", "<<<<<<<<<<setup>>>>>>>>>>>>")
+    val backplane = getVirtuoso(activity)
+    val status = backplane.backplane?.authenticationStatus
+    if (status == AuthenticationStatus.NOT_AUTHENTICATED) {
+      virtuoso!!.startup(
+        URL(backplaneUrl),//substitute the proper backplane url for you implementation
+        // substitute the proper backplane url for your implementation
+        UUID.randomUUID()
+          .toString(),    // provide an appropriate unique user id. A random uuid is used here for demonstration purposes only
+        null, //Optional additional device id to be associated with the user account.  This is not the device id generated by the virtuoso SDK
+        publicKey,//Penthera demo public key.  Substitute the correct one.
+        privateKey,
+        object : IPushRegistrationObserver {
+          override fun onServiceAvailabilityResponse(
+            pushService: Int,
+            errorCode: Int
+          ) {
+            //callback for push registration.  this will be detailed in subsequent tutorials
+          }
+        }
+      )
+      return "Penthera initialization successfully"
+    }
+    return "Penthera init yet"
+  }
+
+
+  fun downloadAsset(data: String, activity: Activity) {
+    val item = Gson().fromJson(data, Item::class.java)
+    assetId = item.assetId
+    val params = MPDAssetBuilder().apply {
+      assetId(item.assetId)
+      manifestUrl(URL(item.contentUrl))
+      assetObserver(AssetParseObserver(context))
+      addToQueue(true)
+      desiredVideoBitrate(Int.MAX_VALUE)
+      withMetadata(data)
+      setClientSideAdSupport(true)
+    }.build()
+
+    virtuoso!!.assetManager.createMPDSegmentedAssetAsync(params)
+  }
+
+  fun getDownloads(): String? {
+    Log.e("MiModulo", "getDownloads")
+    val completedList = mutableListOf<MutableMap<String, Any>>()
+    val cursor = virtuoso?.assetManager?.cursor
+    val count = cursor?.count
+    val columnNames = cursor?.columnNames
+    while (cursor?.moveToNext() == true) {
+      val dataMap = mutableMapOf<String, Any>()
+      for (columnName in columnNames!!) {
+        val columnIndex = cursor.getColumnIndex(columnName)
+        if (columnIndex >= 0) {
+          val value = cursor.getString(columnIndex)
+          if (value != null) {
+            dataMap[columnName] = value
+            dataMap["isCompleted"] = true
+            dataMap["isPaused"] = false
+          }
+          if(columnName == "assetId"){
+            dataMap["id"] = value
+          }
+        }
+      }
+      completedList.add(dataMap)
+    }
+
+    return Gson().toJson(completedList)
+
+  }
+
+  class AssetParseObserver(activity: Context) : ISegmentedAssetFromParserObserver {
+    private val mActivity: Context = activity
+
+    @SuppressLint("ShowToast")
+    override fun complete(asset: ISegmentedAsset?, error: Int, addedToQueue: Boolean) {
+
+      if (asset != null) {
+        Toast.makeText(
+          mActivity,
+          "Asset parsed and " + if (addedToQueue) "added" else "not added" + "to download queue",
+          Toast.LENGTH_LONG
+        ).show()
+      } else {
+        Toast.makeText(mActivity, "Error $error while parsing asset", Toast.LENGTH_LONG).show()
+      }
+    }
+  }
+
+  fun deleteAsset(assetId: String) {
+    //load asset if it has already been downloaded
+    val list: MutableList<IIdentifier>? = virtuoso?.assetManager?.getByAssetId(assetId)
+
+    list?.let {
+      if (it.isNotEmpty())
+        asset = list[0] as IAsset
+      EventEmitter.sharedInstance.dispatch(
+        "penthera",
+        PentheraEvent.ASSET_DELETED,
+        asset!!.assetId,
+        "test"
+      )
+      virtuoso?.assetManager?.delete(asset)
+      asset = null
+    }
+
+  }
+
+  fun getByAssetId(assetId: String): String? {
+    //load asset if it has already been downloaded
+    val list: MutableList<IIdentifier>? = virtuoso?.assetManager?.getByAssetId(assetId)
+
+    list?.let {
+      if (it.isNotEmpty()) {
+        asset = list[0] as VirtuosoSegmentedFile
+        val offlineUrl = asset?.playbackURL.toString()
+        val keyValueMap = HashMap<String, Any>()
+        keyValueMap["offlineUrl"] = offlineUrl
+        keyValueMap["metadata"] = asset?.metadata.toString()
+        return Gson().toJson(keyValueMap)
+      }
+    }
+  return null
+  }
+
+  fun updateUI() {}
+
+  fun loadBitmovinSourceManager(assetId: String, nativeId: String): Boolean {
+    virtuoso?.assetManager?.getByAssetId(assetId)?.firstOrNull()?.let { asset ->
+      val sourceManager = BitmovinSourceManager(context, asset as ISegmentedAsset)
+      val sourceItem = sourceManager.bitmovinSourceItem
+      val playerModule = context.getNativeModule(PlayerModule::class.java)
+      if (playerModule != null && sourceItem != null) {
+        val player = playerModule.getPlayer(nativeId)
+        if (player != null) {
+          player.load(sourceItem)
+          return true
+        }
+      }
+    }
+    return false
+  }
+
+  private fun uiManager(): UIManagerModule? =
+    context.getNativeModule(UIManagerModule::class.java)
+
+
+}

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

@@ -0,0 +1,17 @@
+package com.takeoffmediareactnativepenthera.virtuoso
+
+import com.penthera.virtuososdk.database.impl.provider.VirtuosoSDKContentProvider
+
+class PentheraContentProvider: VirtuosoSDKContentProvider() {
+
+  companion object {
+    init {
+      setAuthority("com.pentheraexample.virtuoso.provider")
+    }
+  }
+
+  override fun getAuthority(): String {
+    return "com.pentheraexample.virtuoso.provider"
+  }
+
+}

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

@@ -0,0 +1,65 @@
+
+package com.takeoffmediareactnativepenthera.virtuoso
+
+import android.app.Notification
+import android.content.Context
+import android.content.Intent
+import com.penthera.virtuososdk.service.VirtuosoServiceStarter
+import com.takeoffmediareactnativepenthera.virtuoso.notification.NotificationFactory
+import com.takeoffmediareactnativepenthera.virtuoso.notification.ServiceForegroundNotificationProvider
+
+class ServiceStarter : VirtuosoServiceStarter() {
+
+  companion object {
+
+    private var currentNotification: Notification? = null
+
+    /**
+     * This convenience method shows how to call the underlying method to force the SDK
+     * to update the foreground notification stored within the download service.
+     * This method causes an asynchronous process which will call back into the
+     * getForegroundServiceNotification() method and then send the resulting notification
+     * into the download service process.
+     */
+    fun updateNotification(aContext: Context, aIntent: Intent) {
+      updateNotification(aContext, aIntent, ServiceStarter::class.java)
+    }
+  }
+
+  // This is a helper class which is used in the demo for creating the notifications
+  private val notificationFactory: NotificationFactory = NotificationFactory("PentheraExample")
+
+  /**
+   * This method will be called by the framework to request the generation of a notification,
+   * to be displayed as the foreground notification for the download service. The notification
+   * returned from this method will be parcelled and passed over the process boundary into the
+   * service. This imposes some limitations on the size of the notification returned, as it must
+   * be suitable to pass over the boundary.
+   *
+   * In this demo we use a separate notification factory class to create foreground notifications
+   * for both these notifications and the ones created directly in the service
+   * (see ServiceForegroundNotificationProvider). In a more complex application this may not be shared.
+   *
+   * @param context A context which can be used in generating the notification
+   * @param forIntent The intent for which to create a notification
+   * @return The new notification
+   */
+  override fun getForegroundServiceNotification(context: Context?, forIntent: Intent?): Notification {
+
+    val notification = notificationFactory.getNotification(context!!, forIntent)
+    if (notification != null) {
+      currentNotification = notification
+    }
+
+    return currentNotification!!
+  }
+
+  override fun getForegroundServiceNotificationProvider(): Class<*> {
+    // Returning this class definition causes the service to instantiate and use the class
+    // from within the service process to generate all notifications relating to asset downloads.
+    // Returning null results in the classic SDK behaviour where all notifications are generated
+    // and delivered to the service via the service starter.
+    return ServiceForegroundNotificationProvider::class.java
+  }
+
+}

package/android/src/main/java/com/takeoffmediareactnativepenthera/virtuoso/data/Drm.kt

@@ -0,0 +1,6 @@
+package com.takeoffmediareactnativepenthera.virtuoso.data
+
+data class Drm(
+  var licence_server: String = "",
+  var headers: Map<String, String> = mapOf(),
+)

package/android/src/main/java/com/takeoffmediareactnativepenthera/virtuoso/data/Item.kt

@@ -0,0 +1,34 @@
+package com.takeoffmediareactnativepenthera.virtuoso.data
+
+import com.google.gson.annotations.SerializedName
+
+data class Item(
+
+  var id: String,
+
+  @SerializedName("asset_id")
+  val assetId: String = "",
+
+  @SerializedName("title")
+  val title: String = "",
+
+  @SerializedName("content_url")
+  val contentUrl: String = "",
+
+  @SerializedName("poster")
+  val poster: String = "",
+
+  @SerializedName("thumbnail")
+  val thumbnail: String = "",
+
+  @SerializedName("en_subtitle")
+  val subtitle: String? = "",
+
+  @SerializedName("drm")
+  val drm: String? = null,
+
+)
+
+
+
+