@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/webview/viewmodel/WebViewModel.kt

@@ -0,0 +1,569 @@
+package com.twentyfouri.tvbridge.webview.viewmodel
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+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.WebView
+import androidx.databinding.BaseObservable
+import androidx.databinding.Bindable
+import com.google.android.exoplayer2.ExoPlaybackException
+import com.google.android.exoplayer2.Player
+import com.google.android.exoplayer2.SeekParameters
+import com.google.android.exoplayer2.source.TrackGroupArray
+import com.google.android.exoplayer2.trackselection.TrackSelectionArray
+import com.google.android.exoplayer2.upstream.DefaultHttpDataSource
+import com.google.android.exoplayer2.upstream.DefaultHttpDataSourceFactory
+import com.google.android.exoplayer2.upstream.HttpDataSource
+import com.google.android.exoplayer2.util.Util
+import com.google.gson.JsonArray
+import com.google.gson.JsonObject
+import com.twentyfouri.smartexoplayer.SmartPlayer
+import com.twentyfouri.smartexoplayer.SmartPlayerFactory
+import com.twentyfouri.smartexoplayer.model.DrmConfiguration
+import com.twentyfouri.smartexoplayer.model.PlayerConfigurationModel
+import com.twentyfouri.smartexoplayer.model.PlayerSourceModel
+import com.twentyfouri.smartexoplayer.tracks.TrackInfo
+import com.twentyfouri.smartexoplayer.tracks.TrackPreference
+import com.twentyfouri.smartexoplayer.tracks.TrackPreferences
+import com.twentyfouri.smartexoplayer.tracks.VideoPreference
+import com.twentyfouri.smartexoplayer.ui.TimerHelper
+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.HttpMediaDrmCallback
+import com.twentyfouri.tvbridge.global.utils.LocalStorage
+import com.twentyfouri.tvbridge.global.utils.LoggingDrmCallback
+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.MediaEventType
+import com.twentyfouri.tvbridge.webview.view.Mainview
+import com.twentyfouri.tvbridge.webview.view.PlayerCache
+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,
+        private val playerFactory: SmartPlayerFactory
+) : BaseObservable(), Player.EventListener, TimerHelper.Listener {
+    private var player: SmartPlayer? = null
+    private var view: Mainview? = null
+    private val jsBridge = BridgeToJavaScript { s: String? ->
+        view?.loadUrl(s)
+    }
+    private val iapCallback = InnerIapCallback()
+    private val playerCache = PlayerCache()
+    private val jumpAnalytics = JumpAnalytics()
+    private val timerHelper = TimerHelper().also { it.addListener(this) }
+
+    private var contentModel: ContentModel? = null
+
+    var audioTrack: TrackInfo? = null
+        private set
+    var subtitleTrack: TrackInfo? = null
+        private set
+
+    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
+
+    private val trackPreferences = TrackPreferences.Builder()
+
+    fun attachView(view: Mainview?) {
+        this.view = view
+        if (view != null) {
+            iapService.initialize()
+            checkNewPurchases()
+            timerHelper.onAttachedToWindow()
+        } else {
+            timerHelper.onDetachedFromWindow()
+        }
+    }
+
+    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.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
+        val playerSourceModel = getPlayerSourceModel(contentModel)
+        val playerConfigurationModel = getConfigurationModel(contentModel)
+        val player = playerFactory.build(playerConfigurationModel)
+        this.player = player
+        view?.assignPlayer(player)
+        timerHelper.player = player
+        jumpAnalytics.setVideoPlayer(player.exoPlayer)
+        player.exoPlayer?.setSeekParameters(SeekParameters.CLOSEST_SYNC)
+        player.playWhenReady = true
+        if (isLowEndDevice) {
+            player.trackSelector.trackPreferences = player.trackSelector.trackPreferences.copy(
+                    video = VideoPreference.Builder().apply {
+                        maxBitrate = LOW_END_DEVICE_MAX_BITRATE
+                    }.build()
+            )
+        }
+        player.addListener(this)
+        player.prepare(playerSourceModel)
+    }
+
+    private fun getPlayerSourceModel(contentModel: ContentModel): PlayerSourceModel {
+        return PlayerSourceModel.Builder().apply {
+            uri = contentModel.streamUrl
+            contentModel.streamType?.let { extensionOverride = it }
+        }.build()
+    }
+
+    private val isLowEndDevice: Boolean
+        get() = when (Build.MODEL) {
+            "AFTB" -> true
+            "AFTM" -> true
+            else -> false
+        }
+
+    private fun getConfigurationModel(contentModel: ContentModel): PlayerConfigurationModel {
+        val configurationModel = PlayerConfigurationModel.Builder()
+        config.playerAppName?.let { configurationModel.userAgent = Util.getUserAgent(context, it) }
+        val drmModel = contentModel.drmModel
+        if (drmModel != null) {
+            val drmConfiguration = DrmConfiguration.Builder()
+            drmConfiguration.drmLicenseUrl = drmModel.drmLicenseUrl
+            drmConfiguration.drmSchemeUuid = Util.getDrmUuid(drmModel.drmSchemeUuid ?: "widevine")
+            val overrideDrmCallback = drmModel.overrideDrmCallback
+                    ?: config.drm.shouldOverrideDrmCallback()
+            if (overrideDrmCallback) {
+                drmConfiguration.drmCallbackFactory = HttpMediaDrmCallback.Factory(
+                        drmModel.drmLicenseUrl, true)
+            } else {
+                drmConfiguration.drmCallbackFactory = LoggingDrmCallback.Factory(
+                        drmModel.drmLicenseUrl, true)
+            }
+            val allowMultiSession = drmModel.multiSessionEnabled ?: config.drm.isMultiSessionEnabled
+            drmConfiguration.drmMultiSession = allowMultiSession
+            configurationModel.drm = drmConfiguration
+        }
+        return configurationModel.build()
+    }
+
+    private fun buildHttpDataSourceFactory(): HttpDataSource.Factory {
+        return DefaultHttpDataSourceFactory(
+                Util.getUserAgent(context, "smartexoplayer"),
+                null,
+                DefaultHttpDataSource.DEFAULT_CONNECT_TIMEOUT_MILLIS,
+                DefaultHttpDataSource.DEFAULT_READ_TIMEOUT_MILLIS,
+                true)
+    }
+
+    fun startPlayer() {
+        player?.playWhenReady = true
+    }
+
+    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.isCurrentWindowDynamic) {
+                position = 0
+            }
+            player.seekTo(position)
+            view?.requestAudioFocus()
+            if (playerCache.savedPlayerState === PlayerCache.PlayerState.PLAYING) {
+                player.playWhenReady = true
+            }
+        } else {
+            if (player?.isCurrentWindowDynamic == true) {
+                player?.seekTo(0)
+            }
+            player?.playWhenReady = true
+        }
+    }
+
+    fun pausePlayer() {
+        player?.playWhenReady = false
+    }
+
+    fun stopPlayer() {
+        view?.setBlackCurtainVisibility(View.VISIBLE)
+        contentModel = null
+
+        player?.also { player ->
+            player.stop()
+            player.release()
+            jumpAnalytics.setVideoPlayer(null)
+        }
+        this.player = null
+    }
+
+    fun releasePlayer() {
+        val player = this.player ?: return
+        if (contentModel != null) {
+            playerCache.loadFromCache = true
+            playerCache.savedContentModel = contentModel
+            playerCache.savedPlayerDuration = player.duration
+            playerCache.savedPlayerPosition = player.currentPosition
+            playerCache.savedPlayerState = if (player.isPlaying) PlayerCache.PlayerState.PLAYING else PlayerCache.PlayerState.PAUSED
+        }
+        timerHelper.player = null
+        player.release()
+        jumpAnalytics.setVideoPlayer(null)
+        view?.assignPlayer(null)
+        this.player = null
+    }
+
+    val currentPosition: Int
+        get() = player?.currentPosition?.toInt() ?: playerCache.savedPlayerPosition.toInt()
+    val duration: Int
+        get() = player?.duration?.toInt() ?: playerCache.savedPlayerDuration.toInt()
+
+    fun seekToPosition(position: Int) {
+        player?.seekTo(position.toLong())
+    }
+
+    val isPlayerPlaying: Boolean
+        get() = player?.isPlaying == true
+    val isInPlayer: Boolean
+        get() = player != null && contentModel != null
+
+    fun loadUrl(url: String?) {
+        view?.loadUrl(url)
+    }
+
+    fun setSubtitlesVisibility(visibility: Boolean) {
+        view?.setSubtitlesVisibility(visibility)
+    }
+
+    fun enableFullScreen() {
+        view?.goFullscreen()
+    }
+
+    fun disableFullScreen(width: Int, height: Int, left: Int, top: Int) {
+        view?.exitFullscreen(width, height, left, top)
+    }
+
+    override fun onPlayerError(error: ExoPlaybackException) {
+        jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.ERROR)
+        stopPlayer()
+        Log.e("AndroidPlayer", "Player error", error)
+    }
+
+    private var previousPlayWhenReady = false
+    private var previousState = Player.STATE_IDLE
+
+    override fun onPlayerStateChanged(playWhenReady: Boolean, playbackState: Int) {
+        if (playbackState != previousState) {
+            when (playbackState) {
+                Player.STATE_ENDED ->
+                    jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.ENDED)
+                Player.STATE_BUFFERING ->
+                    jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.WAITING)
+                Player.STATE_READY -> {
+                    view?.setBlackCurtainVisibility(View.GONE)
+                    jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.PLAYING)
+                }
+            }
+        } else if (playWhenReady != previousPlayWhenReady) {
+            if (playWhenReady) {
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.PLAYING)
+            }
+        }
+        previousPlayWhenReady = playWhenReady
+        previousState = playbackState
+    }
+
+    override fun onPositionDiscontinuity(reason: Int) {
+        when (reason) {
+            Player.DISCONTINUITY_REASON_SEEK,
+            Player.DISCONTINUITY_REASON_SEEK_ADJUSTMENT -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.WAITING)
+            }
+        }
+    }
+
+    override fun onSeekProcessed() {
+        jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.SEEKED)
+    }
+
+    override fun onTimer() {
+        jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.TIME_UPDATE)
+    }
+
+    fun setSubtitleTrack(track: TrackPreference?) {
+        trackPreferences.subtitles = track ?: return
+        player?.trackSelector?.trackPreferences = trackPreferences.build()
+    }
+
+    fun setAudioTrack(track: TrackPreference?) {
+        trackPreferences.audio = track ?: return
+        player?.trackSelector?.trackPreferences = trackPreferences.build()
+    }
+
+    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)
+    }
+
+    override fun onTracksChanged(trackGroups: TrackGroupArray, trackSelections: TrackSelectionArray) {
+        val player = this.player ?: return
+        val tracks = player.trackSelector.getTrackInfos(player)
+        val filtered = tracks.filter { it.type != TrackInfo.TYPE_VIDEO }
+        audioTrack = tracks.firstOrNull { it.selected && it.type == TrackInfo.TYPE_AUDIO }
+        subtitleTrack = tracks.firstOrNull { it.selected && it.type == TrackInfo.TYPE_SUBTITLES }
+        Log.d("WebViewModel", "onTracksChanged: audio=$audioTrack subtitle=$subtitleTrack")
+        jsBridge.bridgeAndroidToJavaScript_MediaTrackEvent(MediaEventType.TRACKS_CHANGED, filtered)
+    }
+
+    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
+    }
+
+    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
+    }
+}

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>

package/dist/templates/platforms/androidtv/project/app/src/main/res/layout/activity_web_view.xml

@@ -0,0 +1,78 @@
+<layout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <data>
+
+        <variable
+            name="viewModel"
+            type="com.twentyfouri.tvbridge.webview.viewmodel.WebViewModel" />
+    </data>
+
+    <RelativeLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:background="@android:color/black"
+        tools:context=".webview.ui.view.WebViewActivity">
+
+        <com.twentyfouri.smartexoplayer.ui.SmartExoPlayerView
+            android:id="@+id/exoplayer_view"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            app:useControls="false"
+            app:useProgress="false"/>
+
+        <View
+            android:id="@+id/black_curtain"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:background="@android:color/black" />
+
+        <LinearLayout
+            android:id="@+id/url_setter"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_centerInParent="true"
+            android:layout_margin="80dp"
+            android:orientation="vertical"
+            app:visibility="@{viewModel.urlSetterVisibility}">
+
+            <EditText
+                android:id="@+id/url"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:nextFocusUp="@+id/url"
+                android:nextFocusLeft="@+id/url"
+                android:nextFocusRight="@+id/url"
+                android:textColor="@android:color/white"/>
+
+            <Button
+                android:id="@+id/button_go"
+                android:layout_width="100dp"
+                android:layout_height="wrap_content"
+                android:background="@drawable/button_focus"
+                android:textColor="@android:color/black"
+                android:nextFocusDown="@+id/button_go"
+                android:nextFocusLeft="@+id/button_go"
+                android:nextFocusRight="@+id/button_go"
+                android:onClick="@{() -> viewModel.onClickGo()}"
+                android:text="GO" />
+
+        </LinearLayout>
+
+        <com.twentyfouri.tvbridge.webview.client.BridgeWebView
+            android:id="@+id/webview"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:layout_alignParentBottom="true"
+            android:layout_alignParentEnd="true"
+            android:layout_alignParentStart="true"
+            android:layout_alignParentTop="true"
+            android:background="@android:color/transparent"
+            android:visibility="gone"/>
+
+    </RelativeLayout>
+
+</layout>
+
+