@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/global/utils/PlayerFactoryExoPlayerNpaw.kt

@@ -0,0 +1,581 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.ContextWrapper
+import android.os.Bundle
+import android.os.Parcelable
+import android.util.AttributeSet
+import android.view.Gravity
+import android.view.MotionEvent
+import android.view.SurfaceView
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewGroup.LayoutParams.MATCH_PARENT
+import android.widget.FrameLayout
+import android.widget.ImageView
+import android.widget.Space
+import androidx.appcompat.widget.AppCompatImageView
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import com.google.android.exoplayer2.C
+import com.google.android.exoplayer2.ExoPlayerLibraryInfo
+import com.google.android.exoplayer2.Player
+import com.google.android.exoplayer2.drm.DefaultDrmSessionManager
+import com.google.android.exoplayer2.drm.DrmSessionManager
+import com.google.android.exoplayer2.drm.FrameworkMediaDrm
+import com.google.android.exoplayer2.drm.MediaDrmCallback
+import com.google.android.exoplayer2.ext.okhttp.OkHttpDataSource
+import com.google.android.exoplayer2.text.Cue
+import com.google.android.exoplayer2.text.CueGroup
+import com.google.android.exoplayer2.text.TextOutput
+import com.google.android.exoplayer2.ui.AdOverlayInfo
+import com.google.android.exoplayer2.ui.AdViewProvider
+import com.google.android.exoplayer2.ui.AspectRatioFrameLayout
+import com.google.android.exoplayer2.ui.SubtitleView
+import com.google.android.exoplayer2.upstream.HttpDataSource
+import com.google.android.exoplayer2.upstream.LoadErrorHandlingPolicy
+import com.google.android.exoplayer2.upstream.cache.CacheDataSource
+import com.google.android.exoplayer2.video.VideoSize
+import com.npaw.NpawPlugin
+import com.npaw.analytics.video.VideoAdapter
+import com.npaw.analytics.video.VideoOptions
+import com.npaw.core.options.AnalyticsOptions
+import com.npaw.exoplayer.ExoPlayerAdapter
+import com.npaw.exoplayer.ExoPlayerBalancer
+import com.twentyfouri.player.base.BackgroundMode
+import com.twentyfouri.player.base.CastingEnded
+import com.twentyfouri.player.base.CastingStarted
+import com.twentyfouri.player.base.CastingType
+import com.twentyfouri.player.base.DrmPlayready
+import com.twentyfouri.player.base.DrmWidevine
+import com.twentyfouri.player.base.EventListenerDispose
+import com.twentyfouri.player.base.PlayerBase
+import com.twentyfouri.player.base.PlayerGesturesTarget
+import com.twentyfouri.player.base.PlayerProxy
+import com.twentyfouri.player.base.PlayerSurface
+import com.twentyfouri.player.base.ResizeEvent
+import com.twentyfouri.player.base.ScaleType
+import com.twentyfouri.player.base.Source
+import com.twentyfouri.player.base.SourceAuthorization
+import com.twentyfouri.player.base.SourceDrm
+import com.twentyfouri.player.base.SourceMetadata
+import com.twentyfouri.player.base.addEventListener
+import com.twentyfouri.player.base.buildUpon
+import com.twentyfouri.player.base.getBoolean
+import com.twentyfouri.player.base.getString
+import com.twentyfouri.player.exoplayer.AuthorizedDataSourceProvider
+import com.twentyfouri.player.exoplayer.DefaultDrmSessionManagerProvider
+import com.twentyfouri.player.exoplayer.DefaultPlayerComponents
+import com.twentyfouri.player.exoplayer.DefaultSharedComponents
+import com.twentyfouri.player.exoplayer.DrmSessionManagerProvider
+import com.twentyfouri.player.exoplayer.PlayerComponents
+import com.twentyfouri.player.exoplayer.PlayerExoPlayer
+import com.twentyfouri.player.exoplayer.PlayerFactoryExoPlayer
+import com.twentyfouri.player.exoplayer.PlayerViewAdvertisement
+import com.twentyfouri.player.exoplayer.SharedComponents
+import com.twentyfouri.tvbridge.BuildConfig
+import com.twentyfouri.tvbridge.configuration.BridgeConfig
+import java.util.WeakHashMap
+import com.npaw.core.util.extensions.Log as NpawLog
+
+class PlayerFactoryExoPlayerNpaw(
+    private val config: BridgeConfig
+) : PlayerFactoryExoPlayer(), PlayerFactoryVersion {
+
+    override val engineName: String = "Exoplayer"
+
+    override val engineVersion: String = ExoPlayerLibraryInfo.VERSION
+
+    private val activePlayers = WeakHashMap<PlayerBase, Boolean>()
+
+    override fun createSharedComponents(context: Context): SharedComponents =
+            CustomizedSharedComponents(context)
+    
+    override fun createView(parent: ViewGroup): View {
+        return NpawPlayerView(parent.context).also {
+            val basePlayer = createPlayer(parent.context)
+            val npawPlugin = (
+                    (basePlayer.components as CustomizedPlayerComponents)
+                        .sharedComponents as CustomizedSharedComponents
+                    ).npawPlugin
+            val npawPlayer = NpawPlayer(basePlayer, npawPlugin)
+            activePlayers[npawPlayer] = true
+            it.player = npawPlayer
+        }
+    }
+
+    override fun getPlayerSurface(view: View): PlayerSurface {
+        return view as NpawPlayerView
+    }
+
+    override fun getPlayer(view: View): PlayerBase {
+        return (view as NpawPlayerView).player
+            ?: throw IllegalStateException("Player was not initialized by PlayerFactory")
+    }
+
+    override fun release() {
+        activePlayers.keys.forEach {
+            it.destroy()
+        }
+        activePlayers.clear()
+        super.release()
+    }
+
+    private inner class CustomizedSharedComponents(context: Context) : DefaultSharedComponents(context) {
+
+        val npawPlugin: NpawPlugin = NpawPlugin
+            .Builder(application, config.npawAccount)
+            .setLogLevel(if (BuildConfig.DEBUG) NpawLog.Level.VERBOSE else NpawLog.Level.ERROR)
+            .build()
+
+        val npawBalancer = ExoPlayerBalancer(npawPlugin)
+
+        override fun destroy() {
+            super.destroy()
+            npawPlugin.destroy()
+        }
+
+        override val drmProvider: DrmSessionManagerProvider by lazy {
+            CustomizedDrmSessionManagerProvider(loadErrorHandlingPolicy)
+        }
+
+        override val applicationName: String
+            get() = config.playerAppName ?: super.applicationName
+
+        override fun buildIsolatedComponents(): PlayerComponents {
+            return CustomizedPlayerComponents(this)
+        }
+
+        override val baseHttpFactory: HttpDataSource.Factory by lazy {
+            npawBalancer.dataSourceFactory as OkHttpDataSource.Factory
+        }
+
+        override val dataSourceFactory: AuthorizedDataSourceProvider by lazy {
+            object : AuthorizedDataSourceProvider {
+                override fun buildDataSourceFactory(authorization: SourceAuthorization?): CacheDataSource.Factory {
+                    return buildReadOnlyDataSourceFactory(baseHttpFactory)
+                }
+
+                override fun buildHttpDataSourceFactory(authorization: SourceAuthorization?): HttpDataSource.Factory {
+                    return baseHttpFactory
+                }
+            }
+        }
+
+        override val cacheDataSourceFactory: AuthorizedDataSourceProvider by lazy {
+            dataSourceFactory
+        }
+    }
+
+    private inner class CustomizedPlayerComponents(shared: SharedComponents) : DefaultPlayerComponents(shared) {
+        override val handleAudioFocus: Boolean
+            get() = false
+    }
+
+    private class CustomizedDrmSessionManagerProvider(
+        loadErrorHandlingPolicy: LoadErrorHandlingPolicy
+    ) : DefaultDrmSessionManagerProvider(loadErrorHandlingPolicy) {
+        override fun buildDrmSessionManager(
+            dataSourceFactory: AuthorizedDataSourceProvider,
+            source: Source,
+            sourceDrm: SourceDrm
+        ): DrmSessionManager? {
+            if (sourceDrm is SourceDrmOverridden) {
+                return buildDrmOverridden(dataSourceFactory, sourceDrm)
+            } else {
+                return super.buildDrmSessionManager(dataSourceFactory, source, sourceDrm)
+            }
+        }
+
+        private fun buildDrmOverridden(dataSourceFactory: AuthorizedDataSourceProvider, sourceDrm: SourceDrmOverridden): DrmSessionManager? {
+            val drmUuid = when (sourceDrm.packageName) {
+                DrmWidevine.packageName -> C.WIDEVINE_UUID
+                DrmPlayready.packageName -> C.PLAYREADY_UUID
+                else -> C.UUID_NIL
+            }
+            val licenseUrl = sourceDrm.licenseServer?.toString() ?: ""
+            val forceLicenseUrl = sourceDrm.forceLicenseServer
+            val httpDataSourceFactory = dataSourceFactory.buildHttpDataSourceFactory(sourceDrm.authorization)
+
+            val drmCallback = LoggingDrmCallback(
+                    OverriddenHttpMediaDrmCallback(
+                            licenseUrl,
+                            forceLicenseUrl,
+                            httpDataSourceFactory
+                    ),
+                    licenseUrl
+            )
+
+            return DefaultDrmSessionManager.Builder()
+                    .setUuidAndExoMediaDrmProvider(drmUuid, FrameworkMediaDrm.DEFAULT_PROVIDER)
+                    .setMultiSession(false)
+                    .setLoadErrorHandlingPolicy(loadErrorHandlingPolicy)
+                    .build(drmCallback)
+        }
+
+        override fun buildDrmCallback(licenseUrl: String, forceLicenseUrl: Boolean, httpDataSourceFactory: HttpDataSource.Factory): MediaDrmCallback {
+            return LoggingDrmCallback(super.buildDrmCallback(licenseUrl, forceLicenseUrl, httpDataSourceFactory), licenseUrl)
+        }
+    }
+
+    private class NpawPlayer(
+        val basePlayer: PlayerExoPlayer,
+        val npawPlugin: NpawPlugin
+    ) : PlayerBase by basePlayer {
+        var exoPlayerAdapter: ExoPlayerAdapter? = null
+
+        var videoAdapter: VideoAdapter? = null
+            set(value) {
+                field?.destroy()
+                field = value
+            }
+
+        fun extractYouboraAnalyticsOptions(source: Source?, target: AnalyticsOptions) {
+            if (source == null) return
+            val jsonAnalyticsArray = source.extras?.optJSONArray("analytics") ?: return
+            for (index in 0 until jsonAnalyticsArray.length()) {
+                val jsonAnalytics = jsonAnalyticsArray.getJSONObject(index)
+                if (jsonAnalytics.getString("integration", "") != "youbora") continue
+                jsonAnalytics.keys().forEach { key ->
+                    when (key) {
+                        "app.name" -> target.appName = jsonAnalytics.getString(key, null)
+                        "app.releaseVersion" -> target.appReleaseVersion = jsonAnalytics.getString(key, null)
+                        "device.id" -> target.deviceId = jsonAnalytics.getString(key, null)
+                        "username" -> target.username = jsonAnalytics.getString(key, null)
+                    }
+                }
+            }
+        }
+
+        fun extractYouboraVideoOptions(source: Source?, target: VideoOptions) {
+            if (source == null) return
+            val jsonAnalyticsArray = source.extras?.optJSONArray("analytics") ?: return
+            for (index in 0 until jsonAnalyticsArray.length()) {
+                val jsonAnalytics = jsonAnalyticsArray.getJSONObject(index)
+                if (jsonAnalytics.getString("integration", "") != "youbora") continue
+                jsonAnalytics.keys().forEach { key ->
+                    when (key) {
+                        "content.id" -> target.contentId = jsonAnalytics.getString(key, null)
+                        "content.title" -> target.contentTitle = jsonAnalytics.getString(key, null)
+                        "content.isLive" -> target.live = jsonAnalytics.getBoolean(key, false)
+                        "content.type" -> target.contentType = jsonAnalytics.getString(key, null)
+                        "content.program" -> target.program = jsonAnalytics.getString(key, null)
+                        "content.channel" -> target.contentChannel = jsonAnalytics.getString(key, null)
+                        "content.episodeTitle" -> target.contentEpisodeTitle = jsonAnalytics.getString(key, null)
+                        "content.season" -> target.contentSeason = jsonAnalytics.getString(key, null)
+                        "content.tvShow" -> target.contentTvShow = jsonAnalytics.getString(key, null)
+                        "content.customDimension.1" -> target.contentCustomDimension1 = jsonAnalytics.getString(key, null)
+                        "content.customDimension.2" -> target.contentCustomDimension2 = jsonAnalytics.getString(key, null)
+                    }
+                }
+            }
+        }
+
+        override var source: Source?
+            get() = basePlayer.source
+            set(value) {
+                exoPlayerAdapter = null
+                videoAdapter = null
+                if (value != null) {
+                    val videoOptions = VideoOptions()
+                    extractYouboraAnalyticsOptions(value, npawPlugin.analyticsOptions)
+                    extractYouboraVideoOptions(value, videoOptions)
+                    
+                    var adjustedSource = value
+                    if (value.metadata?.title.isNullOrEmpty() && !videoOptions.contentTitle.isNullOrEmpty()) {
+                        adjustedSource = value.buildUpon { 
+                            metadata = (metadata?.buildUpon() ?: SourceMetadata.Builder()).apply { 
+                                title = videoOptions.contentTitle
+                            }.build()
+                        }
+                    }
+                    
+                    basePlayer.source = adjustedSource
+                    exoPlayerAdapter = ExoPlayerAdapter(basePlayer.components.context, basePlayer.exoPlayer)
+                    videoAdapter = npawPlugin.videoBuilder()
+                        .setPlayerAdapter(exoPlayerAdapter)
+                        .setOptions(videoOptions)
+                        .build()
+                } else {
+                    basePlayer.source = null
+                }
+            }
+
+        override fun unload() {
+            exoPlayerAdapter = null
+            videoAdapter = null
+            basePlayer.unload()
+        }
+
+        override fun destroy() {
+            exoPlayerAdapter = null
+            videoAdapter = null
+            basePlayer.destroy()
+        }
+    }
+
+    class NpawPlayerView @JvmOverloads constructor(
+        context: Context,
+        attrs: AttributeSet? = null,
+        defStyleAttr: Int = 0
+    ) : FrameLayout(context, attrs, defStyleAttr), AdViewProvider, PlayerSurface {
+
+        private val componentListener = ComponentListener()
+        private val onDetachPlayer = EventListenerDispose()
+
+        val videoFrame: AspectRatioFrameLayout = AspectRatioFrameLayout(context)
+        val surfaceView: View = when {
+            isInEditMode -> Space(context)
+            else -> SurfaceView(context)
+        }
+        val posterView: ImageView = AppCompatImageView(context).also {
+            it.scaleType = ImageView.ScaleType.FIT_CENTER
+        }
+        val subtitleView: SubtitleView = SubtitleView(context)
+        val adOverlay: PlayerViewAdvertisement = PlayerViewAdvertisement(context).also {
+            it.fitsSystemWindows = true
+        }
+        override var adObstructions: List<View> = emptyList()
+        override var gesturesTarget: PlayerGesturesTarget?
+            get() = adOverlay.gesturesTarget
+            set(value) {
+                adOverlay.gesturesTarget = value
+            }
+
+        override var supportsPictureInPicture: Boolean
+            get() = false
+            set(value) {}
+
+        var player: PlayerBase? = null
+            set(value) {
+                if (field == value) return
+                field?.also { detachPlayer(it) }
+                field = value
+                field?.also { attachPlayer(it) }
+            }
+
+        var pausedByBackground: Boolean = false
+            get() = player?.asPlayerExoPlayer()?.pausedByBackground ?: field
+            set(value) {
+                field = value
+                player?.asPlayerExoPlayer()?.pausedByBackground = value
+            }
+        var surfaceAttached: Boolean = false
+
+        init {
+            if (!isInEditMode) {
+                subtitleView.setUserDefaultTextSize()
+                subtitleView.setUserDefaultStyle()
+                subtitleView.setApplyEmbeddedStyles(false)
+            }
+
+            addView(videoFrame, LayoutParams(MATCH_PARENT, MATCH_PARENT, Gravity.CENTER))
+            videoFrame.addView(surfaceView, MATCH_PARENT, MATCH_PARENT)
+            videoFrame.addView(subtitleView, MATCH_PARENT, MATCH_PARENT)
+            addView(posterView, MATCH_PARENT, MATCH_PARENT)
+            addView(adOverlay, MATCH_PARENT, MATCH_PARENT)
+
+            context.lifecycle?.addObserver(componentListener)
+        }
+
+        private val Context.lifecycle: Lifecycle?
+            get() = when (this) {
+                is LifecycleOwner -> lifecycle
+                is ContextWrapper -> baseContext.lifecycle
+                else -> null
+            }
+
+        private fun detachPlayer(player: PlayerBase) {
+            onDetachPlayer()
+            player.asPlayerExoPlayer()?.also { detachSurface(it) }
+        }
+
+        private fun detachSurface(player: PlayerExoPlayer) {
+            if (!surfaceAttached) return
+            surfaceAttached = false
+            player.exoPlayer.removeListener(componentListener)
+            player.adViewProvider = null
+            player.posterSurface = null
+            player.videoSurface = null
+            subtitleView.setCues(null)
+        }
+
+        private fun attachPlayer(player: PlayerBase) {
+            player.asPlayerExoPlayer()?.also { attachSurface(it) }
+            player.fullscreen = isFullscreen
+            onDetachPlayer += player.addEventListener<ResizeEvent> {
+                videoFrame.resizeMode = player.scaleType.toResizeMode()
+            }
+            onDetachPlayer += player.addEventListener<CastingStarted> {
+                player.asPlayerExoPlayer()?.also { detachSurface(it) }
+            }
+            onDetachPlayer += player.addEventListener<CastingEnded> {
+                player.asPlayerExoPlayer()?.also { attachSurface(it) }
+            }
+            videoFrame.resizeMode = player.scaleType.toResizeMode()
+        }
+
+        private fun attachSurface(player: PlayerExoPlayer) {
+            if (surfaceAttached) return
+            surfaceAttached = true
+            player.exoPlayer.addListener(componentListener)
+            player.adViewProvider = this
+            player.posterSurface = posterView
+            player.videoSurface = surfaceView as? SurfaceView
+        }
+
+        private fun PlayerBase.asPlayerExoPlayer(): PlayerExoPlayer? = when {
+            this is PlayerExoPlayer -> this
+            this is PlayerProxy -> this.base?.asPlayerExoPlayer()
+            this is NpawPlayer -> this.basePlayer
+            else -> null
+        }
+
+        protected fun ScaleType?.toResizeMode(): Int = when (this) {
+            ScaleType.STRETCH -> AspectRatioFrameLayout.RESIZE_MODE_FILL
+            ScaleType.ZOOM -> AspectRatioFrameLayout.RESIZE_MODE_ZOOM
+            else -> AspectRatioFrameLayout.RESIZE_MODE_FIT
+        }
+
+        private var isFullscreen = false
+            set(value) {
+                if (field == value) return
+                field = value
+                player?.fullscreen = isFullscreen
+            }
+
+        override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+            super.onLayout(changed, left, top, right, bottom)
+
+            val displayMetrics = context.resources.displayMetrics
+            val screenWidth = displayMetrics.widthPixels
+            val minFullWidth = screenWidth * 9 / 10
+            val screenHeight = displayMetrics.heightPixels
+            val minFullHeight = screenHeight * 9 / 10
+            val width = right - left
+            val height = bottom - top
+            isFullscreen = width >= minFullWidth && height >= minFullHeight
+        }
+
+        @SuppressLint("ClickableViewAccessibility")
+        override fun onTouchEvent(event: MotionEvent): Boolean {
+            return gesturesTarget?.onDelegatedTouchEvent(event) ?: super.onTouchEvent(event)
+        }
+
+        override fun getAdViewGroup(): ViewGroup =
+            adOverlay
+
+        override fun getAdOverlayInfos(): List<AdOverlayInfo> =
+            adObstructions.map { AdOverlayInfo.Builder(it, AdOverlayInfo.PURPOSE_CONTROLS).build() }
+
+        override fun onSaveInstanceState(): Parcelable {
+            val state = Bundle()
+            state.putParcelable("base", super.onSaveInstanceState())
+            state.putBoolean("pausedByBackground", pausedByBackground)
+            return state
+        }
+
+        override fun onRestoreInstanceState(state: Parcelable?) {
+            val bundle = state as? Bundle
+            if (bundle == null) {
+                super.onRestoreInstanceState(state)
+            } else {
+                super.onRestoreInstanceState(bundle.getParcelable("base"))
+                pausedByBackground = bundle.getBoolean("pausedByBackground")
+            }
+        }
+
+        override fun onUserLeaveHint() {
+            (player as? PlayerProxy)?.onUserLeaveHint()
+        }
+
+        override fun onPictureInPictureModeChanged(inPictureInPictureMode: Boolean) {
+        }
+
+        fun autoPauseByBackground() {
+            val player = this.player ?: return
+            if (player.live) {
+                player.stop()
+            } else {
+                player.pause()
+            }
+            pausedByBackground = true
+        }
+
+        private inner class ComponentListener : TextOutput, Player.Listener,
+            DefaultLifecycleObserver {
+            override fun onCues(cueGroup: CueGroup) {
+                subtitleView.setCues(cueGroup.cues)
+            }
+
+            @Deprecated("No longer used")
+            override fun onCues(cues: MutableList<Cue>) {
+                // only overridden because compiler is confused about multiple default implementations
+            }
+
+            override fun onVideoSizeChanged(videoSize: VideoSize) {
+                videoFrame.resizeMode = player?.scaleType.toResizeMode()
+                videoFrame.setAspectRatio(
+                    when {
+                        videoSize.height <= 0 -> 1f
+                        else -> videoSize.width * videoSize.pixelWidthHeightRatio / videoSize.height
+                    }
+                )
+            }
+
+            override fun onIsPlayingChanged(isPlaying: Boolean) {
+                this@NpawPlayerView.keepScreenOn = isPlaying
+            }
+
+            override fun onStop(owner: LifecycleOwner) {
+                val player = this@NpawPlayerView.player ?: return
+                player.asPlayerExoPlayer()?.also {
+                    detachSurface(it)
+                }
+                if (
+                    !player.paused && player.state.source != null &&
+                    player.castingType == CastingType.NONE
+                ) {
+                    val shouldPause = when (player.continueInBackgroundMode) {
+                        BackgroundMode.PAUSE -> true
+                        BackgroundMode.PICTURE_IN_PICTURE -> when {
+                            player.isCastingHost -> false
+                            player.pictureInPicture -> false
+                            else -> true    // PiP disabled in system settings?
+                        }
+                        else -> false
+                    }
+                    if (shouldPause) {
+                        autoPauseByBackground()
+                    }
+                }
+                if (player is PlayerProxy) {
+                    player.onLifecycleStop()
+                }
+            }
+
+            override fun onStart(owner: LifecycleOwner) {
+                val player = this@NpawPlayerView.player ?: return
+                if (pausedByBackground) {
+                    pausedByBackground = false
+                    player.play()
+                }
+                if (player is PlayerProxy) {
+                    player.onLifecycleStart()
+                }
+                player.asPlayerExoPlayer()?.also {
+                    if (player.castingType == CastingType.NONE) {
+                        attachSurface(it)
+                    }
+                }
+            }
+
+            override fun onDestroy(owner: LifecycleOwner) {
+                context.lifecycle?.removeObserver(this)
+            }
+        }
+    }
+}
+

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/com/twentyfouri/tvbridge/global/utils/PlayerFactoryVersion.kt

@@ -0,0 +1,27 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import com.twentyfouri.player.base.PlayerFactoryBase
+
+interface PlayerFactoryVersion {
+    val engineName: String
+    val engineVersion: String
+
+    private data class Fixed(
+        override val engineName: String,
+        override val engineVersion: String
+    ): PlayerFactoryVersion
+
+    companion object {
+        fun from(factory: PlayerFactoryBase): PlayerFactoryVersion {
+            (factory as? PlayerFactoryVersion)?.also { return it }
+
+            // fallback to just engine name
+            val engineName = factory.javaClass.simpleName
+                .replace("PlayerFactory", "")
+                .replace("Customized", "")
+                .lowercase()
+            val engineVersion = "0.0.0"
+            return Fixed(engineName, engineVersion)
+        }
+    }
+}

package/dist/templates/platforms/firetv/project/app/src/main/kotlin/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
+    }
+}