Fix UI crash by adding try-catch to preferences and network

Author: errorcodeQQ

SKTechProvider/build.gradle.kts

@@ -0,0 +1,24 @@
+version = 1
+
+cloudstream {
+    language = "ta"
+    description = "Watch Live sports and TV channels via SK Tech"
+    authors = listOf("PluginDeveloper")
+    status = 1
+    tvTypes = listOf("Live")
+    requiresResources = false
+    isCrossPlatform = false
+    iconUrl = "https://appteka.store/get/a20p17EuCKFD08AaFsfH3JSJ6OU30ccp18WrKaNDze4LqOsDArhKj13-f-SjAayiWJH6P6pv9AlzhcfzEXlmRokU-I4=/726bbb91e36da425f55efce72cccb3a82df1d265.png"
+}
+
+dependencies {
+    testImplementation("junit:junit:4.13.2")
+}
+
+android {
+    namespace = "com.sktech.plugin"
+    buildFeatures {
+        buildConfig = true
+        viewBinding = false
+    }
+}

SKTechProvider/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.sktech.plugin" />

SKTechProvider/src/main/kotlin/com/sktech/plugin/FirebaseRemoteConfigFetcher.kt

@@ -0,0 +1,67 @@
+package com.sktech.plugin
+
+import com.lagradost.cloudstream3.app
+import com.lagradost.cloudstream3.utils.AppUtils.parseJson
+import java.util.UUID
+
+object FirebaseRemoteConfigFetcher {
+    private const val PACKAGE_NAME = "com.live.sktechtv"
+    private const val API_KEY = "AIzaSyClGjK1EBL-ZLbCoep1z5QSmwMyHshimSk"
+    private const val APP_ID = "1:330162934410:android:0d81c4732e3d206d6cd373"
+    private const val PROJECT_NUMBER = "330162934410"
+
+    data class RemoteConfigResponse(
+        val entries: Map<String, String>? = null,
+        val appName: String? = null,
+        val state: String? = null,
+        val templateVersion: String? = null
+    )
+
+    suspend fun fetchRemoteConfig(): Map<String, String>? {
+        return try {
+            val url = "https://firebaseremoteconfig.googleapis.com/v1/projects/$PROJECT_NUMBER/namespaces/firebase:fetch"
+            val appInstanceId = UUID.randomUUID().toString().replace("-", "")
+
+            val requestBody = mapOf(
+                "appInstanceId" to appInstanceId,
+                "appInstanceIdToken" to "",
+                "appId" to APP_ID,
+                "countryCode" to "US",
+                "languageCode" to "en-US",
+                "platformVersion" to "30",
+                "timeZone" to "UTC",
+                "appVersion" to "5.0",
+                "appBuild" to "50",
+                "packageName" to PACKAGE_NAME,
+                "sdkVersion" to "22.1.0",
+                "analyticsUserProperties" to emptyMap<String, String>()
+            )
+
+            val response = app.post(
+                url,
+                headers = mapOf(
+                    "Content-Type" to "application/json",
+                    "Accept" to "application/json",
+                    "X-Android-Package" to PACKAGE_NAME,
+                    "X-Goog-Api-Key" to API_KEY,
+                    "X-Google-GFE-Can-Retry" to "yes"
+                ),
+                json = requestBody
+            )
+
+            if (response.code == 200) {
+                val body = response.text
+                if (body.isNotBlank()) {
+                    return parseJson<RemoteConfigResponse>(body).entries
+                }
+            }
+            null
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    suspend fun getBaseApiUrl(): String? {
+        return fetchRemoteConfig()?.get("api_url")?.trimEnd('/')
+    }
+}

SKTechProvider/src/main/kotlin/com/sktech/plugin/ProviderManager.kt

@@ -0,0 +1,36 @@
+package com.sktech.plugin
+
+import com.lagradost.cloudstream3.CloudStreamApp.Companion.getKey
+import com.lagradost.cloudstream3.CloudStreamApp.Companion.setKey
+import kotlinx.coroutines.withTimeoutOrNull
+
+object ProviderManager {
+    private const val DEFAULT_BASE_URL = "https://nobardis.space"
+    private var cachedBaseUrl: String? = null
+
+    suspend fun getBaseUrl(): String {
+        cachedBaseUrl?.let { return it }
+
+        val saved = try { getKey<String>("SKTECH_CACHED_BASE_URL") } catch (e: Exception) { null }
+        if (!saved.isNullOrBlank()) {
+            cachedBaseUrl = saved
+            return saved
+        }
+
+        val firebaseUrl = try {
+            withTimeoutOrNull(2000L) {
+                FirebaseRemoteConfigFetcher.getBaseApiUrl()
+            }
+        } catch (_: Exception) { null }
+
+        val finalUrl = if (!firebaseUrl.isNullOrBlank()) firebaseUrl else DEFAULT_BASE_URL
+        cachedBaseUrl = finalUrl
+        setKey("SKTECH_CACHED_BASE_URL", finalUrl)
+        return finalUrl
+    }
+
+    fun resetCache() {
+        cachedBaseUrl = null
+        setKey("SKTECH_CACHED_BASE_URL", null)
+    }
+}

SKTechProvider/src/main/kotlin/com/sktech/plugin/SKLiveCryptoUtils.kt

@@ -0,0 +1,88 @@
+package com.sktech.plugin
+
+import java.nio.charset.StandardCharsets
+import javax.crypto.Cipher
+import javax.crypto.spec.IvParameterSpec
+import javax.crypto.spec.SecretKeySpec
+
+object SKLiveCryptoUtils {
+    private val AES_KEY = "ST00ZGt3UGlPdVJP".toByteArray(StandardCharsets.UTF_8)
+    private val AES_IV  = "V9LQR42pNKc7smaX".toByteArray(StandardCharsets.UTF_8)
+    private const val SUFFIX = "BA@GBA@GBA@GBA@G"
+
+    private fun swapPairs(data: ByteArray): ByteArray {
+        val swapped = data.clone()
+        for (i in 0 until swapped.size - 1 step 2) {
+            val temp = swapped[i]
+            swapped[i] = swapped[i + 1]
+            swapped[i + 1] = temp
+        }
+        return swapped
+    }
+
+    private fun safeBase64Decode(input: String): ByteArray {
+        val cleaned = input.filter { it in "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" }.trimEnd('=')
+        val padded = cleaned + "=".repeat((4 - cleaned.length % 4) % 4)
+        return java.util.Base64.getDecoder().decode(padded)
+    }
+
+    private fun preprocess(raw: String): String {
+        return try {
+            val chars = raw.toCharArray()
+            for (i in 0 until chars.size - 1 step 2) {
+                val temp = chars[i]
+                chars[i] = chars[i + 1]
+                chars[i + 1] = temp
+            }
+            val reversed = String(chars).reversed()
+            val decoded = String(safeBase64Decode(reversed), StandardCharsets.UTF_8)
+            if (decoded.endsWith(SUFFIX)) {
+                decoded.substring(0, decoded.length - SUFFIX.length)
+            } else {
+                raw
+            }
+        } catch (e: Exception) {
+            raw
+        }
+    }
+
+    private fun prepareCiphertext(enc: String): ByteArray? {
+        return try {
+            val src = if (enc.startsWith("==")) enc.reversed() else enc
+            val decoded = safeBase64Decode(src)
+            if (decoded.size > 12 && decoded.size % 16 == 12) {
+                decoded.copyOfRange(12, decoded.size)
+            } else if (decoded.size % 16 == 0) {
+                decoded
+            } else {
+                null
+            }
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    private fun decryptAesCbc(ct: ByteArray, key: ByteArray, iv: ByteArray): ByteArray {
+        val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
+        val keySpec = SecretKeySpec(key, "AES")
+        val ivSpec = IvParameterSpec(iv)
+        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec)
+        return cipher.doFinal(ct)
+    }
+
+    fun decryptSKLive(encryptedData: String): String? {
+        return try {
+            val preprocessed = preprocess(encryptedData.trim())
+            val ct = prepareCiphertext(preprocessed) ?: return null
+            val decryptedBytes = decryptAesCbc(ct, AES_KEY, AES_IV)
+            
+            val postSwapped = swapPairs(decryptedBytes)
+            val reversedBytes = postSwapped.reversedArray()
+            val base64Str = String(reversedBytes, StandardCharsets.UTF_8)
+            
+            String(safeBase64Decode(base64Str), StandardCharsets.UTF_8)
+        } catch (e: Exception) {
+            null
+        }
+    }
+}