@24i/smartapps-bigscreen-rnv-build-engine 0.17.2 → 0.17.3-alpha.1

package/dist/templates/platforms/androidtv/project/app/src/main/java/com/twentyfouri/tvbridge/webview/viewmodel/WebViewModel.kt

@@ -0,0 +1,609 @@
+package com.twentyfouri.tvbridge.webview.viewmodel
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.net.Uri
+import android.os.Build
+import android.util.Log
+import android.view.KeyEvent
+import android.view.View
+import android.webkit.CookieManager
+import android.webkit.WebChromeClient
+import android.webkit.WebView
+import androidx.databinding.BaseObservable
+import androidx.databinding.Bindable
+import com.google.android.exoplayer2.C
+import com.google.android.exoplayer2.SeekParameters
+import com.google.gson.JsonArray
+import com.google.gson.JsonObject
+import com.twentyfouri.player.base.*
+import com.twentyfouri.player.exoplayer.PlayerExoPlayer
+import com.twentyfouri.tvbridge.BR
+import com.twentyfouri.tvbridge.BuildConfig
+import com.twentyfouri.tvbridge.Flavor
+import com.twentyfouri.tvbridge.bridge.BridgeFromJavaScript
+import com.twentyfouri.tvbridge.bridge.BridgeToJavaScript
+import com.twentyfouri.tvbridge.common.*
+import com.twentyfouri.tvbridge.configuration.BridgeConfig
+import com.twentyfouri.tvbridge.global.utils.LocalStorage
+import com.twentyfouri.tvbridge.global.utils.SourceDrmOverridden
+import com.twentyfouri.tvbridge.jump.JumpAnalytics
+import com.twentyfouri.tvbridge.webview.client.BridgeWebView
+import com.twentyfouri.tvbridge.webview.client.BridgeWebViewClient
+import com.twentyfouri.tvbridge.webview.client.BridgeWebViewClient.BridgeWebViewClientCallback
+import com.twentyfouri.tvbridge.webview.model.AnalyticsPlaybackInfo
+import com.twentyfouri.tvbridge.webview.model.ContentModel
+import com.twentyfouri.tvbridge.webview.model.DrmModel
+import com.twentyfouri.tvbridge.webview.model.MediaEventType
+import com.twentyfouri.tvbridge.webview.view.Mainview
+import com.twentyfouri.tvbridge.webview.view.PlayerCache
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+import java.net.NetworkInterface
+import java.net.URI
+import javax.inject.Inject
+
+/**
+ * Created by destivar on 15/02/16.
+ */
+class WebViewModel @Inject constructor(
+        private val context: Context,
+        private val localStorage: LocalStorage,
+        private val config: BridgeConfig,
+        private val iapService: IapService,
+        val playerFactory: PlayerFactoryBase
+) : BaseObservable(), EventListener {
+    var player: PlayerBase? = null
+    private var view: Mainview? = null
+    private val jsBridge = BridgeToJavaScript(config) { s: String? ->
+        view?.loadUrl(s)
+    }
+    private val iapCallback = InnerIapCallback()
+    private val playerCache = PlayerCache()
+    private val jumpAnalytics = JumpAnalytics()
+
+    private var contentModel: ContentModel? = null
+
+    val audioTrack: AudioTrack?
+        get() = player?.selectedAudioTrack
+    val subtitleTrack: TextTrack?
+        get() = player?.selectedTextTrack
+
+    var appUrl: String? = null
+
+    var urlSetterVisible: Boolean = false
+        set(value) {
+            if (field == value) return
+            field = value
+            notifyPropertyChanged(BR.urlSetterVisibility)
+        }
+
+    @get:Bindable
+    val urlSetterVisibility: Int
+        get() = if (urlSetterVisible) View.VISIBLE else View.GONE
+
+    fun attachView(view: Mainview?) {
+        this.view = view
+        if (view != null) {
+            iapService.initialize()
+            checkNewPurchases()
+        }
+    }
+
+    fun configureWebView(webView: BridgeWebView) {
+
+        // Enable remote debugging on devices at API level 19 (KitKat) or higher.
+        if (BuildConfig.DEBUG) {
+            WebView.setWebContentsDebuggingEnabled(true)
+        }
+
+        // Add the JavaScript bridge.
+        webView.addJavascriptInterface(BridgeFromJavaScript(this), JAVA_SCRIPT_BRIDGE)
+
+        // WebView callback methods.
+        webView.webViewClient = BridgeWebViewClient(object : BridgeWebViewClientCallback {
+            override fun onUnhandledKeyEvent(view: WebView, event: KeyEvent) {
+                if (event.action == KeyEvent.ACTION_DOWN) {
+                    sendKeyCode(event.keyCode, MediaEventType.KEY_DOWN)
+                } else if (event.action == KeyEvent.ACTION_UP) {
+                    sendKeyCode(event.keyCode, MediaEventType.KEY_UP)
+                }
+            }
+        })
+
+        webView.webChromeClient = object : WebChromeClient() {
+            override fun getDefaultVideoPoster(): Bitmap? {
+                val bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.RGB_565)
+                val canvas = Canvas(bitmap)
+                canvas.drawARGB(255, 0, 0, 0)
+                return bitmap
+            }
+
+            override fun onShowCustomView(view: View, callback: CustomViewCallback) {
+                val intent = Intent(Intent.ACTION_SEND)
+                intent.type = "video/*"
+                context.startActivity(intent)
+            }
+
+            override fun onHideCustomView() {}
+        }
+
+        webView.previewKeyEvent = this::dispatchKeyEvent
+
+        CookieManager.getInstance().setAcceptCookie(true)
+        CookieManager.getInstance().setAcceptThirdPartyCookies(webView, true)
+    }
+
+    fun onClickGo() {
+        view?.loadUrl(appUrl)
+        urlSetterVisible = false
+        if (BuildConfig.DEBUG) {
+            view?.hideKeyboard()
+        }
+    }
+
+    fun setVideo(contentModel: ContentModel) {
+        logContentModel(contentModel)
+        playDirectly(contentModel)
+    }
+
+    private fun logContentModel(contentModel: ContentModel) {
+        Log.i("BridgeVideo", "Url: " + contentModel.streamUrl)
+        val drmModel = contentModel.drmModel
+        if (drmModel != null) {
+            Log.i("BridgeVideo", "DRM: " + drmModel.drmSchemeUuid)
+            Log.i("BridgeVideo", "LicenseUrl: " + drmModel.drmLicenseUrl)
+        }
+    }
+
+    private fun playInExoPlayerDemoApp(contentModel: ContentModel) {
+        val intent = Intent("com.google.android.exoplayer.demo.action.VIEW", Uri.parse(contentModel.streamUrl))
+        val drmModel = contentModel.drmModel
+        if (drmModel != null) {
+            intent.putExtra("drm_scheme", drmModel.drmSchemeUuid)
+            intent.putExtra("drm_license_url", drmModel.drmLicenseUrl)
+        }
+        try {
+            context.startActivity(intent)
+        } catch (e: Exception) {
+            Log.w("WebViewModel", "Failed to start ExoPlayer demo app", e)
+        }
+    }
+
+    private fun playDirectly(contentModel: ContentModel) {
+        this.contentModel = contentModel
+        (player as? PlayerExoPlayer)?.exoPlayer?.also { exoPlayer ->
+            jumpAnalytics.setVideoPlayer(exoPlayer)
+            exoPlayer.setSeekParameters(SeekParameters.CLOSEST_SYNC)
+        }
+        player?.also { player ->
+            player.source = Source {
+                url = contentModel.streamUrl?.let { URI(it) }
+                mimeType = detectMimeType(contentModel)
+                contentModel.drmModel?.let { buildDrm(it) }?.also { drm.add(it) }
+            }
+
+            if (isLowEndDevice) {
+                player.trackRestrictions = player.trackRestrictions.buildUpon {
+                    maxBitrate = LOW_END_DEVICE_MAX_BITRATE
+                }
+            } else if (config.startWithHighVideoQuality) {
+                player.trackRestrictions = player.trackRestrictions.buildUpon {
+                    abrStrategy = AbrStrategy.QUALITY
+                }
+            }
+
+            player.addEventListener(Event.ALL, this)
+
+            player.autoPlay = true
+            player.load()
+            player.play()
+        }
+    }
+
+    private fun detectMimeType(contentModel: ContentModel) =
+            when (contentModel.streamType) {
+                null, "" -> null
+                ".mpd", "mpd", "dash" -> ManifestDash.mimeType
+                ".ism", "ism", "ss" -> ManifestSmoothStreaming.mimeType
+                ".m3u8", "m3u8", "hls" -> ManifestHls.mimeType
+                else -> null
+            }
+
+    private fun buildDrm(drmModel: DrmModel): SourceDrm? {
+        val drmScheme = drmModel.drmSchemeUuid
+        val useOverride = drmModel.overrideDrmCallback ?: config.drm.shouldOverrideDrmCallback()
+        val useWidevine = drmScheme == "widevine" || drmScheme == C.WIDEVINE_UUID.toString()
+        val usePlayReady = drmScheme == "playready" || drmScheme == C.PLAYREADY_UUID.toString()
+        return when {
+            drmScheme == null -> null
+            useOverride -> SourceDrmOverridden {
+                packageName = when {
+                    useWidevine -> DrmWidevine.packageName
+                    usePlayReady -> DrmPlayready.packageName
+                    else -> ""
+                }
+                licenseServer = drmModel.drmLicenseUrl?.let { URI(it) }
+                forceLicenseServer = true
+            }
+            useWidevine -> SourceDrmWidevine {
+                licenseServer = drmModel.drmLicenseUrl?.let { URI(it) }
+                forceLicenseServer = true
+            }
+            usePlayReady -> SourceDrmWidevine {
+                licenseServer = drmModel.drmLicenseUrl?.let { URI(it) }
+                forceLicenseServer = true
+            }
+            else -> SourceDrmUnrecognized(drmScheme)
+        }
+    }
+
+    private val isLowEndDevice: Boolean
+        get() = when (Build.MODEL) {
+            "AFTB" -> true
+            "AFTM" -> true
+            else -> false
+        }
+
+    fun startPlayer() {
+        player?.play()
+    }
+
+    fun resumePlayer() {
+        val savedContentModel = playerCache.savedContentModel
+        if (playerCache.loadFromCache && savedContentModel != null && playerCache.savedPlayerState !== PlayerCache.PlayerState.PAUSED) {
+            setVideo(savedContentModel)
+            var position = playerCache.savedPlayerPosition
+            val player = this.player ?: return
+            if (player.live) {
+                position = 0.0
+            }
+            player.seek(position)
+            view?.requestAudioFocus()
+            if (playerCache.savedPlayerState === PlayerCache.PlayerState.PLAYING) {
+                player.play()
+            }
+        } else {
+            if (player?.live == true) {
+                player?.seek(0.0)
+            }
+            player?.play()
+        }
+    }
+
+    fun pausePlayer() {
+        player?.pause()
+    }
+
+    fun stopPlayer() {
+        view?.setBlackCurtainVisibility(View.VISIBLE)
+        contentModel = null
+
+        player?.also { player ->
+            player.removeEventListener(Event.ALL, this)
+            player.unload()
+            jumpAnalytics.setVideoPlayer(null)
+        }
+    }
+
+    fun releasePlayer() {
+        val player = this.player ?: return
+        if (contentModel != null) {
+            playerCache.loadFromCache = true
+            playerCache.savedContentModel = contentModel
+            playerCache.savedPlayerDuration = player.duration
+            playerCache.savedPlayerPosition = player.currentTime
+            playerCache.savedPlayerState = if (player.playing) PlayerCache.PlayerState.PLAYING else PlayerCache.PlayerState.PAUSED
+        }
+        player.unload()
+        jumpAnalytics.setVideoPlayer(null)
+    }
+
+    val currentPosition: Double
+        get() = player?.currentTime ?: playerCache.savedPlayerPosition
+    val duration: Double
+        get() = player?.duration ?: playerCache.savedPlayerDuration
+
+    fun seekToPosition(position: Double) {
+        player?.seek(position)
+    }
+
+    val isPlayerPlaying: Boolean
+        get() = player?.playing == true
+    val isInPlayer: Boolean
+        get() = player != null && contentModel != null
+
+    fun loadUrl(url: String?) {
+        view?.loadUrl(url)
+    }
+
+    fun setSubtitlesVisibility(visibility: Boolean) {
+        val player = this.player ?: return
+        if (visibility) {
+            player.trackRestrictions = player.trackRestrictions.buildUpon {
+                enableCaptions = true
+            }
+            if (player.textTrack?.kind == TrackKind.EMPTY) {
+                player.textTrack = null
+            }
+        } else {
+            player.trackRestrictions = player.trackRestrictions.buildUpon {
+                enableCaptions = false
+            }
+            player.textTrack = player.textTracks.firstOrNull { it.kind == TrackKind.EMPTY }
+                ?: DISABLED_TEXT_TRACK
+        }
+    }
+
+    fun enableFullScreen() {
+        view?.goFullscreen()
+    }
+
+    fun disableFullScreen(width: Int, height: Int, left: Int, top: Int) {
+        view?.exitFullscreen(width, height, left, top)
+    }
+
+    override fun onEvent(event: Event) {
+        val player = this.player ?: return
+        when (event) {
+            is ErrorEvent -> {
+                Log.e("AndroidPlayer", "Player error", event.error)
+                jsBridge.bridgeAndroidToJavaScript_ErrorEvent(MediaEventType.ERROR, "${event.error.message} - ${event.error.nativeCode}")
+                stopPlayer()
+            }
+            is EndedEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.ENDED)
+            }
+            is WaitingEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.WAITING)
+            }
+            is PlayingEvent -> {
+                view?.setBlackCurtainVisibility(View.GONE)
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.PLAYING)
+            }
+            is SeekedEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.SEEKED)
+            }
+            is TimeUpdateEvent -> {
+                if (player.playing) {
+                    jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.TIME_UPDATE)
+                }
+            }
+            is PauseEvent -> {
+                if (!player.playing) {
+                    jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.PAUSE)
+                }
+            }
+            is LoadedMetadataEvent,
+            is AddAudioTrackEvent, is AddTextTrackEvent,
+            is RemoveAudioTrackEvent, is RemoveTextTrackEvent,
+            is ChangeAudioTrackEvent, is ChangeTextTrackEvent -> {
+                Log.d("WebViewModel", "onTracksChanged: audio=$audioTrack subtitle=$subtitleTrack")
+                jsBridge.bridgeAndroidToJavaScript_MediaTrackEvent(MediaEventType.TRACKS_CHANGED, player.audioTracks, player.textTracks)
+            }
+        }
+    }
+
+    fun setSubtitleTrack(track: TextTrack?) {
+        player?.textTrack = track
+    }
+
+    fun setAudioTrack(track: AudioTrack?) {
+        player?.audioTrack = track
+    }
+
+    fun saveToLocalStorage(key: String?, value: String?) {
+        localStorage.saveCookieJson(key, value)
+    }
+
+    fun getFromLocalStorage(key: String?): String? {
+        return localStorage.getFromLocalStorage(key)
+    }
+
+    fun removeFromLocalStorage(key: String?) {
+        localStorage.removeFromLocalStorage(key)
+    }
+
+    fun sendKeyCode(keyCode: Int, mediaEventType: String) {
+        jsBridge.bridgeAndroidToJavaScript_KeyEvent(keyCode, mediaEventType)
+    }
+
+    fun setPlaybackInfo(playbackInfo: AnalyticsPlaybackInfo) {
+        if ("JUMP" == playbackInfo.name) {
+            jumpAnalytics.setPlaybackInfo(playbackInfo)
+        }
+    }
+
+    fun showMessage(message: String?) {
+        view?.showMessage(message)
+    }
+
+    fun requestAudioFocus(): Int? {
+        return view?.requestAudioFocus()
+    }
+
+    fun abandonAudioFocus() {
+        view?.abandonAudioFocus()
+    }
+
+    fun onBackPressed() {
+        stopPlayer()
+        view?.onBackPressed()
+        loadUrl(appUrl)
+    }
+
+    fun signData(dataJson: String?): String? {
+        return if (dataJson == null || dataJson.isEmpty()) "" else Flavor().signData(context, dataJson)
+    }
+
+    fun launchIapPurchase(sku: String?) {
+        if (sku == null || sku.isEmpty()) return
+        view?.launchIapPurchase(sku)
+    }
+
+    fun checkNewPurchases() {
+        iapService.setCallback(iapCallback)
+        iapService.checkNewPurchases()
+    }
+
+    fun launchIapPurchase(activity: Activity, sku: String) {
+        iapService.setCallback(iapCallback)
+        iapService.purchase(activity, sku)
+    }
+
+    fun getIapProductDetails(skus: List<String>) {
+        iapService.setCallback(iapCallback)
+        iapService.getProducts(skus)
+    }
+
+    fun acknowledgeIapReceipt(receiptId: String) {
+        iapService.setCallback(iapCallback)
+        iapService.acknowledgeReceipt(receiptId)
+    }
+
+    private fun dispatchKeyEvent(event: KeyEvent): Boolean {
+        // pause and stop events should be caught only when we are in player
+        // -> because we want to let user have option to pause/stop some background playback
+        if (isInPlayer) {
+            // we have to catch all media events, otherwise they will be unhandled and reported in onUnhandledKeyEvent
+            // -> and later sent to broadcast receivers of other media apps, which can resume stream/audio from background app
+            when (event.keyCode) {
+                KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE,
+                KeyEvent.KEYCODE_MEDIA_STOP,
+                KeyEvent.KEYCODE_MEDIA_PAUSE -> {
+                    if (event.action == KeyEvent.ACTION_DOWN) {
+                        jsBridge.bridgeAndroidToJavaScript_KeyEvent(event.keyCode, MediaEventType.KEY_DOWN)
+                    } else if (event.action == KeyEvent.ACTION_UP) {
+                        jsBridge.bridgeAndroidToJavaScript_KeyEvent(event.keyCode, MediaEventType.KEY_UP)
+                    }
+                    return true
+                }
+            }
+        }
+        when (event.keyCode) {
+            KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK,
+            KeyEvent.KEYCODE_MEDIA_CLOSE,
+            KeyEvent.KEYCODE_MEDIA_EJECT,
+            KeyEvent.KEYCODE_MEDIA_FAST_FORWARD,
+            KeyEvent.KEYCODE_MEDIA_NEXT,
+            KeyEvent.KEYCODE_MEDIA_PREVIOUS,
+            KeyEvent.KEYCODE_MEDIA_RECORD,
+            KeyEvent.KEYCODE_MEDIA_REWIND,
+            KeyEvent.KEYCODE_MEDIA_SKIP_BACKWARD,
+            KeyEvent.KEYCODE_MEDIA_SKIP_FORWARD,
+            KeyEvent.KEYCODE_MEDIA_STEP_BACKWARD,
+            KeyEvent.KEYCODE_MEDIA_STEP_FORWARD,
+            KeyEvent.KEYCODE_MEDIA_TOP_MENU,
+            KeyEvent.KEYCODE_MEDIA_PLAY -> {
+                if (event.action == KeyEvent.ACTION_DOWN) {
+                    jsBridge.bridgeAndroidToJavaScript_KeyEvent(event.keyCode, MediaEventType.KEY_DOWN)
+                } else if (event.action == KeyEvent.ACTION_UP) {
+                    jsBridge.bridgeAndroidToJavaScript_KeyEvent(event.keyCode, MediaEventType.KEY_UP)
+                }
+                return true
+            }
+        }
+        return false
+    }
+
+    fun detectDeviceInfo(): JSONObject {
+        val deviceInfo = JSONObject()
+        try {
+            deviceInfo.put("deviceBrand", Build.MANUFACTURER)
+            deviceInfo.put("deviceModel", Build.MODEL)
+            deviceInfo.put("osVersion", Build.VERSION.RELEASE)
+            deviceInfo.put("appFlavor", BuildConfig.FLAVOR)
+            deviceInfo.put("appVersion", BuildConfig.VERSION_NAME)
+
+            val drmKeySystems = mutableSetOf<String>()
+            playerFactory.getSupportedFormats(context).manifest.forEach { manifest ->
+                manifest.drm.forEach { drm ->
+                    drmKeySystems.addAll(drm.keySystems)
+                }
+            }
+            deviceInfo.put("drmKeySystems", JSONArray(drmKeySystems))
+
+            val ipAddresses = mutableSetOf<String>()
+            for (networkInterface in NetworkInterface.getNetworkInterfaces()) {
+                for (inetAddress in networkInterface.inetAddresses) {
+                    if (inetAddress.isLoopbackAddress) continue
+                    ipAddresses.add(inetAddress.hostAddress)
+                }
+            }
+            deviceInfo.put("ipLocal", JSONArray(ipAddresses))
+
+        } catch (e: JSONException) {
+            deviceInfo.put("errorType", e.javaClass.simpleName)
+            deviceInfo.put("errorMessage", e.message)
+        }
+        return deviceInfo
+    }
+
+
+    private inner class InnerIapCallback : IapCallback {
+        override fun checkNewPurchasesFinished(result: List<IapPurchase>) {
+            // not actually used at the moment
+        }
+
+        override fun checkNewPurchasesFinished(exception: Exception) {
+            // not actually used at the moment
+        }
+
+        override fun purchaseFinished(result: IapPurchase) {
+            jsBridge.bridgeAndroidToJavaScript_IAPValidationSuccess(result.userId, result.receipt, result.sku)
+        }
+
+        override fun purchaseFinished(exception: Exception) {
+            if (exception is IapException) {
+                jsBridge.bridgeAndroidToJavaScript_IAPValidationError(exception.status)
+            } else {
+                jsBridge.bridgeAndroidToJavaScript_IAPValidationError(exception.message
+                        ?: "Purchase failed")
+            }
+        }
+
+        override fun getProductsFinished(result: List<IapProduct>, missing: List<String>) {
+            val okSkus = JsonArray()
+            for (iapProduct in result) {
+                val jsonProduct = JsonObject()
+                jsonProduct.addProperty("title", iapProduct.title)
+                jsonProduct.addProperty("description", iapProduct.description)
+                jsonProduct.addProperty("price", iapProduct.price)
+                jsonProduct.addProperty("icon", iapProduct.icon)
+                jsonProduct.addProperty("type", iapProduct.type)
+                jsonProduct.addProperty("sku", iapProduct.sku)
+                okSkus.add(jsonProduct)
+            }
+            val badSkus = JsonArray()
+            for (sku in missing) {
+                badSkus.add(sku)
+            }
+            jsBridge.bridgeIAPGetProductDataSuccess(okSkus.toString(), badSkus.toString())
+        }
+
+        override fun getProductsFinished(exception: Exception) {
+            if (exception is IapException) {
+                jsBridge.bridgeIAPGetProductDataFail(exception.status)
+            } else {
+                jsBridge.bridgeIAPGetProductDataFail(exception.message ?: "Purchase failed")
+            }
+        }
+
+        override fun acknowledgeReceiptFinished(exception: Exception?) {
+            // JS does not care
+        }
+    }
+
+    companion object {
+        const val JAVA_SCRIPT_BRIDGE = "JavaScriptBridge"
+        const val LOW_END_DEVICE_MAX_BITRATE = 1500000
+        val DISABLED_TEXT_TRACK = TextTrack {
+            id = "text_off"
+            kind = TrackKind.EMPTY
+        }
+    }
+}

package/dist/templates/platforms/androidtv/project/app/src/main/res/drawable/button_background_focus.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid
+        android:color="#E5F0FD"/>
+    <stroke
+        android:color="#33D7FF"
+        android:width="3dp"/>
+    <corners
+        android:radius="5dp" />
+</shape>

package/dist/templates/platforms/androidtv/project/app/src/main/res/drawable/button_background_normal.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid
+        android:color="#E5F0FD"/>
+    <corners
+        android:radius="5dp" />
+</shape>

package/dist/templates/platforms/androidtv/project/app/src/main/res/drawable/button_background_pressed.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid
+        android:color="#1FD3FF"/>
+    <corners
+        android:radius="5dp" />
+</shape>

package/dist/templates/platforms/androidtv/project/app/src/main/res/drawable/button_focus.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@drawable/button_background_pressed"
+        android:state_pressed="true" />
+    <item android:drawable="@drawable/button_background_focus"
+        android:state_focused="true" />
+    <item android:drawable="@drawable/button_background_normal"/>
+</selector>