@24i/smartapps-bigscreen-rnv-build-engine 0.17.21-alpha.2697 → 0.17.22

package/dist/src/sdks/sdk-androidtv/sdkAndroidtv.js

@@ -145,8 +145,8 @@ const configureProject = (c) => {
     }
     const appId = rnv_1.Common.getConfigProp(c, c.platform, 'id', '');
     const minSdkVersion = rnv_1.Common.getConfigProp(c, c.platform, 'minSdkVersion', 21);
-    const targetSdkVersion = rnv_1.Common.getConfigProp(c, c.platform, 'targetSdkVersion', 33);
-    const compileSdkVersion = rnv_1.Common.getConfigProp(c, c.platform, 'compileSdkVersion', 33);
+    const targetSdkVersion = rnv_1.Common.getConfigProp(c, c.platform, 'targetSdkVersion', 34);
+    const compileSdkVersion = rnv_1.Common.getConfigProp(c, c.platform, 'compileSdkVersion', 34);
     let versionCode = rnv_1.Common.getConfigProp(c, c.platform, 'versionCode');
     if (typeof versionCode === 'undefined') {
         const major = `${semVerObj.major}`.padStart(2, '0');
@@ -202,12 +202,17 @@ const configureEntryUrl = (c) => {
     const entryUrl = getHostedAppEntryUrl(c);
     const theoLicense = process.env['THEO_LICENSE'] ||
         rnv_1.Common.getConfigProp(c, c.platform, 'theoLicense', '');
+    const npawAccountCode = process.env['NPAW_ACCOUNT_CODE'] ||
+        rnv_1.Common.getConfigProp(c, c.platform, 'npawAccountCode', '');
     const injects = [{
             pattern: '{{APP_URL}}',
             override: entryUrl,
         }, {
             pattern: '{{THEO_LICENSE}}',
             override: theoLicense,
+        }, {
+            pattern: '{{NPAW_ACCOUNT_CODE}}',
+            override: npawAccountCode,
         }];
     rnv_1.Common.addSystemInjects(c, injects);
     rnv_1.FileUtils.writeCleanFile(buildGradleFilePath, buildGradleFilePath, injects, null, c);

package/dist/templates/platforms/androidtv/project/app/build.gradle

@@ -4,6 +4,8 @@ apply plugin: 'kotlin-kapt'
 
 def theoLicense = '{{THEO_LICENSE}}'
 def useTheoPlayer = theoLicense != ''
+def npawAccountCode = '{{NPAW_ACCOUNT_CODE}}'
+def useNpawPlugin = npawAccountCode != ''
 
 android {
     namespace = 'com.twentyfouri.tvbridge'
@@ -37,6 +39,7 @@ android {
 
         buildConfigField "String", "APP_URL", '"{{APP_URL}}"'
         buildConfigField "String", "THEO_LICENSE", "\"$theoLicense\""
+        buildConfigField "String", "NPAW_ACCOUNT_CODE", "\"$npawAccountCode\""
         buildConfigField "Boolean", "startWithHighVideoQuality", "true"
     }
 
@@ -86,7 +89,7 @@ dependencies {
     api "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
 
     compileOnly "javax.annotation:jsr250-api:1.0"
-    implementation 'androidx.core:core-ktx:1.9.0'
+    implementation 'androidx.core:core-ktx:1.12.0'
     implementation "androidx.appcompat:appcompat:1.6.1"
     implementation "androidx.lifecycle:lifecycle-extensions:2.2.0"
 
@@ -94,17 +97,27 @@ dependencies {
     kapt "com.google.dagger:dagger-compiler:2.48.1"
 
     implementation "com.squareup.retrofit2:retrofit:2.9.0"
-    implementation "com.squareup.retrofit2:converter-gson:2.5.0"
+    implementation "com.squareup.retrofit2:converter-gson:2.9.0"
     implementation "com.squareup.okhttp3:logging-interceptor:4.9.2"
     implementation "com.squareup.okhttp3:okhttp:4.9.2"
     if (useTheoPlayer) {
         compileOnly "com.twentyfouri.player:exoplayer:0.7.0-alpha.3"
         implementation "com.twentyfouri.player:theoplayer:0.7.0-alpha.3"
-        implementation "com.theoplayer.theoplayer-sdk-android:core:6.8.0"
+        implementation "com.theoplayer.theoplayer-sdk-android:core:6.2.1"
     } else {
         implementation "com.twentyfouri.player:exoplayer:0.7.0-alpha.3"
         compileOnly "com.twentyfouri.player:theoplayer:0.7.0-alpha.3"
-        compileOnly "com.theoplayer.theoplayer-sdk-android:core:6.8.0"
+        compileOnly "com.theoplayer.theoplayer-sdk-android:core:6.2.1"
+    }
+
+    if (useNpawPlugin) {
+        implementation 'com.npaw.plugin:plugin:7.2.31'
+        implementation 'com.npaw.plugin:plugin-exoplayer:2.19.1-7.2.31'
+        implementation 'com.google.android.exoplayer:extension-okhttp:2.19.1'
+    } else {
+        compileOnly 'com.npaw.plugin:plugin:7.2.31'
+        compileOnly 'com.npaw.plugin:plugin-exoplayer:2.19.1-7.2.31'
+        compileOnly 'com.google.android.exoplayer:extension-okhttp:2.19.1'
     }
 
     implementation project(':common')

package/dist/templates/platforms/androidtv/project/app/src/main/java/com/twentyfouri/tvbridge/configuration/BridgeConfig.kt

@@ -14,4 +14,5 @@ class BridgeConfig {
     var customizableUrl: Boolean = BuildConfig.DEBUG
     var startWithHighVideoQuality: Boolean = false
     var theoLicense: String = BuildConfig.THEO_LICENSE
+    var npawAccount: String = BuildConfig.NPAW_ACCOUNT_CODE
 }

package/dist/templates/platforms/androidtv/project/app/src/main/java/com/twentyfouri/tvbridge/global/utils/PlayerFactoryConfigured.kt

@@ -11,6 +11,9 @@ object PlayerFactoryConfigured {
         if (bridgeConfig.theoLicense.isNotEmpty()) {
             factory = factory ?: buildTheoFactory(bridgeConfig)
         }
+        if (bridgeConfig.npawAccount.isNotEmpty()) {
+            factory = factory ?: buildNpawFactory(bridgeConfig)
+        }
         factory = factory ?: buildExoFactory(bridgeConfig)
         return factory ?: throw Exception("Cannot create player factory")
     }
@@ -23,6 +26,14 @@ object PlayerFactoryConfigured {
         }
     }
 
+    private fun buildNpawFactory(bridgeConfig: BridgeConfig): PlayerFactoryBase? {
+        try {
+            return PlayerFactoryExoPlayerNpaw(bridgeConfig)
+        } catch (e: NoClassDefFoundError) {
+            return null
+        }
+    }
+
     private fun buildTheoFactory(bridgeConfig: BridgeConfig): PlayerFactoryBase? {
         try {
             return PlayerFactoryTheoPlayerCustomized(bridgeConfig)

package/dist/templates/platforms/androidtv/project/app/src/main/java/com/twentyfouri/tvbridge/global/utils/PlayerFactoryExoPlayerNpaw.kt

@@ -0,0 +1,521 @@
+package com.twentyfouri.tvbridge.global.utils
+
+import android.annotation.SuppressLint
+import android.app.Application
+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.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.CastingEnded
+import com.twentyfouri.player.base.CastingStarted
+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.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.PlayerProxy
+import com.twentyfouri.player.exoplayer.PlayerViewAdvertisement
+import com.twentyfouri.player.exoplayer.SharedComponents
+import com.twentyfouri.tvbridge.BuildConfig
+import com.twentyfouri.tvbridge.configuration.BridgeConfig
+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
+
+    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)
+            trackPlayer(npawPlayer)
+            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")
+    }
+
+    private inner class CustomizedSharedComponents(context: Context) : DefaultSharedComponents(context) {
+
+        val application = context.applicationContext as? Application
+            ?: throw IllegalStateException("Missing application")
+
+        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() }
+
+        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 : DefaultDrmSessionManagerProvider() {
+        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)
+                    .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)
+                    }
+                }
+            }
+        }
+
+        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 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
+            }
+
+        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")
+            }
+        }
+
+        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 onPause(owner: LifecycleOwner) {
+                val player = this@NpawPlayerView.player ?: return
+                player.asPlayerExoPlayer()?.also {
+                    detachSurface(it)
+                }
+                if (!player.continueInBackground && !player.paused && player.state.source != null) {
+                    if (player.live) {
+                        player.stop()
+                    } else {
+                        player.pause()
+                    }
+                    pausedByBackground = true
+                }
+            }
+
+            override fun onResume(owner: LifecycleOwner) {
+                val player = this@NpawPlayerView.player ?: return
+                if (pausedByBackground) {
+                    pausedByBackground = false
+                    player.play()
+                }
+                player.asPlayerExoPlayer()?.also {
+                    attachSurface(it)
+                }
+            }
+
+            override fun onDestroy(owner: LifecycleOwner) {
+                context.lifecycle?.removeObserver(this)
+            }
+        }
+    }
+}
+

package/dist/templates/platforms/androidtv/project/build.gradle

@@ -38,7 +38,9 @@ allprojects {
                 password = "$mavenRepositoryPassword"
             }
         }
+        maven { url "https://maven.theoplayer.com/releases" }
         maven { url "https://jitpack.io" }
+        maven { url "https://artifact.plugin.npaw.com/artifactory/plugins/android" }
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@24i/smartapps-bigscreen-rnv-build-engine",
-	"version": "0.17.21-alpha.2697",
+	"version": "0.17.22",
 	"description": "Package with build engine for SmartApps BIGscreen projects...",
 	"main": "dist/src/index.js",
 	"scripts": {