@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/view/WebViewActivity.kt

@@ -0,0 +1,306 @@
+package com.twentyfouri.tvbridge.webview.view
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Point
+import android.media.AudioManager
+import android.media.AudioManager.OnAudioFocusChangeListener
+import android.os.Bundle
+import android.text.Editable
+import android.text.TextWatcher
+import android.util.Log
+import android.view.KeyEvent
+import android.view.View
+import android.view.WindowManager
+import android.view.inputmethod.InputMethodManager
+import android.webkit.WebChromeClient
+import android.webkit.WebView
+import android.widget.RelativeLayout
+import android.widget.Toast
+import androidx.appcompat.app.AppCompatActivity
+import androidx.databinding.DataBindingUtil
+import androidx.media.AudioAttributesCompat
+import androidx.media.AudioFocusRequestCompat
+import androidx.media.AudioManagerCompat
+import com.twentyfouri.tvbridge.BuildConfig
+import com.twentyfouri.tvbridge.R
+import com.twentyfouri.tvbridge.configuration.BridgeConfig
+import com.twentyfouri.tvbridge.databinding.ActivityWebViewBinding
+import com.twentyfouri.tvbridge.global.BaseApplication
+import com.twentyfouri.tvbridge.global.di.ActivityComponent
+import com.twentyfouri.tvbridge.global.di.ActivityModule
+import com.twentyfouri.tvbridge.global.di.DaggerActivityComponent
+import com.twentyfouri.tvbridge.sound.TouchPlayer
+import com.twentyfouri.tvbridge.webview.model.MediaEventType
+import com.twentyfouri.tvbridge.webview.viewmodel.WebViewModel
+import java.net.CookieHandler
+import java.net.CookieManager
+import java.net.CookiePolicy
+
+class WebViewActivity : AppCompatActivity(), Mainview {
+
+    private var initialized: Boolean = false
+    private lateinit var component: ActivityComponent
+    private lateinit var binding: ActivityWebViewBinding
+    private lateinit var config: BridgeConfig
+    private lateinit var audioManager: AudioManager
+    private lateinit var viewModel: WebViewModel
+    private lateinit var touchPlayer: TouchPlayer
+
+    private val audioFocusListener = OnAudioFocusChangeListener { /* we actually don't care */ }
+
+    @SuppressLint("SetJavaScriptEnabled")
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        if (!isTaskRoot) {
+            finish()
+            return
+        }
+
+        component = DaggerActivityComponent.builder()
+            .applicationComponent((application as BaseApplication).component)
+            .activityModule(ActivityModule(this))
+            .build()
+        config = component.configuration
+        touchPlayer = component.touchPlayer
+        viewModel = component.viewModelFactory.get()
+        audioManager = getSystemService(AUDIO_SERVICE) as AudioManager
+
+        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        val currentHandler = CookieHandler.getDefault()
+        if (currentHandler !== defaultCookieManager) {
+            CookieHandler.setDefault(defaultCookieManager)
+        }
+
+        binding = DataBindingUtil.setContentView(this, R.layout.activity_web_view)
+        binding.viewModel = viewModel
+        binding.exoplayerView.playerFactory = viewModel.playerFactory
+        viewModel.attachView(this)
+        viewModel.configureWebView(binding.webview)
+        viewModel.player = binding.exoplayerView.player
+
+        binding.url.addTextChangedListener(object : TextWatcher {
+            override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {}
+            override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
+                viewModel.appUrl = s.toString()
+            }
+
+            override fun afterTextChanged(s: Editable) {}
+        })
+
+        val appUrl = config.baseUrl
+        if (config.customizableUrl) {
+            viewModel.urlSetterVisible = true
+            viewModel.appUrl = appUrl
+            setUrlToView(appUrl)
+        } else {
+            viewModel.urlSetterVisible = false
+            loadUrl(appUrl)
+        }
+
+        binding.root.viewTreeObserver.addOnGlobalFocusChangeListener { oldFocus: View, newFocus: View ->
+            Log.v("FOCUS", "global focus changed old = $oldFocus")
+            Log.v("FOCUS", "global focus changed new = $newFocus")
+        }
+
+        initialized = true
+    }
+
+    override fun hideKeyboard() {
+        val imm = getSystemService(Activity.INPUT_METHOD_SERVICE) as? InputMethodManager
+            ?: return
+        //If imm is null do nothing
+        //Find the currently focused view, so we can grab the correct window token from it.
+        //If no view currently has focus, create a new one, just so we can grab a window token from it
+        val view = currentFocus ?: View(this)
+        imm.hideSoftInputFromWindow(view.windowToken, 0)
+    }
+
+    override fun setBlackCurtainVisibility(visibility: Int) {
+        runOnUiThread {
+            binding.blackCurtain.visibility = visibility
+        }
+    }
+
+    override fun showMessage(message: String?) {
+        Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
+    }
+
+    override fun requestAudioFocus(): Int {
+        return AudioManagerCompat.requestAudioFocus(
+            audioManager,
+            AudioFocusRequestCompat
+                .Builder(AudioManagerCompat.AUDIOFOCUS_GAIN)
+                .setAudioAttributes(
+                    AudioAttributesCompat
+                        .Builder()
+                        .setContentType(AudioAttributesCompat.CONTENT_TYPE_MOVIE)
+                        .build()
+                )
+                .setOnAudioFocusChangeListener(audioFocusListener)
+                .build()
+        )
+    }
+
+    override fun abandonAudioFocus() {
+        AudioManagerCompat.abandonAudioFocusRequest(
+            audioManager,
+            AudioFocusRequestCompat
+                .Builder(AudioManagerCompat.AUDIOFOCUS_GAIN)
+                .setOnAudioFocusChangeListener(audioFocusListener)
+                .build()
+        )
+    }
+
+    public override fun onResume() {
+        super.onResume()
+        viewModel.checkNewPurchases()
+        viewModel.resumePlayer()
+    }
+
+    public override fun onPause() {
+        viewModel.pausePlayer()
+        super.onPause()
+    }
+
+    public override fun onDestroy() {
+        if (initialized) {
+            viewModel.releasePlayer()
+            binding.unbind()
+        }
+        super.onDestroy()
+    }
+
+    override fun goFullscreen() {
+        val layoutParams = binding.exoplayerView.layoutParams as RelativeLayout.LayoutParams
+        layoutParams.width = -1
+        layoutParams.height = -1
+        layoutParams.leftMargin = 0
+        layoutParams.topMargin = 0
+        val wm = getSystemService(WINDOW_SERVICE) as WindowManager
+        val display = wm.defaultDisplay
+        val size = Point()
+        display.getSize(size)
+        val width = size.x
+        val height = size.y
+        binding.exoplayerView.layoutParams = layoutParams
+        binding.exoplayerView.layout(width, height, 0, 0)
+    }
+
+    override fun launchIapPurchase(sku: String) {
+        viewModel.launchIapPurchase(this, sku)
+    }
+
+    override fun exitFullscreen(width: Int, height: Int, left: Int, top: Int) {
+        val layoutParams = binding.exoplayerView.layoutParams as RelativeLayout.LayoutParams
+        layoutParams.width = width
+        layoutParams.height = height
+        layoutParams.leftMargin = left
+        layoutParams.topMargin = top
+
+        //set the layout inner and outer sizes
+        binding.exoplayerView.layoutParams = layoutParams
+        binding.exoplayerView.layout(width, height, left, top)
+    }
+
+    override fun setUrlToView(urlString: String?) {
+        binding.url.requestFocus()
+        binding.url.setText(urlString)
+        binding.url.setSelection(urlString?.length ?: 0)
+    }
+
+    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
+        when (event.keyCode) {
+            KeyEvent.KEYCODE_DPAD_RIGHT, KeyEvent.KEYCODE_DPAD_LEFT -> changeFocus()
+            KeyEvent.KEYCODE_DPAD_CENTER -> goToUrl()
+            KeyEvent.KEYCODE_BACK, KeyEvent.KEYCODE_BUTTON_B, KeyEvent.KEYCODE_BUTTON_A, KeyEvent.KEYCODE_MENU, KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE, KeyEvent.KEYCODE_MEDIA_PLAY, KeyEvent.KEYCODE_MEDIA_PAUSE, KeyEvent.KEYCODE_MEDIA_FAST_FORWARD, KeyEvent.KEYCODE_MEDIA_REWIND -> {
+                if (!binding.url.hasFocus() && !binding.buttonGo.hasFocus()) {
+                    // Send these key presses to the WebView, through a JavaScript bridge.
+                    viewModel.sendKeyCode(event.keyCode, MediaEventType.KEY_DOWN)
+                }
+            }
+            else -> {
+                if (!binding.url.hasFocus() && !binding.buttonGo.hasFocus()) {
+                    viewModel.sendKeyCode(event.keyCode, MediaEventType.KEY_DOWN)
+                }
+            }
+        }
+        return super.onKeyDown(keyCode, event)
+    }
+
+    override fun dispatchKeyEvent(event: KeyEvent): Boolean {
+        playTouchSounds(event)
+        return super.dispatchKeyEvent(event)
+    }
+
+    private fun playTouchSounds(event: KeyEvent) {
+        if (event.action != KeyEvent.ACTION_DOWN) {
+            return
+        }
+        when (event.keyCode) {
+            KeyEvent.KEYCODE_DPAD_RIGHT,
+            KeyEvent.KEYCODE_DPAD_LEFT,
+            KeyEvent.KEYCODE_DPAD_UP,
+            KeyEvent.KEYCODE_DPAD_DOWN,
+            KeyEvent.KEYCODE_DPAD_CENTER ->
+                if (config.isEnabledTouchSound) {
+                    touchPlayer.play()
+                }
+        }
+    }
+
+    private fun goToUrl() {
+        if (binding.buttonGo.hasFocus()) {
+            viewModel.onClickGo()
+        }
+    }
+
+    private fun changeFocus() {
+        if (binding.url.hasFocus()) {
+            binding.buttonGo.requestFocus()
+        } else if (binding.buttonGo.hasFocus()) {
+            binding.url.requestFocus()
+        }
+    }
+
+    override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
+        if (!binding.url.hasFocus() && !binding.buttonGo.hasFocus()) {
+            // Send these key presses to the WebView, through a JavaScript bridge.
+            viewModel.sendKeyCode(event.keyCode, MediaEventType.KEY_UP)
+            return true
+        }
+        return super.onKeyUp(keyCode, event)
+    }
+
+    override fun onKeyLongPress(keyCode: Int, event: KeyEvent): Boolean {
+        if (!binding.url.hasFocus() && !binding.buttonGo.hasFocus()) {
+            // Send these key presses to the WebView, through a JavaScript bridge.
+            viewModel.sendKeyCode(event.keyCode, MediaEventType.KEY_PRESS)
+            return true
+        }
+        return super.onKeyLongPress(keyCode, event)
+    }
+
+    override fun loadUrl(url: String?) {
+        if (url.isNullOrEmpty()) return
+        binding.webview.visibility = View.VISIBLE
+        binding.webview.loadUrl(url)
+        if (url.startsWith("http")) {
+            binding.webview.requestFocus()
+        }
+    }
+
+    override fun onBackPressed() {
+        super.onBackPressed()
+    }
+
+    companion object {
+        private val defaultCookieManager: CookieManager = CookieManager().apply {
+            setCookiePolicy(CookiePolicy.ACCEPT_ALL)
+        }
+    }
+}