feat: filter version (gkd-kit#483)

.github/workflows/Build-Apk.yml

@@ -25,8 +25,6 @@ jobs:
 
       - name: write secrets info
         run: |
-          echo GKD_APP_CENTER_SECRET='${{ secrets.GKD_APP_CENTER_SECRET }}' >> gradle.properties
-          echo GKD_DEBUG_APP_CENTER_SECRET='${{ secrets.GKD_DEBUG_APP_CENTER_SECRET }}' >> gradle.properties
           echo ${{ secrets.GKD_STORE_FILE_BASE64 }} | base64 --decode > ${{ github.workspace }}/key.jks
           echo GKD_STORE_FILE='${{ github.workspace }}/key.jks' >> gradle.properties
           echo GKD_STORE_PASSWORD='${{ secrets.GKD_STORE_PASSWORD }}' >> gradle.properties

.github/workflows/Build-Release.yml

@@ -18,8 +18,6 @@ jobs:
 
       - name: write secrets info
         run: |
-          echo GKD_APP_CENTER_SECRET='${{ secrets.GKD_APP_CENTER_SECRET }}' >> gradle.properties
-          echo GKD_DEBUG_APP_CENTER_SECRET='${{ secrets.GKD_DEBUG_APP_CENTER_SECRET }}' >> gradle.properties
           echo ${{ secrets.GKD_STORE_FILE_BASE64 }} | base64 --decode > ${{ github.workspace }}/key.jks
           echo GKD_STORE_FILE='${{ github.workspace }}/key.jks' >> gradle.properties
           echo GKD_STORE_PASSWORD='${{ secrets.GKD_STORE_PASSWORD }}' >> gradle.properties

app/build.gradle.kts

@@ -69,9 +69,6 @@ android {
             "GIT_COMMIT_ID",
             jsonStringOf(gitInfo?.commitId)
         )
-        buildConfigField(
-            "String", "GKD_BUGLY_APP_ID", jsonStringOf(project.properties["GKD_BUGLY_APP_ID"])
-        )
         resourceConfigurations.addAll(listOf("zh", "en"))
         ndk {
             // noinspection ChromeOsAbiSupport
@@ -181,7 +178,6 @@ dependencies {
     implementation(libs.rikka.shizuku.provider)
     implementation(libs.lsposed.hiddenapibypass)
 
-    implementation(libs.tencent.bugly)
     implementation(libs.tencent.mmkv)
 
     implementation(libs.androidx.room.runtime)

app/src/main/kotlin/li/songe/gkd/App.kt

@@ -4,12 +4,10 @@ import android.app.Application
 import android.content.Context
 import android.os.Build
 import com.blankj.utilcode.util.LogUtils
-import com.tencent.bugly.crashreport.CrashReport
 import com.tencent.mmkv.MMKV
 import dagger.hilt.android.HiltAndroidApp
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.MainScope
-import li.songe.gkd.data.DeviceInfo
 import li.songe.gkd.debug.clearHttpSubs
 import li.songe.gkd.notif.initChannel
 import li.songe.gkd.util.GIT_COMMIT_URL
@@ -22,9 +20,9 @@ import org.lsposed.hiddenapibypass.HiddenApiBypass
 
 val appScope by lazy { MainScope() }
 
-private lateinit var _app: Application
+private lateinit var innerApp: Application
 val app: Application
-    get() = _app
+    get() = innerApp
 
 
 @HiltAndroidApp
@@ -38,27 +36,12 @@ class App : Application() {
 
     override fun onCreate() {
         super.onCreate()
-        _app = this
+        innerApp = this
 
-        @Suppress("SENSELESS_COMPARISON") if (BuildConfig.GKD_BUGLY_APP_ID != null) {
-            CrashReport.setDeviceModel(this, DeviceInfo.instance.model)
-            CrashReport.setIsDevelopmentDevice(this, BuildConfig.DEBUG)
-            CrashReport.initCrashReport(applicationContext,
-                BuildConfig.GKD_BUGLY_APP_ID,
-                BuildConfig.DEBUG,
-                CrashReport.UserStrategy(this).apply {
-                    setCrashHandleCallback(object : CrashReport.CrashHandleCallback() {
-                        override fun onCrashHandleStart(
-                            p0: Int,
-                            p1: String?,
-                            p2: String?,
-                            p3: String?,
-                        ): MutableMap<String, String> {
-                            LogUtils.d(p0, p1, p2, p3) // 将报错日志输出到本地
-                            return super.onCrashHandleStart(p0, p1, p2, p3)
-                        }
-                    })
-                })
+        val errorHandler = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { t, e ->
+            LogUtils.d("UncaughtExceptionHandler", t, e)
+            errorHandler?.uncaughtException(t, e)
         }
 
         MMKV.initialize(this)

app/src/main/kotlin/li/songe/gkd/MainActivity.kt

@@ -3,8 +3,8 @@ package li.songe.gkd
 import android.app.ActivityManager
 import android.content.Context
 import androidx.activity.compose.setContent
+import androidx.activity.viewModels
 import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.ui.Modifier
 import androidx.lifecycle.lifecycleScope
 import androidx.navigation.compose.rememberNavController
 import com.dylanc.activityresult.launcher.PickContentLauncher
@@ -31,6 +31,7 @@ import li.songe.gkd.util.storeFlow
 
 @AndroidEntryPoint
 class MainActivity : CompositionActivity({
+    this as MainActivity
     useLifeCycleLog()
     val launcher = StartActivityLauncher(this)
     val pickContentLauncher = PickContentLauncher(this)
@@ -62,15 +63,18 @@ class MainActivity : CompositionActivity({
                 LocalNavController provides navController
             ) {
                 DestinationsNavHost(
-                    navGraph = NavGraphs.root, navController = navController, modifier = Modifier
+                    navGraph = NavGraphs.root,
+                    navController = navController
                 )
             }
             ConfirmDialog()
             AuthDialog()
             UpgradeDialog()
         }
     }
-})
+}) {
+    val mainVm by viewModels<MainViewModel>()
+}
 
 
 

app/src/main/kotlin/li/songe/gkd/MainViewModel.kt

@@ -0,0 +1,65 @@
+package li.songe.gkd
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import li.songe.gkd.data.SubsItem
+import li.songe.gkd.db.DbSet
+import li.songe.gkd.util.authActionFlow
+import li.songe.gkd.util.checkUpdate
+import li.songe.gkd.util.initFolder
+import li.songe.gkd.util.launchTry
+import li.songe.gkd.util.logZipDir
+import li.songe.gkd.util.newVersionApkDir
+import li.songe.gkd.util.snapshotZipDir
+import li.songe.gkd.util.storeFlow
+
+class MainViewModel : ViewModel() {
+    init {
+        appScope.launchTry(Dispatchers.IO) {
+            val localSubsItem = SubsItem(
+                id = -2, order = -2, mtime = System.currentTimeMillis()
+            )
+            if (!DbSet.subsItemDao.query().first().any { s -> s.id == localSubsItem.id }) {
+                DbSet.subsItemDao.insert(localSubsItem)
+            }
+        }
+
+        viewModelScope.launchTry(Dispatchers.IO) {
+            // 每次进入删除缓存
+            listOf(snapshotZipDir, newVersionApkDir, logZipDir).forEach { dir ->
+                if (dir.isDirectory && dir.exists()) {
+                    dir.listFiles()?.forEach { file ->
+                        if (file.isFile) {
+                            file.delete()
+                        }
+                    }
+                }
+            }
+        }
+
+        viewModelScope.launchTry(Dispatchers.IO) {
+            // 在某些机型由于未知原因创建失败
+            // 在此保证每次重新打开APP都能重新检测创建
+            initFolder()
+        }
+
+        if (storeFlow.value.autoCheckAppUpdate) {
+            appScope.launch {
+                try {
+                    checkUpdate()
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+        }
+    }
+
+
+    override fun onCleared() {
+        super.onCleared()
+        authActionFlow.value = null
+    }
+}

app/src/main/kotlin/li/songe/gkd/data/AppRule.kt

@@ -7,16 +7,37 @@ class AppRule(
     rawSubs: RawSubscription,
     exclude: String?,
     val app: RawSubscription.RawApp,
+    val appInfo: AppInfo?,
 ) : ResolvedRule(
     rule = rule,
     group = group,
     subsItem = subsItem,
     rawSubs = rawSubs,
     exclude = exclude,
 ) {
+    val enable = appInfo?.let {
+        if ((rule.excludeVersionCodes
+                ?: group.excludeVersionCodes)?.contains(appInfo.versionCode) == true
+        ) {
+            return@let false
+        }
+        if ((rule.excludeVersionNames
+                ?: group.excludeVersionNames)?.contains(appInfo.versionName) == true
+        ) {
+            return@let false
+        }
+        (rule.versionCodes ?: group.versionCodes)?.apply {
+            return@let contains(appInfo.versionCode)
+        }
+        (rule.versionNames ?: group.versionNames)?.apply {
+            return@let contains(appInfo.versionName)
+        }
+
+        null
+    } ?: true
     val appId = app.id
-    val activityIds = getFixActivityIds(app.id, rule.activityIds ?: group.activityIds)
-    val excludeActivityIds =
+    private val activityIds = getFixActivityIds(app.id, rule.activityIds ?: group.activityIds)
+    private val excludeActivityIds =
         (getFixActivityIds(
             app.id,
             rule.excludeActivityIds ?: group.excludeActivityIds
@@ -25,6 +46,7 @@ class AppRule(
 
     override val type = "app"
     override fun matchActivity(appId: String, activityId: String?): Boolean {
+        if (!enable) return false
         if (appId != app.id) return false
         activityId ?: return true
         if (excludeActivityIds.any { activityId.startsWith(it) }) return false

app/src/main/kotlin/li/songe/gkd/data/GlobalRule.kt

@@ -1,5 +1,6 @@
 package li.songe.gkd.data
 
+import kotlinx.collections.immutable.ImmutableMap
 import li.songe.gkd.service.launcherAppId
 import li.songe.gkd.util.systemAppsFlow
 
@@ -16,24 +17,39 @@ class GlobalRule(
     group: RawSubscription.RawGlobalGroup,
     rawSubs: RawSubscription,
     exclude: String?,
+    appInfoCache: ImmutableMap<String, AppInfo>,
 ) : ResolvedRule(
     rule = rule,
     group = group,
     subsItem = subsItem,
     rawSubs = rawSubs,
     exclude = exclude,
 ) {
-
-    val matchAnyApp = rule.matchAnyApp ?: group.matchAnyApp ?: true
-    val matchLauncher = rule.matchLauncher ?: group.matchLauncher ?: false
-    val matchSystemApp = rule.matchSystemApp ?: group.matchSystemApp ?: false
+    private val matchAnyApp = rule.matchAnyApp ?: group.matchAnyApp ?: true
+    private val matchLauncher = rule.matchLauncher ?: group.matchLauncher ?: false
+    private val matchSystemApp = rule.matchSystemApp ?: group.matchSystemApp ?: false
     val apps = mutableMapOf<String, GlobalApp>().apply {
         (rule.apps ?: group.apps ?: emptyList()).forEach { a ->
+            val enable = a.enable ?: appInfoCache[a.id]?.let { appInfo ->
+                if (a.excludeVersionCodes?.contains(appInfo.versionCode) == true) {
+                    return@let false
+                }
+                if (a.excludeVersionNames?.contains(appInfo.versionName) == true) {
+                    return@let false
+                }
+                a.versionCodes?.apply {
+                    return@let contains(appInfo.versionCode)
+                }
+                a.versionNames?.apply {
+                    return@let contains(appInfo.versionName)
+                }
+                null
+            } ?: true
             this[a.id] = GlobalApp(
                 id = a.id,
-                enable = a.enable ?: true,
+                enable = enable,
                 activityIds = getFixActivityIds(a.id, a.activityIds),
-                excludeActivityIds = getFixActivityIds(a.id, a.excludeActivityIds)
+                excludeActivityIds = getFixActivityIds(a.id, a.excludeActivityIds),
             )
         }
     }