Feature: Added Fuzzy Finding

Closes#: #150

Author: CreativeCodeCat

app/src/main/java/com/github/droidworksstudio/fuzzywuzzy/FuzzyFinder.kt

@@ -0,0 +1,66 @@
+package com.github.droidworksstudio.fuzzywuzzy
+
+import com.github.droidworksstudio.launcher.data.entities.AppInfo
+import java.text.Normalizer
+import java.util.*
+
+object FuzzyFinder {
+    fun scoreApp(app: AppInfo, searchChars: String, topScore: Int): Int {
+        val appChars = app.appName
+
+        val fuzzyScore = calculateFuzzyScore(
+            normalizeString(appChars),
+            normalizeString(searchChars)
+        )
+
+        return (fuzzyScore * topScore).toInt()
+    }
+
+    fun normalizeString(appLabel: String, searchChars: String): Boolean {
+        return (appLabel.contains(searchChars, true) or
+                Normalizer.normalize(appLabel, Normalizer.Form.NFD)
+                    .replace(Regex("\\p{InCombiningDiacriticalMarks}+"), "")
+                    .replace(Regex("[-_+,. ]"), "")
+                    .contains(searchChars, true))
+    }
+
+    private fun normalizeString(input: String): String {
+        // Remove diacritical marks and special characters, and convert to uppercase
+        return input
+            .uppercase(Locale.getDefault())
+            .replace(Regex("[\\p{InCombiningDiacriticalMarks}-_+,.]"), "")
+    }
+
+    private fun calculateFuzzyScore(s1: String, s2: String): Float {
+        val m = s1.length
+        val n = s2.length
+        var matchCount = 0
+        var s1Index = 0
+
+        // Iterate over each character in s2 and check if it exists in s1
+        for (c2 in s2) {
+            var found = false
+
+            // Start searching for c2 from the current s1Index
+            for (j in s1Index until m) {
+                if (s1[j] == c2) {
+                    found = true
+                    // Update s1Index to the next position for the next iteration
+                    s1Index = j + 1
+                    break
+                }
+            }
+
+            // If the current character in s2 is not found in s1, return a score of 0
+            if (!found) {
+                return 0f
+            }
+
+            // Increment the match count
+            matchCount++
+        }
+
+        // Calculate the score as the ratio of matched characters to the longer string length
+        return matchCount.toFloat() / maxOf(m, n)
+    }
+}

app/src/main/java/com/github/droidworksstudio/launcher/data/dao/AppInfoDAO.kt

@@ -43,8 +43,8 @@ interface AppInfoDAO {
     @Query("SELECT * FROM app WHERE is_lock = 1 ORDER BY app_order ASC")
     fun getLockAppsFlow(): Flow<List<AppInfo>>
 
-    @Query("SELECT * FROM app WHERE app_name LIKE :query COLLATE NOCASE AND is_hidden = 0")
-    fun searchApps(query: String?): Flow<List<AppInfo>>
+    @Query("SELECT * FROM app ORDER BY app_name COLLATE NOCASE ASC")
+    fun searchApps(): Flow<List<AppInfo>>
 
     @Update
     suspend fun updateAppInfo(appInfo: AppInfo)

app/src/main/java/com/github/droidworksstudio/launcher/helper/PreferenceHelper.kt

@@ -103,6 +103,14 @@ class PreferenceHelper @Inject constructor(@ApplicationContext context: Context)
         get() = prefs.getBoolean(Constants.AUTOMATIC_OPEN_APP, false)
         set(value) = prefs.edit().putBoolean(Constants.AUTOMATIC_OPEN_APP, value).apply()
 
+    var searchFromStart: Boolean
+        get() = prefs.getBoolean(Constants.SEARCH_FROM_START, true)
+        set(value) = prefs.edit().putBoolean(Constants.SEARCH_FROM_START, value).apply()
+
+    var filterStrength: Int
+        get() = prefs.getInt(Constants.FILTER_STRENGTH, 25)
+        set(value) = prefs.edit().putInt(Constants.FILTER_STRENGTH, value).apply()
+
     var homeAppAlignment: Int
         get() = prefs.getInt(Constants.HOME_APP_ALIGNMENT, Gravity.START)
         set(value) = prefs.edit().putInt(Constants.HOME_APP_ALIGNMENT, value).apply()

app/src/main/java/com/github/droidworksstudio/launcher/repository/AppInfoRepository.kt

@@ -53,8 +53,8 @@ class AppInfoRepository @Inject constructor(
         }
     }
 
-    fun searchNote(query: String?): Flow<List<AppInfo>> {
-        return appDao.searchApps(query)
+    fun searchNote(): Flow<List<AppInfo>> {
+        return appDao.searchApps()
     }
 
     suspend fun updateFavoriteAppInfo(appInfo: AppInfo) = withContext(Dispatchers.IO) {

app/src/main/java/com/github/droidworksstudio/launcher/ui/drawer/DrawFragment.kt

@@ -24,6 +24,7 @@ import com.github.droidworksstudio.common.searchCustomSearchEngine
 import com.github.droidworksstudio.common.searchOnPlayStore
 import com.github.droidworksstudio.common.showKeyboard
 import com.github.droidworksstudio.common.showLongToast
+import com.github.droidworksstudio.fuzzywuzzy.FuzzyFinder
 import com.github.droidworksstudio.launcher.R
 import com.github.droidworksstudio.launcher.adapter.drawer.DrawAdapter
 import com.github.droidworksstudio.launcher.data.entities.AppInfo
@@ -35,6 +36,7 @@ import com.github.droidworksstudio.launcher.listener.OnItemClickedListener
 import com.github.droidworksstudio.launcher.listener.OnSwipeTouchListener
 import com.github.droidworksstudio.launcher.listener.ScrollEventListener
 import com.github.droidworksstudio.launcher.ui.bottomsheetdialog.AppInfoBottomSheetFragment
+import com.github.droidworksstudio.launcher.utils.Constants
 import com.github.droidworksstudio.launcher.viewmodel.AppViewModel
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.launch
@@ -194,7 +196,7 @@ class DrawFragment : Fragment(),
             // Use repeatOnLifecycle to manage the lifecycle state
             repeatOnLifecycle(Lifecycle.State.CREATED) {
                 val trimmedQuery = searchQuery.trim()
-                viewModel.searchAppInfo(trimmedQuery).collect { searchResults ->
+                viewModel.searchAppInfo().collect { searchResults ->
                     val numberOfItemsLeft = searchResults.size
                     val appResults = searchResults.firstOrNull()
                     if (numberOfItemsLeft == 0 && !requireContext().searchOnPlayStore(trimmedQuery)) {
@@ -211,34 +213,70 @@ class DrawFragment : Fragment(),
     }
 
     private fun searchApp(query: String) {
-        val searchQuery = "%$query%"
-
         // Launch a coroutine tied to the lifecycle of the view
         viewLifecycleOwner.lifecycleScope.launch {
             // Repeat the block when the lifecycle is at least CREATED
             repeatOnLifecycle(Lifecycle.State.CREATED) {
+                val trimmedQuery = query.trim()
+
                 // Collect search results from the ViewModel
-                viewModel.searchAppInfo(searchQuery).collect { searchResults ->
-                    val numberOfItemsLeft = searchResults.size
-                    val appResults = searchResults.firstOrNull()
+                viewModel.searchAppInfo().collect { searchResults ->
+                    // Filter and score results using FuzzyFinder
+                    val filteredResults = searchResults
+                        .map { appInfo ->
+                            val score = FuzzyFinder.scoreApp(appInfo, trimmedQuery, Constants.FILTER_STRENGTH_MAX)
+                            appInfo to score // Pairing app info with its score
+                        }
+                        .filter { it.second > 25 } // Only keep results with a positive score
+                        .sortedByDescending { it.second } // Sort results by score, descending
+
+                    // Applying additional filtering based on preferences
+                    val scoredApps = filteredResults.toMap()
+
+                    val finalResults = if (preferenceHelper.filterStrength >= 1) {
+                        // Filtering based on score strength
+                        if (preferenceHelper.searchFromStart) {
+                            // Filter apps that start with the search query and score higher than the filter strength
+                            scoredApps.filter { (app, _) ->
+                                app.appName.startsWith(trimmedQuery, ignoreCase = true)
+                            }
+                                .filter { (_, score) -> score > preferenceHelper.filterStrength }
+                                .map { it.key }
+                                .toMutableList()
+                        } else {
+                            // Filter based on score strength alone
+                            scoredApps.filterValues { it > preferenceHelper.filterStrength }
+                                .keys
+                                .toMutableList()
+                        }
+                    } else {
+                        // If filter strength is less than 1, normalize app names for both cases
+                        searchResults.filter { app ->
+                            FuzzyFinder.normalizeString(app.appName, trimmedQuery)
+                        }.toMutableList()
+                    }
+
+
+                    val numberOfItemsLeft = finalResults.size
+                    val appResults = finalResults.firstOrNull()
+
                     when (numberOfItemsLeft) {
                         1 -> {
                             appResults?.let { appInfo ->
                                 if (preferenceHelper.automaticOpenApp) observeBioAuthCheck(appInfo)
                             }
-                            drawAdapter.submitList(searchResults)
+                            drawAdapter.submitList(finalResults)
                         }
 
                         else -> {
-                            drawAdapter.submitList(searchResults)
+                            drawAdapter.submitList(finalResults)
                         }
                     }
                 }
             }
         }
     }
 
-
     private fun showSelectedApp(appInfo: AppInfo) {
         binding.searchViewText.setQuery("", false)