fix FreeNotifications for older android versions

Author: programminghoch10

FreeNotifications/build.gradle.kts

@@ -8,7 +8,7 @@ android {
 
     defaultConfig {
         minSdk = 26
-        targetSdk = 33
+        targetSdk = 36
     }
 }
 

FreeNotifications/src/main/java/de/binarynoise/freeNotifications/Hook.kt

@@ -1,6 +1,8 @@
 package de.binarynoise.freeNotifications
 
 import android.app.NotificationChannel
+import android.app.NotificationChannelGroup
+import android.os.Build
 import de.binarynoise.logger.Logger.log
 import de.binarynoise.reflection.findDeclaredField
 import de.robv.android.xposed.IXposedHookLoadPackage
@@ -14,53 +16,111 @@ import de.robv.android.xposed.XC_MethodHook as MethodHook
 class Hook : IXposedHookLoadPackage {
 
     override fun handleLoadPackage(lpparam: XC_LoadPackage.LoadPackageParam) {
-        // AOSP: mBlockableSystem / setBlockable / isBlockable
 
-        val cls = NotificationChannel::class.java
+        fun hookVariable(
+            clazz: Class<*>,
+            variableName: String,
+            setMethodName: String,
+            getMethodName: String,
+            value: Boolean,
+        ) {
+            tryAndLog("${clazz.simpleName} after constructor $variableName") {
+                val mVariable = clazz.findDeclaredField(variableName)
+                XposedBridge.hookAllConstructors(clazz, object : MethodHook() {
+                    override fun afterHookedMethod(param: MethodHookParam) {
+                        mVariable.set(param.thisObject, value)
+                    }
+                })
+            }
+            tryAndLog("${clazz.simpleName} $getMethodName") {
+                XposedHelpers.findAndHookMethod(clazz, getMethodName, returnConstant(value))
+            }
+            tryAndLog("${clazz.simpleName} $setMethodName") {
+                XposedHelpers.findAndHookMethod(clazz, setMethodName, Boolean::class.java, DO_NOTHING)
+            }
+        }
 
-        val mBlockableSystem = cls.findDeclaredField("mBlockableSystem")
+        fun String.isCharUpperCase(index: Int): Boolean {
+            return this[index] == this[index].uppercaseChar()
+        }
 
-        tryAndLog("hook NotificationChannel constructors") {
-            XposedBridge.hookAllConstructors(cls, object : MethodHook() {
-                override fun afterHookedMethod(param: MethodHookParam) {
-                    mBlockableSystem.set(param.thisObject, true)
-                }
-            })
+        /**
+         * Remove prefix only if it is used in a CamelCase sentence,
+         * only if the letter following the prefix is uppercase.
+         */
+        fun String.removeCamelCasePrefix(prefix: String): String {
+            if (!this.isCharUpperCase(prefix.length + 1)) return this.removePrefix(prefix)
+            return this
         }
-        tryAndLog("hook setBlockable") {
-            XposedHelpers.findAndHookMethod(cls, "setBlockable", Boolean::class.java, DO_NOTHING)
+        
+        fun sanitizeVariableName(name: String): String {
+            return name.removeCamelCasePrefix("m")
+                .removeCamelCasePrefix("set")
+                .removeCamelCasePrefix("is")
+                .removeCamelCasePrefix("get")
+                .replaceFirstChar { it.uppercaseChar() }
         }
-        tryAndLog("hook isBlockable") {
-            XposedHelpers.findAndHookMethod(cls, "isBlockable", returnConstant(true))
+        
+        fun hookVariable(clazz: Class<*>, variableName: String, functionName: String, value: Boolean) {
+            val sanitizedVariableName = sanitizeVariableName(variableName)
+            val sanitizedFunctionName = sanitizeVariableName(functionName)
+            return hookVariable(
+                clazz,
+                "m$sanitizedVariableName",
+                "set$sanitizedFunctionName",
+                "is$sanitizedFunctionName",
+                value,
+            )
         }
 
-        // AOSP: mImportanceLockedDefaultApp / setImportanceLockedByCriticalDeviceFunction / isImportanceLockedByCriticalDeviceFunction
+        fun hookVariable(clazz: Class<*>, name: String, value: Boolean) {
+            return hookVariable(clazz, name, name, value)
+        }
 
-        val mImportanceLockedDefaultApp = cls.findDeclaredField("mImportanceLockedDefaultApp")
+        // AOSP
+        hookVariable(
+            NotificationChannel::class.java,
+            "mBlockableSystem",
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) "setBlockable" else "setBlockableSystem",
+            true,
+        )
 
-        tryAndLog("hook constructors") {
-            XposedBridge.hookAllConstructors(cls, object : MethodHook() {
-                override fun afterHookedMethod(param: MethodHookParam) {
-                    mImportanceLockedDefaultApp.set(param.thisObject, false)
-                }
-            })
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            // AOSP
+            hookVariable(
+                NotificationChannel::class.java,
+                "mImportanceLockedDefaultApp",
+                "setImportanceLockedByCriticalDeviceFunction",
+                false,
+            )
         }
-        tryAndLog("hook setImportanceLockedByCriticalDeviceFunction") {
-            XposedHelpers.findAndHookMethod(cls, "setImportanceLockedByCriticalDeviceFunction", Boolean::class.java, DO_NOTHING)
+        
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && Build.VERSION.SDK_INT <= Build.VERSION_CODES.S_V2) {
+            // AOSP
+            hookVariable(
+                NotificationChannel::class.java,
+                "mImportanceLockedByOEM",
+                false,
+            )
         }
-        tryAndLog("hook isImportanceLockedByCriticalDeviceFunction") {
-            XposedHelpers.findAndHookMethod(cls, "isImportanceLockedByCriticalDeviceFunction", returnConstant(false))
+        
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            // AOSP
+            hookVariable(
+                NotificationChannelGroup::class.java,
+                "mBlocked",
+                false,
+            )
         }
     }
 }
 
 private inline fun tryAndLog(message: String, block: () -> Unit) {
-    log(message)
     return try {
         block()
-        log("done!")
+        log("hook $message successful!")
     } catch (t: Throwable) {
-        log("failed!")
+        log("hook $message failed!", t)
         XposedBridge.log(t)
     }
 }