Implement configurable debug logging and improve log maintenance

PranavPurwar · PranavPurwar · commit b1783b689174 · 2026-02-19T09:18:32.000+05:30
- Add a toggle in Settings to enable/disable debug logging (disabled by default)
- Refactor `LogUtils` to honor the logging preference and perform log purging asynchronously
- Update log rotation to purge entries older than 7 days from both audit and app log files
- Reduce log verbosity in `AppLockAccessibilityService`
- Bump version to 2.2.2 (code 222) and update build tools to 37.0.0 rc1
- Update Kotlin compiler arguments to version 2.2
diff --git a/.idea/appInsightsSettings.xml b/.idea/appInsightsSettings.xml
diff --git a/.idea/deploymentTargetSelector.xml b/.idea/deploymentTargetSelector.xml
diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -8,17 +8,17 @@ plugins {
 
 android {
     namespace = "dev.pranav.applock"
+    compileSdk = 36
     // Builds with Canary Preview won't work on non-Canary devices
     // compileSdkPreview = "CANARY"
-    compileSdk = 36
 
     defaultConfig {
         applicationId = "dev.pranav.applock"
         minSdk = 26
         targetSdk = 36
         // targetSdkPreview = "CANARY"
-        versionCode = 221
-        versionName = "2.2.1"
+        versionCode = 222
+        versionName = "2.2.2"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -50,10 +50,11 @@ android {
         includeInApk = false
         includeInBundle = false
     }
+    buildToolsVersion = "37.0.0 rc1"
+    compileSdkMinor = 1
     kotlin.compilerOptions {
         jvmTarget.set(JvmTarget.JVM_17)
     }
-    ndkVersion = "29.0.13846066 rc3"
 }
 
 dependencies {
diff --git a/app/release/app-release.apk b/app/release/app-release.apk
diff --git a/app/release/output-metadata.json b/app/release/output-metadata.json
@@ -11,8 +11,8 @@
       "type": "SINGLE",
       "filters": [],
       "attributes": [],
-      "versionCode": 8,
-      "versionName": "1.5.1",
+      "versionCode": 221,
+      "versionName": "2.2.1",
       "outputFile": "app-release.apk"
     }
   ],
diff --git a/app/src/main/java/dev/pranav/applock/AppLockApplication.kt b/app/src/main/java/dev/pranav/applock/AppLockApplication.kt
@@ -25,6 +25,7 @@ class AppLockApplication : Application() {
         initializeComponents()
 
         LogUtils.initialize(this)
+        LogUtils.setLoggingEnabled(appLockRepository.isLoggingEnabled())
         // Purge logs older than 3 days on every app start (run in background to avoid ANR)
         thread(start = true, name = "LogPurge") {
             LogUtils.purgeOldLogs()
diff --git a/app/src/main/java/dev/pranav/applock/core/utils/LogUtils.kt b/app/src/main/java/dev/pranav/applock/core/utils/LogUtils.kt
@@ -9,19 +9,27 @@ import androidx.core.content.FileProvider
 import java.io.File
 import java.time.Instant
 import java.time.temporal.ChronoUnit
+import kotlin.concurrent.thread
 
 @SuppressLint("StaticFieldLeak")
 object LogUtils {
     private const val TAG = "LogUtils"
     private const val FILE_NAME = "app_logs.txt"
     private const val SECURITY_LOGS = "audit_log.txt"
     private lateinit var context: Context
+    private var loggingEnabled = false
 
     fun initialize(application: Context) {
         context = application
     }
 
+    fun setLoggingEnabled(enabled: Boolean) {
+        loggingEnabled = enabled
+    }
+
     fun d(tag: String, message: String) {
+        if (!loggingEnabled) return
+
         val file = File(context.filesDir, SECURITY_LOGS)
 
         if (!file.exists()) {
@@ -103,48 +111,73 @@ object LogUtils {
     }
 
     /**
-     * Purge log entries older than 3 days from the audit log file.
+     * Purge log entries older than 3 days from both audit and app log files.
      * This prevents logs from growing indefinitely.
+     * Runs asynchronously to avoid blocking the main thread.
      */
     fun purgeOldLogs() {
+        thread(name = "LogPurgeThread", isDaemon = true) {
+            purgeOldLogsFromFile(File(context.filesDir, SECURITY_LOGS), "audit")
+            purgeOldLogsFromFile(File(context.cacheDir, FILE_NAME), "app")
+        }
+    }
+
+    private fun purgeOldLogsFromFile(logFile: File, logType: String) {
         try {
-            val securityLogFile = File(context.filesDir, SECURITY_LOGS)
-            if (!securityLogFile.exists()) {
+            if (!logFile.exists()) {
                 return
             }
 
-            val threeDaysAgo = Instant.now().minus(3, ChronoUnit.DAYS)
-            val lines = securityLogFile.readLines()
-            val recentLines = mutableListOf<String>()
-
-            for (line in lines) {
-                try {
-                    // Extract timestamp from log line format: "[ISO-8601 timestamp] D [TAG]: [message]"
-                    val timestampStr = line.substringBefore(" ")
-                    val timestamp = Instant.parse(timestampStr)
-                    
-                    if (timestamp.isAfter(threeDaysAgo)) {
-                        recentLines.add(line)
+            val tempDir = context.cacheDir
+            val tempLogFile = File(tempDir, logFile.name + ".processing")
+            val backupFile = File(tempDir, logFile.name + ".backup")
+
+            try {
+                logFile.copyTo(backupFile, overwrite = true)
+
+                val threeDaysAgo = Instant.now().minus(7, ChronoUnit.DAYS)
+                var purgedCount = 0
+                var keptCount = 0
+
+                backupFile.bufferedReader().use { reader ->
+                    tempLogFile.bufferedWriter().use { writer ->
+                        reader.forEachLine { line ->
+                            try {
+                                val timestampStr = line.substringBefore(" ")
+                                val timestamp = Instant.parse(timestampStr)
+
+                                if (timestamp.isAfter(threeDaysAgo)) {
+                                    writer.write(line)
+                                    writer.newLine()
+                                    keptCount++
+                                } else {
+                                    purgedCount++
+                                }
+                            } catch (_: Exception) {
+                                writer.write(line)
+                                writer.newLine()
+                                keptCount++
+                            }
+                        }
                     }
-                } catch (e: Exception) {
-                    // If we can't parse the timestamp, keep the line to avoid data loss
-                    recentLines.add(line)
                 }
-            }
 
-            // Rewrite the file with only recent logs
-            if (recentLines.size < lines.size) {
-                if (recentLines.isEmpty()) {
-                    // Delete the file if no recent logs remain
-                    securityLogFile.delete()
-                    Log.d(TAG, "Deleted log file - all entries were older than 3 days")
+                if (keptCount == 0) {
+                    logFile.delete()
+                    tempLogFile.delete()
+                    Log.d(TAG, "Deleted $logType log file - all entries were older than 3 days")
+                } else if (purgedCount > 0) {
+                    tempLogFile.copyTo(logFile, overwrite = true)
+                    tempLogFile.delete()
+                    Log.d(TAG, "Purged $purgedCount old $logType log entries")
                 } else {
-                    securityLogFile.writeText(recentLines.joinToString("\n") + "\n")
-                    Log.d(TAG, "Purged ${lines.size - recentLines.size} old log entries")
+                    tempLogFile.delete()
                 }
+            } finally {
+                backupFile.delete()
             }
         } catch (e: Exception) {
-            Log.e(TAG, "Error purging old logs", e)
+            Log.e(TAG, "Error purging old $logType logs", e)
         }
     }
 }
diff --git a/app/src/main/java/dev/pranav/applock/data/repository/AppLockRepository.kt b/app/src/main/java/dev/pranav/applock/data/repository/AppLockRepository.kt
@@ -76,6 +76,9 @@ class AppLockRepository(private val context: Context) {
     fun isShowDonateLink(): Boolean = preferencesRepository.isShowDonateLink(context)
     fun setShowDonateLink(show: Boolean) = preferencesRepository.setShowDonateLink(context, show)
 
+    fun isLoggingEnabled(): Boolean = preferencesRepository.isLoggingEnabled()
+    fun setLoggingEnabled(enabled: Boolean) = preferencesRepository.setLoggingEnabled(enabled)
+
     fun setActiveBackend(backend: BackendImplementation) =
         backendServiceManager.setActiveBackend(backend)
 
diff --git a/app/src/main/java/dev/pranav/applock/data/repository/PreferencesRepository.kt b/app/src/main/java/dev/pranav/applock/data/repository/PreferencesRepository.kt
@@ -146,6 +146,14 @@ class PreferencesRepository(context: Context) {
         settingsPrefs.edit { putBoolean(KEY_SHOW_DONATE_LINK, show) }
     }
 
+    fun isLoggingEnabled(): Boolean {
+        return settingsPrefs.getBoolean(KEY_LOGGING_ENABLED, false)
+    }
+
+    fun setLoggingEnabled(enabled: Boolean) {
+        settingsPrefs.edit { putBoolean(KEY_LOGGING_ENABLED, enabled) }
+    }
+
     companion object {
         private const val PREFS_NAME_APP_LOCK = "app_lock_prefs"
         private const val PREFS_NAME_SETTINGS = "app_lock_settings"
@@ -160,6 +168,7 @@ class PreferencesRepository(context: Context) {
         private const val KEY_BACKEND_IMPLEMENTATION = "backend_implementation"
         private const val KEY_COMMUNITY_LINK_SHOWN = "community_link_shown"
         private const val KEY_SHOW_DONATE_LINK = "show_donate_link"
+        private const val KEY_LOGGING_ENABLED = "logging_enabled"
         private const val LAST_VERSION_CODE = "last_version_code"
         private const val KEY_APPLOCK_ENABLED = "applock_enabled"
         private const val KEY_AUTO_UNLOCK = "auto_unlock"
diff --git a/app/src/main/java/dev/pranav/applock/features/settings/ui/SettingsScreen.kt b/app/src/main/java/dev/pranav/applock/features/settings/ui/SettingsScreen.kt
@@ -89,6 +89,7 @@ fun SettingsScreen(
     var unlockTimeDuration by remember { mutableIntStateOf(appLockRepository.getUnlockTimeDuration()) }
     var antiUninstallEnabled by remember { mutableStateOf(appLockRepository.isAntiUninstallEnabled()) }
     var disableHapticFeedback by remember { mutableStateOf(appLockRepository.shouldDisableHaptics()) }
+    var loggingEnabled by remember { mutableStateOf(appLockRepository.isLoggingEnabled()) }
 
     var showPermissionDialog by remember { mutableStateOf(false) }
     var showDeviceAdminDialog by remember { mutableStateOf(false) }
@@ -421,6 +422,18 @@ fun SettingsScreen(
                                     ).show()
                                 }
                             }
+                        ),
+                        ToggleSettingItem(
+                            icon = Icons.Default.Troubleshoot,
+                            title = "Logging",
+                            subtitle = "Enable debug logging for troubleshooting",
+                            checked = loggingEnabled,
+                            enabled = true,
+                            onCheckedChange = { isChecked ->
+                                loggingEnabled = isChecked
+                                appLockRepository.setLoggingEnabled(isChecked)
+                                LogUtils.setLoggingEnabled(isChecked)
+                            }
                         )
                     )
                 )
diff --git a/app/src/main/java/dev/pranav/applock/services/AppLockAccessibilityService.kt b/app/src/main/java/dev/pranav/applock/services/AppLockAccessibilityService.kt
@@ -269,13 +269,12 @@ class AppLockAccessibilityService : AccessibilityService() {
         ) {
             LogUtils.d(
                 TAG,
-                "Switched from unlocked app $unlockedApp to $currentForegroundPackage. Setting grace period tracking."
+                "Switched from unlocked app $unlockedApp to $currentForegroundPackage."
             )
             AppLockManager.setRecentlyLeftApp(unlockedApp)
             AppLockManager.clearTemporarilyUnlockedApp()
         }
 
-        LogUtils.d(TAG, event.toString())
         checkAndLockApp(currentForegroundPackage, triggeringPackage, System.currentTimeMillis())
     }
 
diff --git a/appintro/build.gradle.kts b/appintro/build.gradle.kts
@@ -35,6 +35,8 @@ android {
     buildFeatures {
         compose = true
     }
+    compileSdkMinor = 1
+    buildToolsVersion = "37.0.0 rc1"
 }
 
 dependencies {
diff --git a/fastlane/metadata/android/en-US/changelogs/222.txt b/fastlane/metadata/android/en-US/changelogs/222.txt
@@ -0,0 +1,3 @@
+- Keep security logs disabled by default
+- Don't log unnecessary information in the logs
+- Delete old logs after 7 days
diff --git a/hidden-api/build.gradle.kts b/hidden-api/build.gradle.kts
@@ -28,6 +28,8 @@ android {
         sourceCompatibility = JavaVersion.VERSION_11
         targetCompatibility = JavaVersion.VERSION_11
     }
+    compileSdkMinor = 1
+    buildToolsVersion = "37.0.0 rc1"
     kotlin.compilerOptions {
         jvmTarget.set(JvmTarget.JVM_11)
     }
diff --git a/patternlock/build.gradle.kts b/patternlock/build.gradle.kts
@@ -6,7 +6,9 @@ plugins {
 android {
     namespace = "com.mrhwsn.composelock"
     compileSdk {
-        version = release(36)
+        version = release(36) {
+            minorApiLevel = 1
+        }
     }
 
     defaultConfig {
@@ -32,6 +34,7 @@ android {
         sourceCompatibility = JavaVersion.VERSION_11
         targetCompatibility = JavaVersion.VERSION_11
     }
+    buildToolsVersion = "37.0.0 rc1"
 }
 
 dependencies {
