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

@@ -0,0 +1,748 @@
+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.os.Build
+import android.provider.Settings
+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 com.google.android.gms.ads.identifier.AdvertisingIdClient
+import com.google.gson.JsonArray
+import com.google.gson.JsonObject
+import com.twentyfouri.player.base.AbrStrategy
+import com.twentyfouri.player.base.AdBreakEndedEvent
+import com.twentyfouri.player.base.AdBreakStartedEvent
+import com.twentyfouri.player.base.AdBreaksRescheduledEvent
+import com.twentyfouri.player.base.AdErrorEvent
+import com.twentyfouri.player.base.AdSkippedEvent
+import com.twentyfouri.player.base.AdStartedEvent
+import com.twentyfouri.player.base.AddAudioTrackEvent
+import com.twentyfouri.player.base.AddTextTrackEvent
+import com.twentyfouri.player.base.AudioTrack
+import com.twentyfouri.player.base.CanPlayEvent
+import com.twentyfouri.player.base.ChangeAudioTrackEvent
+import com.twentyfouri.player.base.ChangeTextTrackEvent
+import com.twentyfouri.player.base.DurationChangeEvent
+import com.twentyfouri.player.base.EndedEvent
+import com.twentyfouri.player.base.ErrorEvent
+import com.twentyfouri.player.base.Event
+import com.twentyfouri.player.base.EventListener
+import com.twentyfouri.player.base.LoadedDataEvent
+import com.twentyfouri.player.base.LoadedMetadataEvent
+import com.twentyfouri.player.base.PauseEvent
+import com.twentyfouri.player.base.PlayerBase
+import com.twentyfouri.player.base.PlayerFactoryBase
+import com.twentyfouri.player.base.PlayingEvent
+import com.twentyfouri.player.base.RemoveAudioTrackEvent
+import com.twentyfouri.player.base.RemoveTextTrackEvent
+import com.twentyfouri.player.base.SeekedEvent
+import com.twentyfouri.player.base.SeekingEvent
+import com.twentyfouri.player.base.Source
+import com.twentyfouri.player.base.SourceDrmPlayready
+import com.twentyfouri.player.base.SourceDrmWidevine
+import com.twentyfouri.player.base.SourceImaAds
+import com.twentyfouri.player.base.TextTrack
+import com.twentyfouri.player.base.TimeUpdateEvent
+import com.twentyfouri.player.base.TrackKind
+import com.twentyfouri.player.base.WaitingEvent
+import com.twentyfouri.player.base.buildUpon
+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.iap.IapCallback
+import com.twentyfouri.tvbridge.common.iap.IapException
+import com.twentyfouri.tvbridge.common.iap.IapProduct
+import com.twentyfouri.tvbridge.common.iap.IapPurchase
+import com.twentyfouri.tvbridge.common.iap.IapService
+import com.twentyfouri.tvbridge.configuration.BridgeConfig
+import com.twentyfouri.tvbridge.global.utils.LocalStorage
+import com.twentyfouri.tvbridge.global.utils.PlayerFactoryVersion
+import com.twentyfouri.tvbridge.global.utils.SourceDrmOverridden
+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.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.io.IOException
+import java.net.NetworkInterface
+import java.util.Locale
+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
+) : 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 var source: Source? = null
+
+    private var adStarted: Boolean = false
+
+    val audioTrack: AudioTrack?
+        get() = player?.selectedAudioTrack
+    val subtitleTrack: TextTrack?
+        get() = player?.selectedTextTrack
+
+    var appUrl: String? = null
+
+    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)
+        if (BuildConfig.DEBUG) {
+            view?.hideKeyboard()
+        }
+    }
+
+    fun setVideo(source: Source) {
+        var adaptedSource = source
+        if (config.drm.shouldOverrideDrmCallback()) {
+            adaptedSource = SourceDrmOverridden.replaceSource(adaptedSource)
+        }
+        logSource(adaptedSource)
+        playDirectly(adaptedSource)
+    }
+
+    private fun logSource(source: Source) {
+        Log.i("BridgeVideo", "Url: ${source.url}")
+        when (val ads = source.ads) {
+            is SourceImaAds -> {
+                Log.i("BridgeVideo", "Ads: ${ads.url}")
+            }
+        }
+        when (val drmModel = source.drm.firstOrNull()) {
+            is SourceDrmWidevine -> {
+                Log.i("BridgeVideo", "DRM: " + drmModel.packageName)
+                Log.i("BridgeVideo", "LicenseUrl: " + drmModel.licenseServer)
+            }
+            is SourceDrmPlayready -> {
+                Log.i("BridgeVideo", "DRM: " + drmModel.packageName)
+                Log.i("BridgeVideo", "LicenseUrl: " + drmModel.licenseServer)
+            }
+            is SourceDrmOverridden -> {
+                Log.i("BridgeVideo", "DRM: " + drmModel.packageName)
+                Log.i("BridgeVideo", "LicenseUrl: " + drmModel.licenseServer)
+            }
+        }
+    }
+
+    private fun playDirectly(source: Source) {
+        this.source = source
+        player?.also { player ->
+            player.source = source
+
+            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 val isLowEndDevice: Boolean
+        get() = when (Build.MODEL) {
+            "AFTB" -> true
+            "AFTM" -> true
+            else -> false
+        }
+
+    fun startPlayer() {
+        player?.play()
+    }
+
+    fun resumePlayer() {
+        val savedSource = playerCache.savedSource
+        if (playerCache.loadFromCache && savedSource != null && playerCache.savedPlayerState !== PlayerCache.PlayerState.PAUSED) {
+            setVideo(savedSource)
+            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)
+        source = null
+
+        player?.also { player ->
+            player.removeEventListener(Event.ALL, this)
+            player.unload()
+        }
+    }
+
+    fun releasePlayer() {
+        val player = this.player ?: return
+        if (source != null) {
+            playerCache.loadFromCache = true
+            playerCache.savedSource = source
+            playerCache.savedPlayerDuration = player.duration
+            playerCache.savedPlayerPosition = player.currentTime
+            playerCache.savedPlayerState = if (player.playing) PlayerCache.PlayerState.PLAYING else PlayerCache.PlayerState.PAUSED
+        }
+        player.unload()
+    }
+
+    fun reloadPlayer() {
+        view?.reloadPlayer()
+    }
+
+    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 && source != 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 LoadedMetadataEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.LOADEDMETADATA)
+                jsBridge.bridgeAndroidToJavaScript_MediaTrackEvent(
+                    MediaEventType.TRACKS_CHANGED,
+                    player.audioTracks,
+                    player.textTracks
+                )
+            }
+
+            is LoadedDataEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.LOADEDDATA)
+            }
+
+            is CanPlayEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.CANPLAY)
+            }
+
+            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 DurationChangeEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.DURATION_CHANGE)
+            }
+
+            is SeekingEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaEvent(MediaEventType.SEEKING)
+            }
+
+            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 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
+                )
+            }
+
+            is AdBreaksRescheduledEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaAdBreaksEvent(
+                    MediaEventType.AD_BREAKS_RESCHEDULED,
+                    player.timeline
+                )
+            }
+
+            is AdBreakStartedEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaAdEvent(
+                    MediaEventType.AD_BREAK_START,
+                    player.currentAdBreak,
+                    player.currentAd
+                )
+            }
+
+            is AdBreakEndedEvent -> {
+                if (adStarted) {
+                    jsBridge.bridgeAndroidToJavaScript_MediaAdEvent(
+                        MediaEventType.AD_ENDED,
+                        player.currentAdBreak,
+                        null
+                    )
+                }
+                adStarted = false
+                jsBridge.bridgeAndroidToJavaScript_MediaAdEvent(
+                    MediaEventType.AD_BREAK_END,
+                    player.currentAdBreak,
+                    player.currentAd
+                )
+            }
+
+            is AdStartedEvent -> {
+                if (adStarted) {
+                    jsBridge.bridgeAndroidToJavaScript_MediaAdEvent(
+                        MediaEventType.AD_ENDED,
+                        player.currentAdBreak,
+                        null
+                    )
+                } else {
+                    adStarted = true
+                }
+                jsBridge.bridgeAndroidToJavaScript_MediaAdEvent(
+                    MediaEventType.AD_STARTED,
+                    player.currentAdBreak,
+                    player.currentAd
+                )
+            }
+
+            is AdErrorEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaAdEvent(
+                    MediaEventType.AD_ERROR,
+                    player.currentAdBreak,
+                    player.currentAd
+                )
+            }
+
+            is AdSkippedEvent -> {
+                jsBridge.bridgeAndroidToJavaScript_MediaAdEvent(
+                    MediaEventType.AD_SKIPPED,
+                    player.currentAdBreak,
+                    player.currentAd
+                )
+            }
+        }
+    }
+
+    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) {
+        // previously used for Jump analytics, not supported with THEO
+    }
+
+    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(receipt: JSONObject) {
+        iapService.setCallback(iapCallback)
+        iapService.acknowledgeReceipt(receipt)
+    }
+
+    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 {
+            val engineVersion = PlayerFactoryVersion.from(playerFactory)
+            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)
+            deviceInfo.put("engineName", engineVersion.engineName)
+            deviceInfo.put("engineVersion", engineVersion.engineVersion)
+
+            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
+    }
+
+    fun detectMediaInfo(): JSONObject? {
+        val player = this.player ?: return null
+        val mediaInfo = JSONObject()
+        try {
+            mediaInfo.put("resolution", "${player.videoWidth}x${player.videoHeight}")
+            player.selectedVideoTrack?.also { track ->
+                mediaInfo.put("videoCodec", track.codec)
+                mediaInfo.put("bitrate", track.bitrate)
+                mediaInfo.put("framerate", track.frameRate)
+            }
+            player.selectedAudioTrack?.also { track ->
+                mediaInfo.put("audioCodec", track.codec)
+            }
+            player.metrics.also { metrics ->
+                mediaInfo.put("estimatedBandwidth", metrics.bandwidthEstimate)
+                mediaInfo.put("totalDataLoaded", metrics.totalDownloadedBytes)
+                if (player.live) {
+                    mediaInfo.put("liveLatency", metrics.liveLatency)
+                }
+            }
+        } catch (e: JSONException) {
+            mediaInfo.put("errorType", e.javaClass.simpleName)
+            mediaInfo.put("errorMessage", e.message)
+        }
+        return mediaInfo
+    }
+
+    val adId get() = try {
+        // Let's try Google first
+        AdvertisingIdClient.getAdvertisingIdInfo(context).id
+    } catch (e: IOException) {
+        // Probably Amazon
+        try {
+            Settings.Secure.getString(context.contentResolver, "advertising_id")
+        } catch (snfe: Settings.SettingNotFoundException) {
+            null
+        }
+    }
+
+    val limitAdTracking get() = try {
+        // Let's try Google first
+        AdvertisingIdClient.getAdvertisingIdInfo(context).isLimitAdTrackingEnabled
+    } catch (e: IOException) {
+        // Probably Amazon
+        try {
+            Settings.Secure.getInt(context.contentResolver, "limit_ad_tracking") != 0
+        } catch (snfe: Settings.SettingNotFoundException) {
+            true
+        }
+    }
+
+    val language get() = Locale.getDefault().language
+
+    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
+        }
+    }
+}