StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
Fix Stalker auth reuse and player defaults
David Nashash0bcff17c3db7
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.ktindex dd70c76a..0be32547 100644--- a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt+++ b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt@@ -168,6 +168,7 @@ class OkHttpStalkerApiService @Inject constructor(lastError = errorcontinue}+ profilePayload.ensureNoPortalError()evidence += "get_profile"var providerProfile = profilePayload.toProviderProfile()diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.ktindex e9a5e13d..3ba5fafa 100644--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt@@ -85,6 +85,7 @@ class StalkerProvider() : IptvProvider {internal companion object {private const val TAG = "StalkerProvider"+ private const val DEFAULT_PLAYER_USER_AGENT = "Lavf53.32.100"private val sharedAuthCache = ConcurrentHashMap<String, CachedAuth>()fun clearSharedAuthCacheForTests() {@@ -192,20 +193,14 @@ class StalkerProvider(}suspend fun streamLiveStreams(onChannel: suspend (Channel) -> Unit): Result<Int> {- return when (val authResult = ensureAuthenticated()) {- is Result.Success -> {- val (session, _) = authResult.data- val result = api.streamLiveStreams(session, currentDeviceProfile()) { item ->- toChannel(item)?.let { channel -> onChannel(channel) }- }- when (result) {- is Result.Success -> Result.success(result.data)- is Result.Error -> Result.error(result.message, result.exception)- is Result.Loading -> Result.error("Unexpected loading state")- }+ return runWithAuthorizedSession { session, _ ->+ when (val result = api.streamLiveStreams(session, currentDeviceProfile()) { item ->+ toChannel(item)?.let { channel -> onChannel(channel) }+ }) {+ is Result.Success -> Result.success(result.data)+ is Result.Error -> Result.error(result.message, result.exception)+ is Result.Loading -> Result.error("Unexpected loading state")}- is Result.Error -> Result.error(authResult.message, authResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")}}@@ -293,47 +288,32 @@ class StalkerProvider(override suspend fun getSeriesInfo(seriesId: Long): Result<Series> = getSeriesInfo(seriesId.toString())suspend fun getSeriesInfo(providerSeriesId: String): Result<Series> {- return when (val authResult = ensureAuthenticated()) {- is Result.Success -> {- val (session, _) = authResult.data- when (val detailsResult = api.getSeriesDetails(session, currentDeviceProfile(), providerSeriesId)) {- is Result.Success -> Result.success(detailsResult.data.toSeries())- is Result.Error -> Result.error(detailsResult.message, detailsResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")- }+ return runWithAuthorizedSession { session, _ ->+ when (val detailsResult = api.getSeriesDetails(session, currentDeviceProfile(), providerSeriesId)) {+ is Result.Success -> Result.success(detailsResult.data.toSeries())+ is Result.Error -> Result.error(detailsResult.message, detailsResult.exception)+ is Result.Loading -> Result.error("Unexpected loading state")}- is Result.Error -> Result.error(authResult.message, authResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")}}override suspend fun getEpg(channelId: String): Result<List<Program>> {- return when (val authResult = ensureAuthenticated()) {- is Result.Success -> {- val (session, _) = authResult.data- when (val epgResult = api.getEpg(session, currentDeviceProfile(), channelId)) {- is Result.Success -> Result.success(epgResult.data.map { it.toProgram() })- is Result.Error -> Result.error(epgResult.message, epgResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")- }+ return runWithAuthorizedSession { session, _ ->+ when (val epgResult = api.getEpg(session, currentDeviceProfile(), channelId)) {+ is Result.Success -> Result.success(epgResult.data.map { it.toProgram() })+ is Result.Error -> Result.error(epgResult.message, epgResult.exception)+ is Result.Loading -> Result.error("Unexpected loading state")}- is Result.Error -> Result.error(authResult.message, authResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")}}suspend fun getBulkEpg(periodHours: Int = 6): Result<List<Program>> {- return when (val authResult = ensureAuthenticated()) {- is Result.Success -> {- val (session, _) = authResult.data- when (val epgResult = api.getBulkEpg(session, currentDeviceProfile(), periodHours)) {- is Result.Success -> Result.success(epgResult.data.map { it.toProgram() })- is Result.Error -> Result.error(epgResult.message, epgResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")- }+ return runWithAuthorizedSession { session, _ ->+ when (val epgResult = api.getBulkEpg(session, currentDeviceProfile(), periodHours)) {+ is Result.Success -> Result.success(epgResult.data.map { it.toProgram() })+ is Result.Error -> Result.error(epgResult.message, epgResult.exception)+ is Result.Loading -> Result.error("Unexpected loading state")}- is Result.Error -> Result.error(authResult.message, authResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")}}@@ -346,15 +326,10 @@ class StalkerProvider(periodHours: Int = 6,onProgram: suspend (Program) -> Unit): Result<Int> {- return when (val authResult = ensureAuthenticated()) {- is Result.Success -> {- val (session, _) = authResult.data- api.streamBulkEpg(session, currentDeviceProfile(), periodHours) { record ->+ return runWithAuthorizedSession { session, _ ->+ api.streamBulkEpg(session, currentDeviceProfile(), periodHours) { record ->onProgram(record.toProgram())}- }- is Result.Error -> Result.error(authResult.message, authResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")}}@@ -366,30 +341,20 @@ class StalkerProvider(periodHours: Int = 6,onProgram: suspend (Program) -> Unit): Result<Int> {- return when (val authResult = ensureAuthenticated()) {- is Result.Success -> {- val (session, _) = authResult.data- api.streamEpg(session, currentDeviceProfile(), channelId, periodHours) { record ->+ return runWithAuthorizedSession { session, _ ->+ api.streamEpg(session, currentDeviceProfile(), channelId, periodHours) { record ->onProgram(record.toProgram())}- }- is Result.Error -> Result.error(authResult.message, authResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")}}override suspend fun getShortEpg(channelId: String, limit: Int): Result<List<Program>> {- return when (val authResult = ensureAuthenticated()) {- is Result.Success -> {- val (session, _) = authResult.data- when (val epgResult = api.getShortEpg(session, currentDeviceProfile(), channelId, limit)) {- is Result.Success -> Result.success(epgResult.data.map { it.toProgram() })- is Result.Error -> Result.error(epgResult.message, epgResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")- }+ return runWithAuthorizedSession { session, _ ->+ when (val epgResult = api.getShortEpg(session, currentDeviceProfile(), channelId, limit)) {+ is Result.Success -> Result.success(epgResult.data.map { it.toProgram() })+ is Result.Error -> Result.error(epgResult.message, epgResult.exception)+ is Result.Loading -> Result.error("Unexpected loading state")}- is Result.Error -> Result.error(authResult.message, authResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")}}@@ -578,7 +543,7 @@ class StalkerProvider(?: cookieModeHint).allowsRebootstrap(descriptor, accountProfile)} &&- isLikelyAuthOrSessionFailure(lastError?.message.orEmpty(), lastError?.exception)+ isAuthorizationFailure(lastError?.message.orEmpty(), lastError?.exception)if (needsRebootstrap) {invalidateAuthentication()return resolvePlaybackInfoInternal(@@ -717,44 +682,39 @@ class StalkerProvider(type: ContentType,loader: suspend (StalkerSession, StalkerDeviceProfile) -> Result<List<StalkerCategoryRecord>>): Result<List<Category>> {- return when (val authResult = ensureAuthenticated()) {- is Result.Success -> {- val (session, _) = authResult.data- when (val result = loader(session, currentDeviceProfile())) {- is Result.Success -> {- val categoryRecords = result.data.ifEmpty {- when (type) {- ContentType.MOVIE -> listOf(StalkerCategoryRecord(id = "*", name = "All Movies"))- ContentType.SERIES -> listOf(StalkerCategoryRecord(id = "*", name = "All Series"))- else -> emptyList()- }- }- val categories = categoryRecords.map { record ->- val id = syntheticCategoryId(type, record.id.ifBlank { record.name })- CategorySeed(- id = id,- rawId = record.id,- name = record.name- )+ return runWithAuthorizedSession { session, _ ->+ when (val result = loader(session, currentDeviceProfile())) {+ is Result.Success -> {+ val categoryRecords = result.data.ifEmpty {+ when (type) {+ ContentType.MOVIE -> listOf(StalkerCategoryRecord(id = "*", name = "All Movies"))+ ContentType.SERIES -> listOf(StalkerCategoryRecord(id = "*", name = "All Series"))+ else -> emptyList()}- categoryCache[type] = categories- Result.success(- categories.map { seed ->- Category(- id = seed.id,- name = seed.name,- type = type,- isAdult = AdultContentClassifier.isAdultCategoryName(seed.name)- )- }+ }+ val categories = categoryRecords.map { record ->+ val id = syntheticCategoryId(type, record.id.ifBlank { record.name })+ CategorySeed(+ id = id,+ rawId = record.id,+ name = record.name)}- is Result.Error -> Result.error(result.message, result.exception)- is Result.Loading -> Result.error("Unexpected loading state")+ categoryCache[type] = categories+ Result.success(+ categories.map { seed ->+ Category(+ id = seed.id,+ name = seed.name,+ type = type,+ isAdult = AdultContentClassifier.isAdultCategoryName(seed.name)+ )+ }+ )}+ is Result.Error -> Result.error(result.message, result.exception)+ is Result.Loading -> Result.error("Unexpected loading state")}- is Result.Error -> Result.error(authResult.message, authResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")}}@@ -763,14 +723,9 @@ class StalkerProvider(categoryId: Long?,loader: suspend (StalkerSession, StalkerDeviceProfile, String?) -> Result<List<StalkerItemRecord>>): Result<List<StalkerItemRecord>> {- return when (val authResult = ensureAuthenticated()) {- is Result.Success -> {- val (session, _) = authResult.data- val rawCategoryId = resolveRawCategoryId(type, categoryId)- loader(session, currentDeviceProfile(), rawCategoryId)- }- is Result.Error -> Result.error(authResult.message, authResult.exception)- is Result.Loading -> Result.error("Unexpected loading state")+ return runWithAuthorizedSession { session, _ ->+ val rawCategoryId = resolveRawCategoryId(type, categoryId)+ loader(session, currentDeviceProfile(), rawCategoryId)}}@@ -779,11 +734,29 @@ class StalkerProvider(categoryId: Long?,loader: suspend (StalkerSession, StalkerDeviceProfile, String?) -> Result<StalkerPagedItems>): Result<StalkerPagedItems> {+ return runWithAuthorizedSession { session, _ ->+ val rawCategoryId = resolveRawCategoryId(type, categoryId)+ loader(session, currentDeviceProfile(), rawCategoryId)+ }+ }++ private suspend fun <T> runWithAuthorizedSession(+ retryOnAuthorizationFailure: Boolean = true,+ block: suspend (StalkerSession, StalkerProviderProfile) -> Result<T>+ ): Result<T> {return when (val authResult = ensureAuthenticated()) {is Result.Success -> {- val (session, _) = authResult.data- val rawCategoryId = resolveRawCategoryId(type, categoryId)- loader(session, currentDeviceProfile(), rawCategoryId)+ val (session, profile) = authResult.data+ when (val result = block(session, profile)) {+ is Result.Error ->+ if (retryOnAuthorizationFailure && isAuthorizationFailure(result.message, result.exception)) {+ invalidateAuthentication()+ runWithAuthorizedSession(false, block)+ } else {+ Result.error(result.message, result.exception)+ }+ else -> result+ }}is Result.Error -> Result.error(authResult.message, authResult.exception)is Result.Loading -> Result.error("Unexpected loading state")@@ -904,7 +877,10 @@ class StalkerProvider(.ifBlank { session.serverCookieHeader }put("Referer", session.portalReferer)put("Accept", "*/*")- put("Accept-Encoding", "identity")+ put("Connection", "keep-alive")+ buildPlaybackHostHeader(url)?.let { host ->+ put("Host", host)+ }put("Cookie", buildPlaybackCookieHeader(serverCookieHeader, profile))put("X-User-Agent", profile.xUserAgent)session.token.takeIf { it.isNotBlank() && !omitAuthorization }?.let { token ->@@ -938,7 +914,19 @@ class StalkerProvider(profile.headerOverrides.entries.firstOrNull { (name, _) ->name.equals("User-Agent", ignoreCase = true)}?.let { (_, value) -> return value }- return profile.playerUserAgent.ifBlank { profile.userAgent.ifBlank { null } }+ return profile.playerUserAgent.ifBlank { DEFAULT_PLAYER_USER_AGENT }+ }++ private fun buildPlaybackHostHeader(url: String): String? {+ val uri = runCatching { URI(url) }.getOrNull() ?: return null+ val host = uri.host?.trim()?.takeIf { it.isNotBlank() } ?: return null+ val isDefaultPort = when {+ uri.port == -1 -> true+ uri.scheme.equals("http", ignoreCase = true) && uri.port == 80 -> true+ uri.scheme.equals("https", ignoreCase = true) && uri.port == 443 -> true+ else -> false+ }+ return if (isDefaultPort) host else "$host:${uri.port}"}private fun shouldOmitPlaybackAuthorization(url: String): Boolean {@@ -1575,27 +1563,11 @@ class StalkerProvider(return ProviderStatus.UNKNOWN}- private fun isLikelyAuthOrSessionFailure(message: String, exception: Throwable?): Boolean {+ private fun isAuthorizationFailure(message: String, exception: Throwable?): Boolean {val normalizedMessage = message.lowercase(Locale.ROOT)val exceptionMessage = exception?.message?.lowercase(Locale.ROOT).orEmpty()- return normalizedMessage.contains("http 401") ||- normalizedMessage.contains("http 403") ||- normalizedMessage.contains("http 204") ||- normalizedMessage.contains("http 456") ||- normalizedMessage.contains("authorization") ||- normalizedMessage.contains("token") ||- normalizedMessage.contains("access denied") ||- normalizedMessage.contains("forbidden") ||- normalizedMessage.contains("temporary playback link") ||- normalizedMessage.contains("no content") ||- normalizedMessage.contains("empty temporary link") ||- exceptionMessage.contains("http 401") ||- exceptionMessage.contains("http 403") ||- exceptionMessage.contains("http 204") ||- exceptionMessage.contains("http 456") ||- exceptionMessage.contains("authorization") ||- exceptionMessage.contains("token") ||- exceptionMessage.contains("no content")+ return normalizedMessage.contains("authorization failed") ||+ exceptionMessage.contains("authorization failed")}private fun validateArchiveWindow(diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.ktindex f335e5a0..0b9f0442 100644--- a/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt+++ b/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt@@ -105,6 +105,30 @@ class OkHttpStalkerApiServiceTest {assertThat(success.data.second.maxConnections).isEqualTo(2)}+ @Test+ fun authenticate_rejects_token_when_getProfile_returns_authorization_failed() = runTest {+ val service = OkHttpStalkerApiService(+ okHttpClient = fakeClient(+ "handshake" to """{"js":{"token":"token-123"}}""",+ "get_profile" to """{"js":{"error":"Authorization failed"}}"""+ ),+ json = Json { ignoreUnknownKeys = true }+ )++ val result = service.authenticate(+ buildStalkerDeviceProfile(+ portalUrl = "https://portal.example.com/c",+ macAddress = "00:1A:79:12:34:56",+ deviceProfile = "MAG250",+ timezone = "UTC",+ locale = "en"+ )+ )++ assertThat(result).isInstanceOf(Result.Error::class.java)+ assertThat((result as Result.Error).message).contains("Authorization failed")+ }+@Testfun authenticate_doesNotSwitchEndpointsAfterHandshakeSucceeds() = runTest {val requestedPaths = mutableListOf<String>()diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.ktindex 2f44f518..1edd30d5 100644--- a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt+++ b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt@@ -145,6 +145,59 @@ class StalkerProviderTest {assertThat(api.authenticateCalls).isEqualTo(2)}+ @Test+ fun getLiveCategories_reauthenticates_only_after_authorization_failed() = runTest {+ val api = FakeStalkerApiService(+ profile = StalkerProviderProfile(accountName = "Room"),+ liveCategoryResults = ArrayDeque(+ listOf(+ Result.error("Authorization failed"),+ Result.success(emptyList())+ )+ )+ )+ val provider = StalkerProvider(+ providerId = 7,+ api = api,+ portalUrl = "https://portal.example.com/c/",+ macAddress = "00:1A:79:12:34:56",+ deviceProfile = "MAG250",+ timezone = "UTC",+ locale = "en"+ )++ val result = provider.getLiveCategories()++ assertThat(result).isInstanceOf(Result.Success::class.java)+ assertThat(api.authenticateCalls).isEqualTo(2)+ }++ @Test+ fun getLiveCategories_doesNotReauthenticate_for_non_authorization_errors() = runTest {+ val api = FakeStalkerApiService(+ profile = StalkerProviderProfile(accountName = "Room"),+ liveCategoryResults = ArrayDeque(+ listOf(+ Result.error("Temporary playback link missing")+ )+ )+ )+ val provider = StalkerProvider(+ providerId = 7,+ api = api,+ portalUrl = "https://portal.example.com/c/",+ macAddress = "00:1A:79:12:34:56",+ deviceProfile = "MAG250",+ timezone = "UTC",+ locale = "en"+ )++ val result = provider.getLiveCategories()++ assertThat(result).isInstanceOf(Result.Error::class.java)+ assertThat(api.authenticateCalls).isEqualTo(1)+ }+@Testfun getLiveStreams_maps_archive_capabilities_to_catch_up_fields() = runTest {@@ -358,10 +411,48 @@ class StalkerProviderTest {assertThat(success.data.headers["Cookie"]).doesNotContain("device_id=")assertThat(success.data.headers["Cookie"]).doesNotContain("device_id2=")assertThat(success.data.headers["Cookie"]).doesNotContain("signature=")- assertThat(success.data.headers["Accept-Encoding"]).isEqualTo("identity")+ assertThat(success.data.headers["Accept"]).isEqualTo("*/*")+ assertThat(success.data.headers["Connection"]).isEqualTo("keep-alive")+ assertThat(success.data.headers["Host"]).isEqualTo("fdox.org:8080")+ assertThat(success.data.userAgent).isEqualTo("Lavf53.32.100")assertThat(success.data.allowInvalidSsl).isTrue()}+ @Test+ fun resolvePlaybackInfo_uses_mag_style_default_player_headers() = runTest {+ val provider = StalkerProvider(+ providerId = 7,+ api = FakeStalkerApiService(+ profile = StalkerProviderProfile(accountName = "Room"),+ createLinkUrl = "http://cdn.example.com/live/stream.ts"+ ),+ portalUrl = "https://portal.example.com/c/",+ macAddress = "00:1A:79:12:34:56",+ playbackBackendHint = com.streamvault.domain.model.StalkerPlaybackBackendHint.TEMP_LINK_STRICT,+ cookieModeHint = com.streamvault.domain.model.StalkerCookieMode.CREATE_LINK,+ deviceProfile = "MAG322",+ timezone = "UTC",+ locale = "en"+ )++ val result = provider.resolvePlaybackInfo(+ kind = StalkerStreamKind.LIVE,+ descriptor = checkNotNull(+ buildStalkerPlaybackDescriptor(+ primaryCmd = "ffmpeg http://localhost/ch/1200_",+ capabilities = StalkerPortalCapabilities(useHttpTemporaryLink = true)+ )+ )+ )++ assertThat(result).isInstanceOf(Result.Success::class.java)+ val success = result as Result.Success+ assertThat(success.data.userAgent).isEqualTo("Lavf53.32.100")+ assertThat(success.data.headers["Accept"]).isEqualTo("*/*")+ assertThat(success.data.headers["Connection"]).isEqualTo("keep-alive")+ assertThat(success.data.headers["Host"]).isEqualTo("cdn.example.com")+ }+@Testfun resolvePlaybackInfo_applies_custom_header_overrides_and_user_agent_removal() = runTest {val provider = StalkerProvider(@@ -581,7 +672,8 @@ class StalkerProviderTest {private val profile: StalkerProviderProfile,private val liveStreams: List<StalkerItemRecord> = emptyList(),private val createLinkUrl: String = "http://cdn.example.com/stream.ts",- private val currentCookieHeader: String = ""+ private val currentCookieHeader: String = "",+ private val liveCategoryResults: ArrayDeque<Result<List<StalkerCategoryRecord>>> = ArrayDeque()) : StalkerApiService {var createLinkCalls: Int = 0private set@@ -605,7 +697,7 @@ class StalkerProviderTest {override suspend fun getLiveCategories(session: StalkerSession,profile: StalkerDeviceProfile- ) = Result.success(emptyList<StalkerCategoryRecord>())+ ) = liveCategoryResults.removeFirstOrNull() ?: Result.success(emptyList<StalkerCategoryRecord>())override suspend fun getLiveStreams(session: StalkerSession,diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.mdindex 897a6e57..e60f2559 100644--- a/docs/CHANGELOG.md+++ b/docs/CHANGELOG.md@@ -22,6 +22,8 @@ All notable product changes are recorded in this document.- Fixed the default Stalker `get_profile` version string to use the legacy MAG 250 `5.6.10` profile value expected by stricter portals.- Fixed Stalker and Xtream setup overrides so saved User-Agent, custom headers, and Stalker advanced compatibility settings are respected across login, sync, playback resolution, and VOD/series detail requests.- Fixed Stalker HTTP proxy playback support so proxy metadata is preserved through resolved streams and also used by Android TV Input playback.+- Fixed Stalker authentication so a handshake token is only accepted after `get_profile` succeeds without an `Authorization failed` portal error, and cached portal auth now stays reused until that specific authorization failure happens.+- Fixed default Stalker player requests to use MAG-style playback defaults, including `Lavf53.32.100` as the player User-Agent plus explicit `Accept`, `Connection`, and `Host` headers.- Fixed Live TV favorites, recents, and custom-group ordered lists still collapsing SD/HD/FHD channel variants after grouped variants were disabled.### Added