Update/enhance performance

app/build.gradle.kts

@@ -130,7 +130,8 @@ dependencies {
 
     androidTestImplementation(composeBom)
     testImplementation(libs.junit)
-    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.11.0")
+    testImplementation(libs.kotlinx.coroutines.test)
+    testImplementation(libs.json)
     debugImplementation(libs.androidx.compose.ui.tooling)
 
 }

app/src/main/AndroidManifest.xml

@@ -5,6 +5,14 @@
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.VIBRATE" />
+
+    <queries>
+        <intent>
+            <action android:name="android.speech.RecognitionService" />
+        </intent>
+    </queries>
 
     <application
         android:name=".MainApp"

app/src/main/java/com/frogobox/appkeyboard/model/KeyboardFeatureType.kt

@@ -24,7 +24,12 @@ enum class KeyboardFeatureType(val id: String, val text: String, val icon: Int)
     CLIPBOARD("menu_clipboard", "Clipboard", R.drawable.ic_menu_clipboard),
     TEXT_EDIT("menu_text_edit", "Text Editing", R.drawable.ic_menu_text_edit),
     SUGGESTION("menu_suggestion", "Word Suggestion", R.drawable.ic_menu_suggestion),
+    NUMBER_ROW("menu_number_row", "Number Row", R.drawable.ic_menu_number_row),
+    ONE_HANDED("menu_one_handed", "One-Handed", R.drawable.ic_menu_one_handed),
     CHANGE_KEYBOARD("menu_change_keyboard", "Change Keyboard", R.drawable.ic_menu_keyboard),
+    AI_ASSISTANT("menu_ai_assistant", "AI Assistant", R.drawable.ic_menu_ai_assistant),
+    VOICE_TYPING("menu_voice_typing", "Voice Typing", R.drawable.ic_menu_voice_typing),
+    GESTURE_SWIPE("menu_gesture_swipe", "Gesture & Swipe", R.drawable.ic_menu_gesture_swipe),
     SETTING("menu_setting", "Setting", R.drawable.ic_menu_setting);
 
     fun mapToModel(): KeyboardFeatureModel {

app/src/main/java/com/frogobox/appkeyboard/model/KeyboardThemeType.kt

@@ -35,6 +35,7 @@ enum class KeyboardThemeType(
     CYAN("Nordic Cyan", "Fresh & Clean", ThemeType.COLOR, R.color.color_bg_keyboard_cyan, isDark = true),
     PINK("Sakura Pink", "Aesthetic Pastel", ThemeType.COLOR, R.color.color_bg_keyboard_pink, isDark = true),
     YELLOW("Amber Gold", "Golden Accent", ThemeType.COLOR, R.color.color_bg_keyboard_yellow, isDark = false),
+    HIGH_CONTRAST("High Contrast (WCAG AAA)", "Ultra OLED Black & Canary Yellow", ThemeType.COLOR, R.color.color_bg_keyboard_high_contrast, isDark = true),
     IMAGE_BG_DARK("Wallpaper", "Sample Artwork", ThemeType.IMAGE, R.drawable.ic_wallpaper_dummy, isDark = true);
 
     fun mapToModel(): KeyboardThemeModel {

app/src/main/java/com/frogobox/appkeyboard/services/KeyboardUtil.kt

@@ -25,9 +25,31 @@ class KeyboardUtil @Inject constructor(
         const val KEYBOARD_SUGGESTION_ENABLED = "KEYBOARD_SUGGESTION_ENABLED"
         const val KEY_ALWAYS_SHOW_FEATURE = "KEY_ALWAYS_SHOW_FEATURE"
         const val KEY_FEATURE_ORDER = "KEY_FEATURE_ORDER"
+        const val KEY_NUMBER_ROW_ENABLED = "KEY_NUMBER_ROW_ENABLED"
+        const val KEY_ONE_HANDED_MODE = "KEY_ONE_HANDED_MODE"
+        const val KEY_SYMBOL_HINTS_ENABLED = "KEY_SYMBOL_HINTS_ENABLED"
+        const val KEY_DYNAMIC_THEME_ENABLED = "KEY_DYNAMIC_THEME_ENABLED"
+        const val KEY_SPLIT_MODE_ENABLED = "KEY_SPLIT_MODE_ENABLED"
+        const val KEY_HAPTIC_INTENSITY = "KEY_HAPTIC_INTENSITY"
+        const val KEY_SMART_PUNCTUATION_ENABLED = "KEY_SMART_PUNCTUATION_ENABLED"
+        const val KEY_ACTIVE_LANGUAGE = "KEY_ACTIVE_LANGUAGE"
+        const val KEY_HEIGHT_SCALE = "KEY_HEIGHT_SCALE"
+        const val KEY_BOTTOM_CHIN_OFFSET = "KEY_BOTTOM_CHIN_OFFSET"
+        const val KEY_FLOATING_MODE_ENABLED = "KEY_FLOATING_MODE_ENABLED"
+        const val KEY_HAPTIC_DURATION_MS = "KEY_HAPTIC_DURATION_MS"
+        const val KEY_SOUND_VOLUME_PERCENT = "KEY_SOUND_VOLUME_PERCENT"
+        const val KEY_GESTURE_TYPING_ENABLED = "KEY_GESTURE_TYPING_ENABLED"
+        const val KEY_GESTURE_SWIPE_SHORTCUTS_ENABLED = "KEY_GESTURE_SWIPE_SHORTCUTS_ENABLED"
+        const val KEY_USER_DICTIONARY_LEARNING_ENABLED = "KEY_USER_DICTIONARY_LEARNING_ENABLED"
+        const val KEY_SMART_CALCULATOR_ENABLED = "KEY_SMART_CALCULATOR_ENABLED"
 
         val DEFAULT_FEATURE_TYPES = listOf(
             KeyboardFeatureType.SUGGESTION,
+            KeyboardFeatureType.NUMBER_ROW,
+            KeyboardFeatureType.ONE_HANDED,
+            KeyboardFeatureType.AI_ASSISTANT,
+            KeyboardFeatureType.VOICE_TYPING,
+            KeyboardFeatureType.GESTURE_SWIPE,
             KeyboardFeatureType.AUTO_TEXT,
             KeyboardFeatureType.PRODUCT_REMOTE,
             KeyboardFeatureType.CLIPBOARD,
@@ -45,6 +67,142 @@ class KeyboardUtil @Inject constructor(
         return pref.getPrefBoolean(key, true)
     }
 
+    fun isNumberRowEnabled(): Boolean {
+        return pref.getPrefBoolean(KEY_NUMBER_ROW_ENABLED, false)
+    }
+
+    fun setNumberRowEnabled(enabled: Boolean) {
+        pref.savePrefBoolean(KEY_NUMBER_ROW_ENABLED, enabled)
+    }
+
+    fun getOneHandedMode(): String {
+        return pref.getPrefString(KEY_ONE_HANDED_MODE, "OFF")
+    }
+
+    fun setOneHandedMode(mode: String) {
+        pref.savePrefString(KEY_ONE_HANDED_MODE, mode)
+    }
+
+    fun isSymbolHintsEnabled(): Boolean {
+        return pref.getPrefBoolean(KEY_SYMBOL_HINTS_ENABLED, true)
+    }
+
+    fun setSymbolHintsEnabled(enabled: Boolean) {
+        pref.savePrefBoolean(KEY_SYMBOL_HINTS_ENABLED, enabled)
+    }
+
+    fun isDynamicThemeEnabled(): Boolean {
+        return pref.getPrefBoolean(KEY_DYNAMIC_THEME_ENABLED, false)
+    }
+
+    fun setDynamicThemeEnabled(enabled: Boolean) {
+        pref.savePrefBoolean(KEY_DYNAMIC_THEME_ENABLED, enabled)
+    }
+
+    fun isSplitModeEnabled(): Boolean {
+        return pref.getPrefBoolean(KEY_SPLIT_MODE_ENABLED, false)
+    }
+
+    fun setSplitModeEnabled(enabled: Boolean) {
+        pref.savePrefBoolean(KEY_SPLIT_MODE_ENABLED, enabled)
+    }
+
+    fun getHapticIntensity(): String {
+        return pref.getPrefString(KEY_HAPTIC_INTENSITY, "MEDIUM")
+    }
+
+    fun setHapticIntensity(intensity: String) {
+        pref.savePrefString(KEY_HAPTIC_INTENSITY, intensity)
+    }
+
+    fun isSmartPunctuationEnabled(): Boolean {
+        return pref.getPrefBoolean(KEY_SMART_PUNCTUATION_ENABLED, true)
+    }
+
+    fun setSmartPunctuationEnabled(enabled: Boolean) {
+        pref.savePrefBoolean(KEY_SMART_PUNCTUATION_ENABLED, enabled)
+    }
+
+    fun getActiveLanguage(): String {
+        return pref.getPrefString(KEY_ACTIVE_LANGUAGE, "ID")
+    }
+
+    fun setActiveLanguage(lang: String) {
+        pref.savePrefString(KEY_ACTIVE_LANGUAGE, lang)
+    }
+
+    fun getHeightScale(): String {
+        return pref.getPrefString(KEY_HEIGHT_SCALE, "NORMAL")
+    }
+
+    fun setHeightScale(scale: String) {
+        pref.savePrefString(KEY_HEIGHT_SCALE, scale)
+    }
+
+    fun getBottomChinOffset(): String {
+        return pref.getPrefString(KEY_BOTTOM_CHIN_OFFSET, "NONE")
+    }
+
+    fun setBottomChinOffset(offset: String) {
+        pref.savePrefString(KEY_BOTTOM_CHIN_OFFSET, offset)
+    }
+
+    fun isFloatingModeEnabled(): Boolean {
+        return pref.getPrefBoolean(KEY_FLOATING_MODE_ENABLED, false)
+    }
+
+    fun setFloatingModeEnabled(enabled: Boolean) {
+        pref.savePrefBoolean(KEY_FLOATING_MODE_ENABLED, enabled)
+    }
+
+    fun getHapticDurationMs(): Long {
+        return pref.getPrefString(KEY_HAPTIC_DURATION_MS, "20").toLongOrNull() ?: 20L
+    }
+
+    fun setHapticDurationMs(durationMs: Long) {
+        pref.savePrefString(KEY_HAPTIC_DURATION_MS, durationMs.toString())
+    }
+
+    fun getSoundVolumePercent(): Int {
+        return pref.getPrefString(KEY_SOUND_VOLUME_PERCENT, "100").toIntOrNull() ?: 100
+    }
+
+    fun setSoundVolumePercent(volume: Int) {
+        pref.savePrefString(KEY_SOUND_VOLUME_PERCENT, volume.toString())
+    }
+
+    fun isGestureTypingEnabled(): Boolean {
+        return pref.getPrefBoolean(KEY_GESTURE_TYPING_ENABLED, true)
+    }
+
+    fun setGestureTypingEnabled(enabled: Boolean) {
+        pref.savePrefBoolean(KEY_GESTURE_TYPING_ENABLED, enabled)
+    }
+
+    fun isGestureSwipeShortcutsEnabled(): Boolean {
+        return pref.getPrefBoolean(KEY_GESTURE_SWIPE_SHORTCUTS_ENABLED, true)
+    }
+
+    fun setGestureSwipeShortcutsEnabled(enabled: Boolean) {
+        pref.savePrefBoolean(KEY_GESTURE_SWIPE_SHORTCUTS_ENABLED, enabled)
+    }
+
+    fun isUserDictionaryLearningEnabled(): Boolean {
+        return pref.getPrefBoolean(KEY_USER_DICTIONARY_LEARNING_ENABLED, true)
+    }
+
+    fun setUserDictionaryLearningEnabled(enabled: Boolean) {
+        pref.savePrefBoolean(KEY_USER_DICTIONARY_LEARNING_ENABLED, enabled)
+    }
+
+    fun isSmartCalculatorEnabled(): Boolean {
+        return pref.getPrefBoolean(KEY_SMART_CALCULATOR_ENABLED, true)
+    }
+
+    fun setSmartCalculatorEnabled(enabled: Boolean) {
+        pref.savePrefBoolean(KEY_SMART_CALCULATOR_ENABLED, enabled)
+    }
+
     fun isSuggestionEnabled(): Boolean {
         return getStateToggle(KeyboardFeatureType.SUGGESTION.id)
     }

app/src/main/java/com/frogobox/appkeyboard/suggestion/WordSuggestionEngine.kt

@@ -182,6 +182,13 @@ class WordSuggestionEngine @Inject constructor() {
         }
     }
 
+    /**
+     * Returns full list of vocabulary words for gesture typing and prediction engines.
+     */
+    fun getAllWords(): List<String> {
+        return dictionaryList.toList()
+    }
+
     /**
      * Core suggestion generation returning the 3 required sections:
      * - Section 1: User's verbatim word