@24i/smartapps-bigscreen-rnv-build-engine 0.17.2-alpha.2154 → 0.17.2-alpha.2155

package/dist/templates/platforms/androidtv/project/app/src/main/java/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/androidtv/project/app/src/main/java/com/twentyfouri/tvbridge/global/utils/HttpMediaDrmCallback.kt

@@ -0,0 +1,184 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import android.net.Uri
+import android.text.TextUtils
+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.upstream.DataSourceInputStream
+import com.google.android.exoplayer2.upstream.DataSpec
+import com.google.android.exoplayer2.upstream.HttpDataSource
+import com.google.android.exoplayer2.util.Assertions
+import com.google.android.exoplayer2.util.Util
+import com.twentyfouri.smartexoplayer.drm.SmartMediaDrmCallback
+import com.twentyfouri.smartexoplayer.model.DrmConfiguration
+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 HttpMediaDrmCallback(
+        private val defaultLicenseUrl: String?,
+        private val forceDefaultLicenseUrl: Boolean,
+        private val dataSourceFactory: HttpDataSource.Factory
+) : SmartMediaDrmCallback {
+
+    private val keyRequestProperties = HashMap<String, String>()
+
+    /**
+     * @param defaultLicenseUrl The default license URL. Used for key requests that do not specify
+     * their own license URL.
+     * @param dataSourceFactory A factory from which to obtain [HttpDataSource] instances.
+     */
+    constructor(defaultLicenseUrl: String, dataSourceFactory: HttpDataSource.Factory) : this(defaultLicenseUrl, false, dataSourceFactory) {}
+
+    /**
+     * Sets a header for key requests made by the callback.
+     *
+     * @param name The name of the header field.
+     * @param value The value of the field.
+     */
+    override fun setKeyRequestProperty(name: String, value: String) {
+        Log.d(TAG, "setKeyRequestProperty")
+        Assertions.checkNotNull(name)
+        Assertions.checkNotNull(value)
+        synchronized(keyRequestProperties) { keyRequestProperties.put(name, value) }
+    }
+
+    /**
+     * Clears a header for key requests made by the callback.
+     *
+     * @param name The name of the header field.
+     */
+    override fun clearKeyRequestProperty(name: String) {
+        Log.d(TAG, "clearKeyRequestProperty")
+        Assertions.checkNotNull(name)
+        synchronized(keyRequestProperties) { keyRequestProperties.remove(name) }
+    }
+
+    /**
+     * Clears all headers for key requests made by the callback.
+     */
+    override fun clearAllKeyRequestProperties() {
+        Log.d(TAG, "clearAllKeyRequestProperties")
+        synchronized(keyRequestProperties) { keyRequestProperties.clear() }
+    }
+
+    @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"
+        }
+        // Add additional request properties.
+        synchronized(keyRequestProperties) { requestProperties.putAll(keyRequestProperties) }
+
+        //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)
+    }
+
+    class Factory(
+            private val licenseUrl: String?,
+            private val forceDefaultUrl: Boolean
+    ) : SmartMediaDrmCallback.Factory {
+        override fun build(drm: DrmConfiguration, dataSourceFactory: HttpDataSource.Factory): SmartMediaDrmCallback =
+                HttpMediaDrmCallback(licenseUrl, forceDefaultUrl, dataSourceFactory)
+    }
+
+    companion object {
+        private const val TAG = "DrmCallback"
+
+        private fun executeGet(urlString: String): ByteArray {
+            var licenserRequest: URL? = null
+            try {
+                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(Uri.parse(url), data, 0, 0, C.LENGTH_UNSET.toLong(), null,
+                    DataSpec.FLAG_ALLOW_GZIP)
+            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/androidtv/project/app/src/main/java/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/androidtv/project/app/src/main/java/com/twentyfouri/tvbridge/global/utils/LoggingDrmCallback.kt

@@ -0,0 +1,46 @@
+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.upstream.HttpDataSource
+import com.twentyfouri.smartexoplayer.drm.SmartHttpMediaDrmCallback
+import com.twentyfouri.smartexoplayer.drm.SmartMediaDrmCallback
+import com.twentyfouri.smartexoplayer.model.DrmConfiguration
+import com.twentyfouri.tvbridge.BuildConfig
+import java.util.*
+
+class LoggingDrmCallback(
+        private val licenseUrl: String?,
+        forceDefaultUrl: Boolean,
+        dataSourceFactory: HttpDataSource.Factory
+) : SmartHttpMediaDrmCallback(licenseUrl, forceDefaultUrl, dataSourceFactory) {
+
+    @Throws(Exception::class)
+    override fun executeKeyRequest(uuid: UUID, request: ExoMediaDrm.KeyRequest): ByteArray {
+        if (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 = super.executeKeyRequest(uuid, request)
+        if (BuildConfig.DEBUG) {
+            Log.v(TAG, "DRM response:\n" + response.toBase64())
+        }
+        return response
+    }
+
+    private fun ByteArray.toBase64(): String = Base64.encodeToString(this, Base64.DEFAULT)
+
+    class Factory(
+            private val licenseUrl: String?,
+            private val forceDefaultUrl: Boolean
+    ) : SmartMediaDrmCallback.Factory {
+        override fun build(drm: DrmConfiguration, dataSourceFactory: HttpDataSource.Factory): SmartMediaDrmCallback =
+                LoggingDrmCallback(licenseUrl, forceDefaultUrl, dataSourceFactory)
+    }
+
+    companion object {
+        private const val TAG = "DrmCallback"
+    }
+}

package/dist/templates/platforms/androidtv/project/app/src/main/java/com/twentyfouri/tvbridge/global/utils/SimpleActivityLifecycleCallback.kt

@@ -0,0 +1,32 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import android.app.Activity
+import android.app.Application.ActivityLifecycleCallbacks
+import android.os.Bundle
+
+abstract class SimpleActivityLifecycleCallback : ActivityLifecycleCallbacks {
+
+    override fun onActivityStarted(activity: Activity) {
+        //Do nothing
+    }
+
+    override fun onActivityResumed(activity: Activity) {
+        //Do nothing
+    }
+
+    override fun onActivityPaused(activity: Activity) {
+        //Do nothing
+    }
+
+    override fun onActivityStopped(activity: Activity) {
+        //Do nothing
+    }
+
+    override fun onActivitySaveInstanceState(activity: Activity, bundle: Bundle) {
+        //Do nothing
+    }
+
+    override fun onActivityDestroyed(activity: Activity) {
+        //Do nothing
+    }
+}

package/dist/templates/platforms/androidtv/project/app/src/main/java/com/twentyfouri/tvbridge/jump/JumpAnalytics.kt

@@ -0,0 +1,209 @@
+package com.twentyfouri.tvbridge.jump
+
+import android.util.Log
+import com.google.android.exoplayer2.SimpleExoPlayer
+import com.google.gson.JsonObject
+import com.twentyfouri.tvbridge.BuildConfig
+import com.twentyfouri.tvbridge.webview.model.AnalyticsPlaybackInfo
+import jump.JumpKit
+import jump.insights.models.contextinformation.*
+import jump.insights.models.track.events.JKContentType
+import jump.insights.models.track.events.JKTransactionType
+import jump.libs.gson.annotations.SerializedName
+import java.util.*
+
+class JumpAnalytics {
+
+    private var started = false
+    private var hasContent = false
+
+    fun setPlaybackInfo(playbackInfo: AnalyticsPlaybackInfo) {
+        setApplicationId(playbackInfo.id ?: return)
+        setUserInfo(playbackInfo.userInfo)
+        setContentInfo(playbackInfo.contentInfo)
+    }
+
+    private fun setApplicationId(applicationId: String) {
+        if (started) return
+        started = true
+        JumpKit.setDebugMode(BuildConfig.DEBUG)
+        JumpKit.start(applicationId)
+    }
+
+    private fun setUserInfo(params: JsonObject?) {
+        JumpKit.insights.setUserInfo(parseUserInfo(params))
+    }
+
+    private fun setContentInfo(params: JsonObject?) {
+        val contentInfo = parseContentInfo(params)
+        jump.exoplayerextension.JumpKit.insights.setContentInfo(contentInfo)
+        hasContent = true
+    }
+
+    fun setVideoPlayer(player: SimpleExoPlayer?) {
+        if (player == null) {
+            /* NOTICE: passing null also causes insights.setContentInfo(null) */
+            jump.exoplayerextension.JumpKit.insights.setVideoPlayer(null)
+            hasContent = false
+        } else if (started && hasContent) {
+            jump.exoplayerextension.JumpKit.insights.setVideoPlayer(player)
+        } else if (started) {
+            Log.w("JumpAnalytics", "No content data available. Did you call SetPlaybackInfo before SetVideoPath?")
+        }
+    }
+
+    private fun parseUserInfo(params: JsonObject?): JKUserInfo {
+        return try {
+            var userType = parseEnum(params, "userType", JKUserType::class.java)
+            if (userType == null) userType = JKUserType.ANONYMOUS
+            val userId = parseString(params, "userId")
+            val userCountry = parseString(params, "userCountry")
+            val userBirthDate = parseString(params, "userBirthDate")
+            var userSex = parseEnum(params, "userSex", JKUserSex::class.java)
+            if (userSex == null) userSex = JKUserSex.UNDEFINED
+            val userProfileId = parseString(params, "userProfileId")
+            val userOperator = parseString(params, "userOperator")
+            if (userType == JKUserType.ANONYMOUS) JKUserInfo.anonymousInstance() else JKUserInfo(userType, userId, userCountry, userBirthDate, userSex, userProfileId, userOperator)
+        } catch (e: Exception) {
+            Log.w("JumpAnalytics", "Parsing userInfo failed. Falling back to ANONYMOUS", e)
+            JKUserInfo.anonymousInstance()
+        }
+    }
+
+    private fun parseCategory(params: JsonObject?, property: String): JKContextCategory? {
+        val jsonValue = params?.get(property) ?: return null
+        return if (!jsonValue.isJsonObject) null else parseCategory(jsonValue.asJsonObject)
+    }
+
+    private fun parseCategory(params: JsonObject): JKContextCategory {
+        return JKContextCategory(
+                parseString(params, "categoryId"),
+                parseString(params, "categoryName")
+        )
+    }
+
+    private fun parseSubCategory(params: JsonObject?, property: String): JKContextSubcategory? {
+        val jsonValue = params?.get(property) ?: return null
+        return if (!jsonValue.isJsonObject) null else parseSubCategory(jsonValue.asJsonObject)
+    }
+
+    private fun parseSubCategory(params: JsonObject): JKContextSubcategory {
+        return JKContextSubcategory(
+                parseString(params, "subcategoryId"),
+                parseString(params, "categoryId"),
+                parseString(params, "subcategoryName")
+        )
+    }
+
+    private fun parseGenre(params: JsonObject): JKContextGenre {
+        return JKContextGenre(
+                parseString(params, "genreId"),
+                parseString(params, "genreName"),
+                parseCategory(params, "categoryId"),
+                parseSubCategory(params, "subCategoryId")
+        )
+    }
+
+    private fun parseContentInfo(params: JsonObject?): JKContextContent {
+        return JKContextContent(
+                parseString(params, "contentId"),
+                parseString(params, "contentTitle"),
+                parseString(params, "contentSerieTitle"),
+                parseInteger(params, "contentEpisodeNumber"),
+                parseInteger(params, "contentSeasonNumber"),
+                parseString(params, "contentDescription"),
+                parseCategory(params, "contentCategory"),
+                parseSubCategory(params, "contentSubCategory"),
+                parseGenres(params, "contentGenres"),
+                parseString(params, "contentProvider"),
+                parseEnum(params, "contentTransactionType", JKTransactionType::class.java),
+                parseEnum(params, "contentType", JKContentType::class.java),
+                parseString(params, "contentLanguage")
+        )
+    }
+
+    private fun parseGenres(container: JsonObject?, property: String): List<JKContextGenre>? {
+        if (container == null) return null
+        val jsonValue = container[property] ?: return null
+        if (!jsonValue.isJsonArray) return null
+        val list = ArrayList<JKContextGenre>()
+        for (jsonElement in jsonValue.asJsonArray) {
+            if (!jsonElement.isJsonObject) continue
+            list.add(parseGenre(jsonElement.asJsonObject))
+        }
+        return list
+    }
+
+    private fun <T : Enum<T>> parseEnum(container: JsonObject?, property: String, type: Class<T>): T? {
+        if (container == null) return null
+        val jsonValue = container[property] ?: return null
+        if (!jsonValue.isJsonPrimitive) return null
+        val primitive = jsonValue.asJsonPrimitive
+        return when {
+            primitive.isString ->
+                parseEnum(type, jsonValue.asString)
+            primitive.isNumber ->
+                parseEnum(type, jsonValue.asInt)
+            else ->
+                null
+        }
+    }
+
+    private fun <T : Enum<T>> parseEnum(type: Class<T>, value: String): T? {
+        try {
+            for (constant in type.enumConstants ?: return null) {
+                val name = constant.name
+                if (name == value) {
+                    return constant
+                }
+                val annotation = type.getField(name).getAnnotation(SerializedName::class.java)
+                if (annotation != null) {
+                    if (annotation.value == value) {
+                        return constant
+                    }
+                }
+            }
+            return null
+        } catch (e: NoSuchFieldException) {
+            return null
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun <T : Enum<T>> parseEnum(type: Class<T>, value: Int): T? {
+        return try {
+            val map = type.getDeclaredField("mapper")[null] as Map<T, Int>
+            for ((key, value1) in map) {
+                if (value1 == value) {
+                    return key
+                }
+            }
+            null
+        } catch (e: ClassCastException) {
+            null
+        } catch (e: IllegalAccessException) {
+            null
+        } catch (e: NoSuchFieldException) {
+            null
+        }
+    }
+
+    private fun parseString(container: JsonObject?, property: String): String? {
+        if (container == null) return null
+        var jsonValue = container[property]
+        if (jsonValue == null && property.endsWith("Id")) {
+            // inconsistencies in SDK cause confusion, try uppercased xxxxID just in case
+            jsonValue = container[property.replace("Id", "ID")]
+        }
+        if (jsonValue == null) return null
+        if (!jsonValue.isJsonPrimitive) return null
+        return if (!jsonValue.asJsonPrimitive.isString) null else jsonValue.asString
+    }
+
+    private fun parseInteger(container: JsonObject?, property: String): Int? {
+        if (container == null) return null
+        val jsonValue = container[property] ?: return null
+        if (!jsonValue.isJsonPrimitive) return null
+        return if (!jsonValue.asJsonPrimitive.isNumber) null else jsonValue.asInt
+    }
+}

package/dist/templates/platforms/androidtv/project/app/src/main/java/com/twentyfouri/tvbridge/sound/TouchPlayer.kt

@@ -0,0 +1,86 @@
+package com.twentyfouri.tvbridge.sound
+
+import android.content.Context
+import android.media.AudioManager
+import android.media.MediaPlayer
+import android.provider.MediaStore
+import android.util.Log
+import androidx.annotation.IntRange
+import androidx.annotation.RawRes
+import com.twentyfouri.tvbridge.R
+
+/**
+ * Play touch sound. Uses queue to handle several overlapping sounds
+ * Configuration:
+ *      MEDIA_PLAYER_LIST_SIZE: Number of parallel touch sounds that can be played at once
+ *      TOUCH_SOUND_RES: Resource ID of touch sound to be used
+ *      USE_NATIVE_SOUND: Uses native click sound from AudioManager, don't use overlapping & queue at all
+ */
+class TouchPlayer(
+        private val context: Context
+) : MediaPlayer.OnCompletionListener {
+
+    companion object {
+        private const val MEDIA_PLAYER_LIST_SIZE = 1L
+        @RawRes
+        private const val TOUCH_SOUND_RES = R.raw.click
+        private const val USE_NATIVE_SOUND = true
+        private var audioManager: AudioManager? = null
+    }
+
+    private var mediaPlayerList = mutableListOf<MediaPlayer>()
+
+    @IntRange(from = 0, to = MEDIA_PLAYER_LIST_SIZE - 1)
+    private var mediaPlayerListIterator: Int = 0
+
+    init {
+        for (i in 0 until Companion.MEDIA_PLAYER_LIST_SIZE) {
+            mediaPlayerList.add(getNewPlayer())
+        }
+        if (USE_NATIVE_SOUND) {
+            audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        }
+    }
+
+    fun play() {
+        Log.d("TouchPlayer", "Touch event envoked")
+        audioManager?.playSoundEffect(AudioManager.FX_KEY_CLICK)
+                ?: getAvailableMediaPlayer()?.start()
+    }
+
+    override fun onCompletion(mp: MediaPlayer) {
+        if (mp in mediaPlayerList) {
+            mediaPlayerList[mediaPlayerList.indexOf(mp)] = getNewPlayer()
+            mp.release()
+        }
+    }
+
+    /**
+     * Returns available player from buffer. If there is no available player already, it returns null
+     */
+    private fun getAvailableMediaPlayer(): MediaPlayer? {
+        val nextIter = if (MEDIA_PLAYER_LIST_SIZE.toInt() == 1) {
+            mediaPlayerListIterator
+        } else {
+            ++mediaPlayerListIterator / MEDIA_PLAYER_LIST_SIZE.toInt()
+        }
+        val selectedPlayer = mediaPlayerList[mediaPlayerListIterator]
+
+        return if (selectedPlayer.isPlaying) {  // We reached the end of available buffer
+            null
+        } else {
+            mediaPlayerListIterator = nextIter
+            selectedPlayer
+        }
+    }
+
+    private fun getNewPlayer(): MediaPlayer {
+        val mediaPlayer = MediaPlayer()
+        mediaPlayer.setAudioStreamType(AudioManager.STREAM_SYSTEM)
+        mediaPlayer.setOnCompletionListener(this)
+        val afd = context.resources.openRawResourceFd(TOUCH_SOUND_RES)
+        mediaPlayer.setDataSource(afd.fileDescriptor, afd.startOffset, afd.length)
+        mediaPlayer.prepare()
+        return mediaPlayer
+    }
+}