Skip to content

StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.

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.kt
index 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 = error
continue
}
+ 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.kt
index 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.kt
index 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")
+ }
+
@Test
fun 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.kt
index 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)
+ }
+
@Test
fun 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")
+ }
+
@Test
fun 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 = 0
private 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.md
index 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