@24i/smartapps-bigscreen-rnv-build-engine 5.0.0-alpha.25 → 5.0.0

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/di/ActivityComponent.kt

@@ -0,0 +1,13 @@
+package com.twentyfouri.tvbridge.global.di
+
+import android.app.Activity
+import com.twentyfouri.tvbridge.webview.viewmodel.WebViewModel
+import dagger.Component
+import javax.inject.Provider
+
+@PerActivity
+@Component(dependencies = [ApplicationComponent::class], modules = [ActivityModule::class])
+interface ActivityComponent : ApplicationComponent {
+    val activity: Activity
+    val viewModelFactory: Provider<WebViewModel>
+}

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/di/ActivityModule.kt

@@ -0,0 +1,14 @@
+package com.twentyfouri.tvbridge.global.di
+
+import android.app.Activity
+import dagger.Module
+import dagger.Provides
+
+@Module
+class ActivityModule(
+        private val activity: Activity
+) {
+    @Provides
+    fun provideActivity() =
+            activity
+}

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/di/ApplicationComponent.kt

@@ -0,0 +1,23 @@
+package com.twentyfouri.tvbridge.global.di
+
+import android.content.Context
+import com.twentyfouri.player.base.PlayerFactoryBase
+import com.twentyfouri.tvbridge.common.iap.IapService
+import com.twentyfouri.tvbridge.configuration.BridgeConfig
+import com.twentyfouri.tvbridge.global.BaseApplication
+import com.twentyfouri.tvbridge.global.utils.LocalStorage
+import com.twentyfouri.tvbridge.sound.TouchPlayer
+import dagger.Component
+import javax.inject.Singleton
+
+@Singleton
+@Component(modules = [ApplicationModule::class])
+interface ApplicationComponent {
+    val application: BaseApplication
+    val localStorage: LocalStorage
+    val configuration: BridgeConfig
+    val playerFactory: PlayerFactoryBase
+    val applicationContext: Context
+    val touchPlayer: TouchPlayer
+    val iapService: IapService
+}

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/di/ApplicationModule.kt

@@ -0,0 +1,51 @@
+package com.twentyfouri.tvbridge.global.di
+
+import android.content.Context
+import com.twentyfouri.player.base.PlayerFactoryBase
+import com.twentyfouri.tvbridge.Flavor
+import com.twentyfouri.tvbridge.common.iap.NullIapService
+import com.twentyfouri.tvbridge.configuration.BridgeConfig
+import com.twentyfouri.tvbridge.global.BaseApplication
+import com.twentyfouri.tvbridge.global.utils.LocalStorage
+import com.twentyfouri.tvbridge.global.utils.PlayerFactoryConfigured
+import com.twentyfouri.tvbridge.sound.TouchPlayer
+import dagger.Module
+import dagger.Provides
+import javax.inject.Singleton
+
+@Module
+class ApplicationModule(
+        private val baseApplication: BaseApplication,
+        private val configuration: BridgeConfig
+) {
+    @Provides
+    fun getApplication() = baseApplication
+
+    @Provides
+    fun getConfiguration() = configuration
+
+    @Provides
+    fun provideApplicationContext(): Context = baseApplication
+
+    @Singleton
+    @Provides
+    fun provideLocalStorage() = LocalStorage(baseApplication.applicationContext)
+
+    @Singleton
+    @Provides
+    fun provideTouchPlayer() = TouchPlayer(baseApplication)
+
+    @Singleton
+    @Provides
+    fun provideIapService() = Flavor
+            .iapServiceFactories
+            .firstOrNull { it.detectSupport(baseApplication) }
+            ?.build(baseApplication)
+            ?: NullIapService()
+
+    @Provides
+    @Singleton
+    fun providePlayerFactory(config: BridgeConfig): PlayerFactoryBase =
+        PlayerFactoryConfigured.buildFactory(config, baseApplication)
+
+}

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/di/PerActivity.kt

@@ -0,0 +1,26 @@
+package com.twentyfouri.tvbridge.global.di
+
+import javax.inject.Scope
+
+/*
+ * Copyright (C) 2013 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * A scoping annotation to permit objects whose lifetime should
+ * conform to the life of the activity to be memoized in the
+ * correct component.
+ */
+@Scope
+@kotlin.annotation.Retention(AnnotationRetention.RUNTIME)
+annotation class PerActivity

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/utils/LocalStorage.kt

@@ -0,0 +1,30 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import android.content.Context
+import android.content.SharedPreferences
+
+class LocalStorage(context: Context) {
+
+    private val preferences: SharedPreferences =
+            context.applicationContext.getSharedPreferences(SHARED_PREFERENCES, Context.MODE_PRIVATE)
+
+    fun saveCookieJson(key: String?, value: String?) {
+        val editor = preferences.edit()
+        editor.putString(key, value)
+        editor.apply()
+    }
+
+    fun removeFromLocalStorage(key: String?) {
+        val editor = preferences.edit()
+        editor.remove(key)
+        editor.apply()
+    }
+
+    fun getFromLocalStorage(key: String?): String? {
+        return preferences.getString(key, null)
+    }
+
+    companion object {
+        private const val SHARED_PREFERENCES = "com.twentyfouri.tvbridge"
+    }
+}

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/utils/LoggingDrmCallback.kt

@@ -0,0 +1,38 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import android.util.Base64
+import android.util.Log
+import com.google.android.exoplayer2.drm.ExoMediaDrm
+import com.google.android.exoplayer2.drm.MediaDrmCallback
+import java.util.*
+
+class LoggingDrmCallback(
+        private val base: MediaDrmCallback,
+        private val licenseUrl: String? = null
+) : MediaDrmCallback {
+    override fun executeProvisionRequest(
+            uuid: UUID,
+            request: ExoMediaDrm.ProvisionRequest
+    ): ByteArray {
+        return base.executeProvisionRequest(uuid, request)
+    }
+
+    override fun executeKeyRequest(uuid: UUID, request: ExoMediaDrm.KeyRequest): ByteArray {
+        if (com.twentyfouri.player.exoplayer.BuildConfig.DEBUG) {
+            Log.v(TAG, "DRM Embedded URL: ${request.licenseServerUrl}")
+            Log.v(TAG, "DRM Default URL: $licenseUrl")
+            Log.v(TAG, "DRM request:\n${request.data.toBase64()}")
+        }
+        val response = base.executeKeyRequest(uuid, request)
+        if (com.twentyfouri.player.exoplayer.BuildConfig.DEBUG) {
+            Log.v(TAG, "DRM response:\n" + response.toBase64())
+        }
+        return response
+    }
+
+    private fun ByteArray.toBase64(): String = Base64.encodeToString(this, Base64.DEFAULT)
+
+    companion object {
+        const val TAG = "DrmCallback"
+    }
+}

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/utils/OverriddenHttpMediaDrmCallback.kt

@@ -0,0 +1,134 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import android.net.Uri
+import android.util.Base64
+import android.util.Log
+import com.google.android.exoplayer2.C
+import com.google.android.exoplayer2.drm.ExoMediaDrm
+import com.google.android.exoplayer2.drm.MediaDrmCallback
+import com.google.android.exoplayer2.upstream.DataSourceInputStream
+import com.google.android.exoplayer2.upstream.DataSpec
+import com.google.android.exoplayer2.upstream.HttpDataSource
+import com.google.android.exoplayer2.util.Util
+import com.twentyfouri.tvbridge.BuildConfig
+import org.json.JSONException
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.IOException
+import java.io.InputStreamReader
+import java.net.MalformedURLException
+import java.net.URL
+import java.net.URLEncoder
+import java.util.HashMap
+import java.util.UUID
+
+class OverriddenHttpMediaDrmCallback(
+        private val defaultLicenseUrl: String?,
+        private val forceDefaultLicenseUrl: Boolean,
+        private val dataSourceFactory: HttpDataSource.Factory
+) : MediaDrmCallback {
+
+    @Throws(IOException::class)
+    override fun executeProvisionRequest(uuid: UUID, request: ExoMediaDrm.ProvisionRequest): ByteArray {
+        Log.d(TAG, "executeProvisionRequest")
+        val url = request.defaultUrl + "&signedRequest=" + String(request.data)
+        return executePost(dataSourceFactory, url, ByteArray(0), null)
+    }
+
+    @Throws(Exception::class)
+    override fun executeKeyRequest(uuid: UUID, request: ExoMediaDrm.KeyRequest): ByteArray {
+        Log.d(TAG, "executeKeyRequest")
+        var url: String? = request.licenseServerUrl
+        if (forceDefaultLicenseUrl || url.isNullOrEmpty()) {
+            url = defaultLicenseUrl
+        }
+        val requestProperties: MutableMap<String, String> = HashMap()
+        // Add standard request properties for supported schemes.
+        val contentType = "text/plain"
+        requestProperties["Content-Type"] = contentType
+        if (C.PLAYREADY_UUID == uuid) {
+            requestProperties["SOAPAction"] = "http://schemas.microsoft.com/DRM/2007/03/protocols/AcquireLicense"
+        }
+
+        //adding data to url
+        val challenge = request.data
+        val encoded = URLEncoder.encode(Base64.encodeToString(challenge, Base64.NO_WRAP), "UTF-8")
+        url = appendQuery(url, "_widevineChallenge=$encoded")
+        if (BuildConfig.DEBUG) {
+            Log.d(TAG, "Executing post on url $url with content type $contentType")
+        }
+        return executeGet(url)
+    }
+
+    companion object {
+        private const val TAG = "DrmCallback"
+
+        private fun executeGet(urlString: String): ByteArray {
+            try {
+                val licenserRequest = URL(urlString)
+                val yc = licenserRequest.openConnection()
+                val input = BufferedReader(InputStreamReader(yc.getInputStream()))
+                val builder = StringBuilder()
+                var inputLine: String?
+                while (input.readLine().also { inputLine = it } != null) {
+                    builder.append(inputLine)
+                }
+                input.close()
+                val jsonObject = JSONObject(builder.toString())
+                val container = jsonObject.getJSONObject("getWidevineLicenseResponse")
+                val license = container.getString("license")
+                if (BuildConfig.DEBUG) {
+                    Log.d(TAG, "Finished post: $license")
+                }
+                return Base64.decode(license, Base64.NO_WRAP)
+            } catch (e: MalformedURLException) {
+                e.printStackTrace()
+            } catch (e: IOException) {
+                e.printStackTrace()
+            } catch (e: JSONException) {
+                e.printStackTrace()
+            }
+            return byteArrayOf()
+        }
+
+        @Throws(IOException::class)
+        private fun executePost(
+                dataSourceFactory: HttpDataSource.Factory,
+                url: String,
+                data: ByteArray,
+                requestProperties: Map<String, String>?
+        ): ByteArray {
+            Log.d(TAG, "executePost")
+            val dataSource = dataSourceFactory.createDataSource()
+            if (requestProperties != null) {
+                for ((key, value) in requestProperties) {
+                    dataSource.setRequestProperty(key, value)
+                }
+            }
+            val dataSpec = DataSpec.Builder()
+                .setUri(Uri.parse(url))
+                .setFlags(DataSpec.FLAG_ALLOW_GZIP)
+                .setHttpMethod(DataSpec.HTTP_METHOD_POST)
+                .setHttpBody(data)
+                .setHttpRequestHeaders(requestProperties ?: emptyMap())
+                .build()
+            val inputStream = DataSourceInputStream(dataSource, dataSpec)
+            return try {
+                Util.toByteArray(inputStream)
+            } finally {
+                Util.closeQuietly(inputStream)
+            }
+        }
+
+        fun appendQuery(url: String?, appendQuery: String): String {
+            val oldUri = Uri.parse(url)
+            var newQuery = oldUri.query
+            if (newQuery == null) {
+                newQuery = appendQuery
+            } else {
+                newQuery += "&$appendQuery"
+            }
+            return oldUri.scheme + "://" + oldUri.authority + oldUri.path + "?" + newQuery
+        }
+    }
+}

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/utils/PlayerFactoryBitmovinCustomized.kt

@@ -0,0 +1,19 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import android.app.Application
+import com.twentyfouri.player.bitmovin.NpawConfig
+import com.twentyfouri.player.bitmovin.PlayerBitmovin
+import com.twentyfouri.player.bitmovin.PlayerFactoryBitmovin
+import com.twentyfouri.tvbridge.configuration.BridgeConfig
+
+class PlayerFactoryBitmovinCustomized(config: BridgeConfig, application: Application) :
+    PlayerFactoryBitmovin(
+        config.bitmovinLicense,
+        if (config.npawAccount.isNotEmpty()) {
+            NpawConfig(config.npawAccount, application)
+        } else {
+            null
+        },
+        config.bitmovinAnalytics.ifEmpty { PlayerBitmovin.ANALYTICS_LICENSE_DEFERRED }
+    ),
+    PlayerFactoryVersion

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/utils/PlayerFactoryConfigured.kt

@@ -0,0 +1,37 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import android.app.Application
+import com.twentyfouri.player.base.PlayerFactoryBase
+import com.twentyfouri.tvbridge.configuration.BridgeConfig
+
+object PlayerFactoryConfigured {
+    fun buildFactory(bridgeConfig: BridgeConfig, application: Application): PlayerFactoryBase {
+        var factory: PlayerFactoryBase? = null
+        if (bridgeConfig.bitmovinLicense.isNotEmpty()) {
+            factory = factory ?: buildBitmovinFactory(bridgeConfig, application)
+        }
+        if (bridgeConfig.npawAccount.isNotEmpty()) {
+            factory = factory ?: buildNpawFactory(bridgeConfig)
+        }
+        factory = factory ?: buildExoFactory(bridgeConfig)
+        return factory ?: throw Exception("Cannot create player factory")
+    }
+
+    private fun buildExoFactory(bridgeConfig: BridgeConfig) = try {
+        PlayerFactoryExoPlayerCustomized(bridgeConfig)
+    } catch (e: NoClassDefFoundError) {
+        null
+    }
+
+    private fun buildNpawFactory(bridgeConfig: BridgeConfig) = try {
+        PlayerFactoryExoPlayerNpaw(bridgeConfig)
+    } catch (e: NoClassDefFoundError) {
+        null
+    }
+
+    private fun buildBitmovinFactory(bridgeConfig: BridgeConfig, application: Application) = try {
+        PlayerFactoryBitmovinCustomized(bridgeConfig, application)
+    } catch (e: NoClassDefFoundError) {
+        null
+    }
+}

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/utils/PlayerFactoryExoPlayerCustomized.kt

@@ -0,0 +1,106 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import android.content.Context
+import com.google.android.exoplayer2.C
+import com.google.android.exoplayer2.ExoPlayerLibraryInfo
+import com.google.android.exoplayer2.drm.DefaultDrmSessionManager
+import com.google.android.exoplayer2.drm.DrmSessionManager
+import com.google.android.exoplayer2.drm.FrameworkMediaDrm
+import com.google.android.exoplayer2.drm.MediaDrmCallback
+import com.google.android.exoplayer2.ext.ima.ImaAdsLoader
+import com.google.android.exoplayer2.upstream.HttpDataSource
+import com.google.android.exoplayer2.upstream.LoadErrorHandlingPolicy
+import com.twentyfouri.player.base.DrmPlayready
+import com.twentyfouri.player.base.DrmWidevine
+import com.twentyfouri.player.base.Source
+import com.twentyfouri.player.base.SourceDrm
+import com.twentyfouri.player.base.TimeProvider
+import com.twentyfouri.player.exoplayer.*
+import com.twentyfouri.tvbridge.configuration.BridgeConfig
+
+class PlayerFactoryExoPlayerCustomized(
+    private val config: BridgeConfig
+) : PlayerFactoryExoPlayer(), PlayerFactoryVersion {
+
+    override val engineName: String = "Exoplayer"
+
+    override val engineVersion: String = ExoPlayerLibraryInfo.VERSION
+
+    override fun createSharedComponents(context: Context): SharedComponents =
+            CustomizedSharedComponents(context)
+
+    private inner class CustomizedSharedComponents(context: Context) : DefaultSharedComponents(context) {
+
+        override val drmProvider: DrmSessionManagerProvider by lazy {
+            CustomizedDrmSessionManagerProvider(loadErrorHandlingPolicy)
+        }
+
+        override val applicationName: String
+            get() = config.playerAppName ?: super.applicationName
+
+        override fun buildIsolatedComponents(): PlayerComponents {
+            return CustomizedPlayerComponents(this)
+        }
+
+        override val mainSourceProvider: MediaSourceFactoryProvider by lazy {
+            DefaultMediaSourceFactoryProvider().also {
+                it.useLiveMediaTailorWorkaround = true
+            }
+        }
+
+        override val focusSkipButton: Boolean
+            get() = false
+    }
+
+    private inner class CustomizedPlayerComponents(shared: SharedComponents) : DefaultPlayerComponents(shared) {
+        override val handleAudioFocus: Boolean
+            get() = false
+    }
+
+    private class CustomizedDrmSessionManagerProvider(
+        loadErrorHandlingPolicy: LoadErrorHandlingPolicy
+    ) : DefaultDrmSessionManagerProvider(loadErrorHandlingPolicy) {
+        override fun buildDrmSessionManager(
+            dataSourceFactory: AuthorizedDataSourceProvider,
+            source: Source,
+            sourceDrm: SourceDrm
+        ): DrmSessionManager? {
+            if (sourceDrm is SourceDrmOverridden) {
+                return buildDrmOverridden(dataSourceFactory, sourceDrm)
+            } else {
+                return super.buildDrmSessionManager(dataSourceFactory, source, sourceDrm)
+            }
+        }
+
+        private fun buildDrmOverridden(dataSourceFactory: AuthorizedDataSourceProvider, sourceDrm: SourceDrmOverridden): DrmSessionManager? {
+            val drmUuid = when (sourceDrm.packageName) {
+                DrmWidevine.packageName -> C.WIDEVINE_UUID
+                DrmPlayready.packageName -> C.PLAYREADY_UUID
+                else -> C.UUID_NIL
+            }
+            val licenseUrl = sourceDrm.licenseServer?.toString() ?: ""
+            val forceLicenseUrl = sourceDrm.forceLicenseServer
+            val httpDataSourceFactory = dataSourceFactory.buildHttpDataSourceFactory(sourceDrm.authorization)
+
+            val drmCallback = LoggingDrmCallback(
+                    OverriddenHttpMediaDrmCallback(
+                            licenseUrl,
+                            forceLicenseUrl,
+                            httpDataSourceFactory
+                    ),
+                    licenseUrl
+            )
+
+            return DefaultDrmSessionManager.Builder()
+                    .setUuidAndExoMediaDrmProvider(drmUuid, FrameworkMediaDrm.DEFAULT_PROVIDER)
+                    .setMultiSession(false)
+                    .setLoadErrorHandlingPolicy(loadErrorHandlingPolicy)
+                    .build(drmCallback)
+        }
+
+        override fun buildDrmCallback(licenseUrl: String, forceLicenseUrl: Boolean, httpDataSourceFactory: HttpDataSource.Factory): MediaDrmCallback {
+            return LoggingDrmCallback(super.buildDrmCallback(licenseUrl, forceLicenseUrl, httpDataSourceFactory), licenseUrl)
+        }
+    }
+}
+