refactor + fix bugs + add modify group option in dock

Author: guruswarupa

app/release/app-release.apk

@@ -21,6 +21,7 @@ import android.widget.LinearLayout
 import android.widget.PopupWindow
 import android.widget.TextView
 import android.widget.Toast
+import androidx.core.content.ContextCompat
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.textfield.TextInputEditText
 import com.google.android.material.textfield.TextInputLayout
@@ -330,22 +331,28 @@ class AppDockManager(
     }
 
     private fun showRemoveDockAppDialog(item: String) {
+        // Options for the dialog
         val options = if (item.startsWith("group:")) {
-            arrayOf("Remove", "Rename")
+            arrayOf("Remove", "Rename", "Modify Group")
         } else {
             arrayOf("Remove")
         }
 
-        MaterialAlertDialogBuilder(context)
+        // Create the dialog
+        MaterialAlertDialogBuilder(context, R.style.CustomDialogTheme)
             .setTitle("Manage Dock Item")
             .setItems(options) { _, which ->
                 when (which) {
                     0 -> removeDockItem(item)
                     1 -> if (item.startsWith("group:")) showRenameGroupDialog(item)
+                    2 -> if (item.startsWith("group:")) showModifyGroupDialog(item)
                 }
                 refreshDock()
             }
-            .setNegativeButton("Cancel", null)
+            .setNegativeButton("Cancel") { dialog, _ ->
+                dialog.dismiss()
+            }
+            .setBackground(ContextCompat.getDrawable(context, R.drawable.dialog_background)) // Custom background
             .show()
     }
 
@@ -387,6 +394,53 @@ class AppDockManager(
             .show()
     }
 
+    private fun showModifyGroupDialog(item: String) {
+        if (!item.startsWith("group:")) return
+
+        val parts = item.split(":", limit = 3)
+        if (parts.size != 3) return
+
+        val groupName = parts[1]
+        val currentPackageNames = parts[2].split(',').toMutableList()
+
+        val intent = Intent(Intent.ACTION_MAIN).apply {
+            addCategory(Intent.CATEGORY_LAUNCHER)
+        }
+        val apps = packageManager.queryIntentActivities(intent, 0)
+        val sortedApps = apps.sortedBy { it.loadLabel(packageManager).toString().lowercase() }
+        val appNames = sortedApps.map { it.loadLabel(packageManager).toString() }
+        val appPackageNames = sortedApps.map { it.activityInfo.packageName }
+
+        val checkedItems = BooleanArray(appNames.size) { false }
+        appPackageNames.forEachIndexed { index, packageName ->
+            if (currentPackageNames.contains(packageName)) {
+                checkedItems[index] = true
+            }
+        }
+
+        AlertDialog.Builder(context)
+            .setTitle("Modify Group: $groupName")
+            .setMultiChoiceItems(appNames.toTypedArray(), checkedItems) { _, which, isChecked ->
+                val packageName = appPackageNames[which]
+                if (isChecked) {
+                    currentPackageNames.add(packageName)
+                } else {
+                    currentPackageNames.remove(packageName)
+                }
+            }
+            .setPositiveButton("Save") { _, _ ->
+                if (currentPackageNames.size >= 2) {
+                    removeDockItem(item)
+                    addGroupToDock(currentPackageNames, groupName)
+                    refreshDock()
+                } else {
+                    Toast.makeText(context, "A group must have at least 2 apps", Toast.LENGTH_SHORT).show()
+                }
+            }
+            .setNegativeButton("Cancel", null)
+            .show()
+    }
+
     private fun showGroupNameDialog(selectedPackages: List<String>) {
         val editText = EditText(context)
         AlertDialog.Builder(context)

app/release/baselineProfiles/0/app-release.dm

@@ -8,157 +8,116 @@ import android.net.Uri
 import android.widget.EditText
 import android.widget.Toast
 import androidx.recyclerview.widget.RecyclerView
+import kotlinx.coroutines.*
+import java.util.concurrent.ConcurrentHashMap
 
 class AppSearchManager(
-    private val packageManager: PackageManager,
-    private val appList: MutableList<ResolveInfo>,
-    private val fullAppList: MutableList<ResolveInfo>,
+    private val pm: PackageManager,
+    private val apps: MutableList<ResolveInfo>,
+    private var allApps: MutableList<ResolveInfo>,
     private val adapter: AppAdapter,
-    private val recyclerView: RecyclerView,
-    private val searchBox: EditText,
-    private val contactsList: List<String> // List of contact names or numbers
+    private val rv: RecyclerView,
+    private val search: EditText,
+    private val contacts: List<String>
 ) {
+    private var searchJob: Job? = null
+    private val searchScope = CoroutineScope(Dispatchers.Main)
+    private var currentQuery: String = ""
+    private val appLabels = ConcurrentHashMap<ResolveInfo, String>() // Cache app labels
 
     init {
-        searchBox.addTextChangedListener(object : android.text.TextWatcher {
-            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
+        // Pre-cache app labels for faster lookup
+        CoroutineScope(Dispatchers.IO).launch {
+            allApps.forEach { app ->
+                appLabels[app] = app.loadLabel(pm).toString().lowercase()
+            }
+        }
+
+        search.addTextChangedListener(object : android.text.TextWatcher {
+            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
+                // Implementation (can be empty if not needed)
+            }
 
             override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
-                filterAppsAndContacts(s.toString())
+                val newQuery = s.toString()
+                if (newQuery != currentQuery) {
+                    currentQuery = newQuery
+                    searchJob?.cancel() // Cancel previous job
+                    searchJob = searchScope.launch {
+                        delay(300) // Debounce delay
+                        filter(newQuery)
+                    }
+                }
             }
 
-            override fun afterTextChanged(s: android.text.Editable?) {}
+            override fun afterTextChanged(s: android.text.Editable?) {
+            }
         })
 
-        searchBox.setOnLongClickListener {
-            val intent = Intent(Intent.ACTION_VIEW, Uri.parse("https://www.google.com"))
-            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        search.setOnLongClickListener {
             try {
-                searchBox.context.startActivity(intent)
+                search.context.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse("https://www.google.com")).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
             } catch (e: Exception) {
-                Toast.makeText(searchBox.context, "No browser found!", Toast.LENGTH_SHORT).show()
+                Toast.makeText(search.context, "Browser not found!", Toast.LENGTH_SHORT).show()
             }
             true
         }
     }
 
-    fun filterAppsAndContacts(query: String) {
-        val newFilteredList = mutableListOf<ResolveInfo>()
-
-        if (query.isNotEmpty()) {
-            // Filter installed apps
-            newFilteredList.addAll(fullAppList.filter {
-                it.loadLabel(packageManager).toString().contains(query, ignoreCase = true)
-            })
-
-            // Group contacts by name
-            val groupedContacts = contactsList.filter {
-                it.contains(query, ignoreCase = true)
-            }.groupBy { it }
-
-            // Create contact options
-            groupedContacts.forEach { (contactName, contactList) ->
-                // Create WhatsApp contacts for each contact in the group
-                val filteredWhatsAppContacts = contactList.map { createWhatsAppContactOption(it) }
-
-                // Add WhatsApp contacts first
-                newFilteredList.addAll(filteredWhatsAppContacts)
-
-                // Add SMS and phone options for each contact
-                contactList.forEach { contact ->
-                    newFilteredList.add(createContactOption(contact))
-                    newFilteredList.add(createSmsOption(contact))
-                }
-            }
-
-            // Fallback if no results found
-            if (newFilteredList.isEmpty()) {
-                newFilteredList.add(createPlayStoreSearchOption(query))
-                newFilteredList.add(createGoogleMapsSearchOption(query))
-                newFilteredList.add(createYoutubeSearchOption(query))
-                newFilteredList.add(createBrowserSearchOption(query))
-            }
-        } else {
-            // If query is empty, show all apps sorted
-            newFilteredList.addAll(fullAppList.sortedBy { it.loadLabel(packageManager).toString().lowercase() })
-        }
-
-        // Update the actual list
-        appList.clear()
-        appList.addAll(newFilteredList)
-        adapter.notifyDataSetChanged() // Ensure UI updates
-    }
-
-    private fun createWhatsAppContactOption(contact: String): ResolveInfo {
-        return ResolveInfo().apply {
-            activityInfo = ActivityInfo().apply {
-                packageName = "whatsapp_contact"
-                name = contact  // Display contact name
+    fun updateAppLabels() {
+        appLabels.clear()
+        CoroutineScope(Dispatchers.IO).launch {
+            allApps.forEach { app ->
+                appLabels[app] = app.loadLabel(pm).toString().lowercase()
             }
         }
     }
 
-    private fun createGoogleMapsSearchOption(query: String): ResolveInfo {
-        return ResolveInfo().apply {
-            activityInfo = ActivityInfo().apply {
-                packageName = "maps_search"
-                name = query
-            }
-        }
-    }
+    private suspend fun filter(query: String) = withContext(Dispatchers.Default) {
+        val filtered = mutableListOf<ResolveInfo>()
+        if (query.isNotEmpty()) {
+            val lowerQuery = query.lowercase()
 
-    private fun createYoutubeSearchOption(query: String): ResolveInfo {
-        return ResolveInfo().apply {
-            activityInfo = ActivityInfo().apply {
-                packageName = "yt_search"
-                name = query
-            }
-        }
-    }
+            val validApps = allApps.filter { appLabels[it]?.contains(lowerQuery) == true } //Filter valid apps.
+            filtered.addAll(validApps)
 
-    private fun createFileSearchOption(query: String): ResolveInfo {
-        return ResolveInfo().apply {
-            activityInfo = ActivityInfo().apply {
-                packageName = "file_search"
-                name = query
+            contacts.filter { it.lowercase().contains(lowerQuery) }.groupBy { it }.forEach { (_, list) ->
+                list.map { createWhatsApp(it) }.let { filtered.addAll(it) }
+                list.forEach { filtered.add(createContact(it)); filtered.add(createSms(it)) }
             }
-        }
-    }
-
-    private fun createPlayStoreSearchOption(query: String): ResolveInfo {
-        return ResolveInfo().apply {
-            activityInfo = ActivityInfo().apply {
-                packageName = "play_store_search"
-                name = query
+            if (filtered.isEmpty()) {
+                filtered.add(createPlayStore(query)); filtered.add(createMaps(query)); filtered.add(createYoutube(query)); filtered.add(createBrowser(query))
             }
+        } else {
+            // Show only the app list when search is empty
+            filtered.addAll(allApps.sortedBy { appLabels[it] })
         }
-    }
 
-    private fun createBrowserSearchOption(query: String): ResolveInfo {
-        return ResolveInfo().apply {
-            activityInfo = ActivityInfo().apply {
-                packageName = "browser_search"
-                name = query
-
-            }
+        withContext(Dispatchers.Main) {
+            apps.clear()
+            apps.addAll(filtered)
+            adapter.notifyDataSetChanged()
         }
     }
 
-    private fun createSmsOption(contact: String): ResolveInfo {
-        return ResolveInfo().apply {
-            activityInfo = ActivityInfo().apply {
-                packageName = "sms_contact"
-                name = contact
+    fun removeInvalidApps() {
+        val iterator = allApps.iterator()
+        while (iterator.hasNext()) {
+            val app = iterator.next()
+            try {
+                pm.getApplicationLabel(app.activityInfo.applicationInfo)
+            } catch (e: Exception) {
+                iterator.remove()
             }
         }
+        updateAppLabels()
     }
 
-    private fun createContactOption(contact: String): ResolveInfo {
-        return ResolveInfo().apply {
-            activityInfo = ActivityInfo().apply {
-                packageName = "contact_search"
-                name = contact  // Display contact name or number
-            }
-        }
-    }
-}
+    private fun createWhatsApp(contact: String) = ResolveInfo().apply { activityInfo = ActivityInfo().apply { packageName = "whatsapp_contact"; name = contact } }
+    private fun createMaps(query: String) = ResolveInfo().apply { activityInfo = ActivityInfo().apply { packageName = "maps_search"; name = query } }
+    private fun createYoutube(query: String) = ResolveInfo().apply { activityInfo = ActivityInfo().apply { packageName = "yt_search"; name = query } }
+    private fun createPlayStore(query: String) = ResolveInfo().apply { activityInfo = ActivityInfo().apply { packageName = "play_store_search"; name = query } }
+    private fun createBrowser(query: String) = ResolveInfo().apply { activityInfo = ActivityInfo().apply { packageName = "browser_search"; name = query } }
+    private fun createSms(contact: String) = ResolveInfo().apply { activityInfo = ActivityInfo().apply { packageName = "sms_contact"; name = contact } }
+    private fun createContact(contact: String) = ResolveInfo().apply { activityInfo = ActivityInfo().apply { packageName = "contact_search"; name = contact } }
+}