Merge branch 'main' into weblate-simple-mobile-tools-simple-keyboard

Author: tibbi

app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt

@@ -44,6 +44,7 @@ class SettingsActivity : SimpleActivity() {
         setupKeyboardLanguage()
         setupKeyboardHeightMultiplier()
         setupShowClipboardContent()
+        setupSentencesCapitalization()
         setupShowNumbersRow()
 
         updateTextColors(settings_nested_scrollview)
@@ -160,6 +161,15 @@ class SettingsActivity : SimpleActivity() {
             config.showClipboardContent = settings_show_clipboard_content.isChecked
         }
     }
+
+    private fun setupSentencesCapitalization() {
+        settings_start_sentences_capitalized.isChecked = config.enableSentencesCapitalization
+        settings_start_sentences_capitalized_holder.setOnClickListener {
+            settings_start_sentences_capitalized.toggle()
+            config.enableSentencesCapitalization = settings_start_sentences_capitalized.isChecked
+        }
+    }
+
     private fun setupShowNumbersRow() {
         settings_show_numbers_row.isChecked = config.showNumbersRow
         settings_show_numbers_row_holder.setOnClickListener {

app/src/main/kotlin/com/simplemobiletools/keyboard/helpers/Config.kt

@@ -17,6 +17,10 @@ class Config(context: Context) : BaseConfig(context) {
         get() = prefs.getBoolean(SHOW_POPUP_ON_KEYPRESS, true)
         set(showPopupOnKeypress) = prefs.edit().putBoolean(SHOW_POPUP_ON_KEYPRESS, showPopupOnKeypress).apply()
 
+    var enableSentencesCapitalization: Boolean
+        get() = prefs.getBoolean(SENTENCES_CAPITALIZATION, true)
+        set(enableCapitalization) = prefs.edit().putBoolean(SENTENCES_CAPITALIZATION, enableCapitalization).apply()
+
     var showKeyBorders: Boolean
         get() = prefs.getBoolean(SHOW_KEY_BORDERS, false)
         set(showKeyBorders) = prefs.edit().putBoolean(SHOW_KEY_BORDERS, showKeyBorders).apply()

app/src/main/kotlin/com/simplemobiletools/keyboard/helpers/Constants.kt

@@ -1,8 +1,61 @@
 package com.simplemobiletools.keyboard.helpers
 
-const val SHIFT_OFF = 0
-const val SHIFT_ON_ONE_CHAR = 1
-const val SHIFT_ON_PERMANENT = 2
+import android.content.Context
+import com.simplemobiletools.keyboard.extensions.config
+import com.simplemobiletools.keyboard.helpers.MyKeyboard.Companion.KEYCODE_SPACE
+
+enum class ShiftState {
+    OFF,
+    ON_ONE_CHAR,
+    ON_PERMANENT;
+
+    companion object {
+        private val endOfSentenceChars: List<Char> = listOf('.', '?', '!')
+
+        fun getDefaultShiftState(context: Context): ShiftState {
+            return when (context.config.enableSentencesCapitalization) {
+                true -> ON_ONE_CHAR
+                else -> OFF
+            }
+        }
+
+        fun getShiftStateForText(context: Context, newText: String?): ShiftState {
+            if (!context.config.enableSentencesCapitalization) {
+                return OFF
+            }
+
+            val twoLastSymbols = newText?.takeLast(2)
+            return when {
+                shouldCapitalizeSentence(previousChar = twoLastSymbols?.getOrNull(0), currentChar = twoLastSymbols?.getOrNull(1)) -> {
+                    ON_ONE_CHAR
+                }
+                else -> {
+                    OFF
+                }
+            }
+        }
+
+        fun getCapitalizationOnDelete(context: Context, text: CharSequence?): ShiftState {
+            if (!context.config.enableSentencesCapitalization) {
+                return OFF
+            }
+
+            return if (text.isNullOrEmpty() || shouldCapitalizeSentence(currentChar = text.last(), previousChar = text.getOrNull(text.lastIndex - 1))) {
+                ON_ONE_CHAR
+            } else {
+                OFF
+            }
+        }
+
+        private fun shouldCapitalizeSentence(previousChar: Char?, currentChar: Char?): Boolean {
+            if (previousChar == null || currentChar == null) {
+                return false
+            }
+
+            return currentChar.code == KEYCODE_SPACE && endOfSentenceChars.contains(previousChar)
+        }
+    }
+}
 
 // limit the count of alternative characters that show up at long pressing a key
 const val MAX_KEYS_PER_MINI_ROW = 9
@@ -11,6 +64,7 @@ const val MAX_KEYS_PER_MINI_ROW = 9
 const val VIBRATE_ON_KEYPRESS = "vibrate_on_keypress"
 const val SHOW_POPUP_ON_KEYPRESS = "show_popup_on_keypress"
 const val SHOW_KEY_BORDERS = "show_key_borders"
+const val SENTENCES_CAPITALIZATION = "sentences_capitalization"
 const val LAST_EXPORTED_CLIPS_FOLDER = "last_exported_clips_folder"
 const val KEYBOARD_LANGUAGE = "keyboard_language"
 const val HEIGHT_MULTIPLIER = "height_multiplier"

app/src/main/kotlin/com/simplemobiletools/keyboard/helpers/MyKeyboard.kt

@@ -34,7 +34,7 @@ class MyKeyboard {
     var mKeyboardHeightMultiplier: Float = 1F
 
     /** Is the keyboard in the shifted state  */
-    var mShiftState = SHIFT_OFF
+    var mShiftState = ShiftState.OFF
 
     /** Total height of the keyboard, including the padding and keys  */
     var mHeight = 0
@@ -258,13 +258,14 @@ class MyKeyboard {
      * @param enterKeyType determines what icon should we show on Enter key
      */
     @JvmOverloads
-    constructor(context: Context, @XmlRes xmlLayoutResId: Int, enterKeyType: Int) {
+    constructor(context: Context, @XmlRes xmlLayoutResId: Int, enterKeyType: Int, shiftState: ShiftState = ShiftState.OFF) {
         mDisplayWidth = context.resources.displayMetrics.widthPixels
         mDefaultHorizontalGap = 0
         mDefaultWidth = mDisplayWidth / 10
         mDefaultHeight = mDefaultWidth
         mKeyboardHeightMultiplier = getKeyboardHeightMultiplier(context.config.keyboardHeightMultiplier)
         mKeys = ArrayList()
+        mShiftState = shiftState
         mEnterKeyType = enterKeyType
         loadKeyboard(context, context.resources.getXml(xmlLayoutResId))
     }
@@ -315,12 +316,11 @@ class MyKeyboard {
         mRows.add(row)
     }
 
-    fun setShifted(shiftState: Int): Boolean {
+    fun setShifted(shiftState: ShiftState): Boolean {
         if (this.mShiftState != shiftState) {
             this.mShiftState = shiftState
             return true
         }
-
         return false
     }
 

app/src/main/kotlin/com/simplemobiletools/keyboard/services/SimpleKeyboardIME.kt

@@ -20,7 +20,8 @@ import com.simplemobiletools.keyboard.R
 import com.simplemobiletools.keyboard.extensions.config
 import com.simplemobiletools.keyboard.helpers.*
 import com.simplemobiletools.keyboard.views.MyKeyboardView
-import kotlinx.android.synthetic.main.keyboard_view_keyboard.view.*
+import kotlinx.android.synthetic.main.keyboard_view_keyboard.view.keyboard_holder
+import kotlinx.android.synthetic.main.keyboard_view_keyboard.view.keyboard_view
 
 // based on https://www.androidauthority.com/lets-build-custom-keyboard-android-832362/
 class SimpleKeyboardIME : InputMethodService(), MyKeyboardView.OnKeyboardActionListener, SharedPreferences.OnSharedPreferenceChangeListener {
@@ -41,7 +42,6 @@ class SimpleKeyboardIME : InputMethodService(), MyKeyboardView.OnKeyboardActionL
 
     override fun onInitializeInterface() {
         super.onInitializeInterface()
-        keyboard = MyKeyboard(this, getKeyboardLayoutXML(), enterKeyType)
         getSharedPrefs().registerOnSharedPreferenceChangeListener(this)
     }
 
@@ -65,8 +65,7 @@ class SimpleKeyboardIME : InputMethodService(), MyKeyboardView.OnKeyboardActionL
         super.onStartInput(attribute, restarting)
         inputTypeClass = attribute!!.inputType and TYPE_MASK_CLASS
         enterKeyType = attribute.imeOptions and (IME_MASK_ACTION or IME_FLAG_NO_ENTER_ACTION)
-
-        keyboard = getKeyBoard()
+        keyboard = createNewKeyboard()
         keyboardView?.setKeyboard(keyboard!!)
         keyboardView?.setEditorInfo(attribute)
         updateShiftKeyState()
@@ -75,9 +74,9 @@ class SimpleKeyboardIME : InputMethodService(), MyKeyboardView.OnKeyboardActionL
     private fun updateShiftKeyState() {
         if (keyboardMode == KEYBOARD_LETTERS) {
             val editorInfo = currentInputEditorInfo
-            if (editorInfo != null && editorInfo.inputType != InputType.TYPE_NULL && keyboard?.mShiftState != SHIFT_ON_PERMANENT) {
+            if (editorInfo != null && editorInfo.inputType != InputType.TYPE_NULL && keyboard?.mShiftState != ShiftState.ON_PERMANENT) {
                 if (currentInputConnection.getCursorCapsMode(editorInfo.inputType) != 0) {
-                    keyboard?.setShifted(SHIFT_ON_ONE_CHAR)
+                    keyboard?.setShifted(ShiftState.ON_ONE_CHAR)
                     keyboardView?.invalidateAllKeys()
                 }
             }
@@ -96,8 +95,10 @@ class SimpleKeyboardIME : InputMethodService(), MyKeyboardView.OnKeyboardActionL
 
         when (code) {
             MyKeyboard.KEYCODE_DELETE -> {
-                if (keyboard!!.mShiftState == SHIFT_ON_ONE_CHAR) {
-                    keyboard!!.mShiftState = SHIFT_OFF
+
+                if (keyboard!!.mShiftState != ShiftState.ON_PERMANENT) {
+                    val extractedText = inputConnection.getTextBeforeCursor(3, 0)?.dropLast(1)
+                    keyboard!!.setShifted(ShiftState.getCapitalizationOnDelete(context = this, text = extractedText))
                 }
 
                 val selectedText = inputConnection.getSelectedText(0)
@@ -109,13 +110,14 @@ class SimpleKeyboardIME : InputMethodService(), MyKeyboardView.OnKeyboardActionL
                 }
                 keyboardView!!.invalidateAllKeys()
             }
+
             MyKeyboard.KEYCODE_SHIFT -> {
                 if (keyboardMode == KEYBOARD_LETTERS) {
                     when {
-                        keyboard!!.mShiftState == SHIFT_ON_PERMANENT -> keyboard!!.mShiftState = SHIFT_OFF
-                        System.currentTimeMillis() - lastShiftPressTS < SHIFT_PERM_TOGGLE_SPEED -> keyboard!!.mShiftState = SHIFT_ON_PERMANENT
-                        keyboard!!.mShiftState == SHIFT_ON_ONE_CHAR -> keyboard!!.mShiftState = SHIFT_OFF
-                        keyboard!!.mShiftState == SHIFT_OFF -> keyboard!!.mShiftState = SHIFT_ON_ONE_CHAR
+                        keyboard!!.mShiftState == ShiftState.ON_PERMANENT -> keyboard!!.mShiftState = ShiftState.OFF
+                        System.currentTimeMillis() - lastShiftPressTS < SHIFT_PERM_TOGGLE_SPEED -> keyboard!!.mShiftState = ShiftState.ON_PERMANENT
+                        keyboard!!.mShiftState == ShiftState.ON_ONE_CHAR -> keyboard!!.mShiftState = ShiftState.OFF
+                        keyboard!!.mShiftState == ShiftState.OFF -> keyboard!!.mShiftState = ShiftState.ON_ONE_CHAR
                     }
 
                     lastShiftPressTS = System.currentTimeMillis()
@@ -132,15 +134,22 @@ class SimpleKeyboardIME : InputMethodService(), MyKeyboardView.OnKeyboardActionL
                 }
                 keyboardView!!.invalidateAllKeys()
             }
+
             MyKeyboard.KEYCODE_ENTER -> {
                 val imeOptionsActionId = getImeOptionsActionId()
                 if (imeOptionsActionId != IME_ACTION_NONE) {
                     inputConnection.performEditorAction(imeOptionsActionId)
                 } else {
                     inputConnection.sendKeyEvent(KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENTER))
                     inputConnection.sendKeyEvent(KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_ENTER))
+
+                    if (config.enableSentencesCapitalization) {
+                        keyboard!!.setShifted(ShiftState.ON_ONE_CHAR)
+                        keyboardView!!.invalidateAllKeys()
+                    }
                 }
             }
+
             MyKeyboard.KEYCODE_MODE_CHANGE -> {
                 val keyboardXml = if (keyboardMode == KEYBOARD_LETTERS) {
                     keyboardMode = KEYBOARD_SYMBOLS
@@ -152,48 +161,58 @@ class SimpleKeyboardIME : InputMethodService(), MyKeyboardView.OnKeyboardActionL
                 keyboard = MyKeyboard(this, keyboardXml, enterKeyType)
                 keyboardView!!.setKeyboard(keyboard!!)
             }
+
             MyKeyboard.KEYCODE_EMOJI -> {
                 keyboardView?.openEmojiPalette()
             }
+
             else -> {
                 var codeChar = code.toChar()
-                if (Character.isLetter(codeChar) && keyboard!!.mShiftState > SHIFT_OFF) {
+                val originalText = inputConnection.getExtractedText(ExtractedTextRequest(), 0)?.text ?: return
+
+                if (Character.isLetter(codeChar) && keyboard!!.mShiftState > ShiftState.OFF) {
                     codeChar = Character.toUpperCase(codeChar)
                 }
 
                 // If the keyboard is set to symbols and the user presses space, we usually should switch back to the letters keyboard.
                 // However, avoid doing that in cases when the EditText for example requires numbers as the input.
                 // We can detect that by the text not changing on pressing Space.
-                if (keyboardMode != KEYBOARD_LETTERS && keyboardMode != KEYBOARD_PHONE && code == MyKeyboard.KEYCODE_SPACE) {
-                    val originalText = inputConnection.getExtractedText(ExtractedTextRequest(), 0)?.text ?: return
+                if (keyboardMode != KEYBOARD_LETTERS && code == MyKeyboard.KEYCODE_SPACE) {
                     inputConnection.commitText(codeChar.toString(), 1)
                     val newText = inputConnection.getExtractedText(ExtractedTextRequest(), 0)?.text
-                    switchToLetters = originalText != newText
+                    if (originalText != newText) {
+                        switchToLetters = true
+                    }
                 } else {
                     inputConnection.commitText(codeChar.toString(), 1)
                 }
 
-                if (keyboard!!.mShiftState == SHIFT_ON_ONE_CHAR && keyboardMode == KEYBOARD_LETTERS) {
-                    keyboard!!.mShiftState = SHIFT_OFF
+                if (keyboardMode == KEYBOARD_LETTERS && keyboard!!.mShiftState != ShiftState.ON_PERMANENT) {
+                    keyboard!!.setShifted(ShiftState.getShiftStateForText(this, newText = "$originalText$codeChar"))
                     keyboardView!!.invalidateAllKeys()
                 }
+
             }
         }
 
-        if (code != MyKeyboard.KEYCODE_SHIFT) {
+        if (code != MyKeyboard.KEYCODE_SHIFT && config.enableSentencesCapitalization) {
             updateShiftKeyState()
         }
     }
 
     override fun onActionUp() {
         if (switchToLetters) {
+            // TODO: Change keyboardMode to enum class
             keyboardMode = KEYBOARD_LETTERS
-            keyboard = MyKeyboard(this, getKeyboardLayoutXML(), enterKeyType)
+            val text = currentInputConnection?.getExtractedText(ExtractedTextRequest(), 0)?.text
+            val newShiftState = ShiftState.getShiftStateForText(this, text?.toString().orEmpty())
+
+            keyboard = MyKeyboard(this, getKeyboardLayoutXML(), enterKeyType, shiftState = newShiftState)
 
             val editorInfo = currentInputEditorInfo
-            if (editorInfo != null && editorInfo.inputType != InputType.TYPE_NULL && keyboard?.mShiftState != SHIFT_ON_PERMANENT) {
+            if (editorInfo != null && editorInfo.inputType != InputType.TYPE_NULL && keyboard?.mShiftState != ShiftState.ON_PERMANENT) {
                 if (currentInputConnection.getCursorCapsMode(editorInfo.inputType) != 0) {
-                    keyboard?.setShifted(SHIFT_ON_ONE_CHAR)
+                    keyboard?.setShifted(ShiftState.ON_ONE_CHAR)
                 }
             }
 
@@ -215,32 +234,37 @@ class SimpleKeyboardIME : InputMethodService(), MyKeyboardView.OnKeyboardActionL
     }
 
     override fun reloadKeyboard() {
-        val keyboard = getKeyBoard()
+        val keyboard = createNewKeyboard()
         this.keyboard = keyboard
         keyboardView?.setKeyboard(keyboard)
     }
 
-    private fun getKeyBoard(): MyKeyboard {
+    private fun createNewKeyboard(): MyKeyboard {
         val keyboardXml = when (inputTypeClass) {
             TYPE_CLASS_NUMBER -> {
                 keyboardMode = KEYBOARD_NUMBERS
                 R.xml.keys_numbers
             }
+
             TYPE_CLASS_PHONE -> {
                 keyboardMode = KEYBOARD_PHONE
                 R.xml.keys_phone
             }
+
             TYPE_CLASS_DATETIME -> {
                 keyboardMode = KEYBOARD_SYMBOLS
                 R.xml.keys_symbols
             }
+
             else -> {
                 keyboardMode = KEYBOARD_LETTERS
                 getKeyboardLayoutXML()
             }
         }
 
-        return MyKeyboard(this, keyboardXml, enterKeyType)
+        return MyKeyboard(
+            context = this, xmlLayoutResId = keyboardXml, enterKeyType = enterKeyType, shiftState = ShiftState.getDefaultShiftState(this)
+        )
     }
 
     override fun onUpdateSelection(oldSelStart: Int, oldSelEnd: Int, newSelStart: Int, newSelEnd: Int, candidatesStart: Int, candidatesEnd: Int) {

app/src/main/kotlin/com/simplemobiletools/keyboard/views/MyKeyboardView.kt

@@ -455,7 +455,7 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut
      * @param shifted whether or not to enable the state of the shift key
      * @return true if the shift key state changed, false if there was no change
      */
-    private fun setShifted(shiftState: Int) {
+    private fun setShifted(shiftState: ShiftState) {
         if (mKeyboard?.setShifted(shiftState) == true) {
             invalidateAllKeys()
         }
@@ -466,7 +466,7 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut
      * @return true if the shift is in a pressed state, false otherwise
      */
     private fun isShifted(): Boolean {
-        return (mKeyboard?.mShiftState ?: SHIFT_OFF) > SHIFT_OFF
+        return (mKeyboard?.mShiftState ?: ShiftState.OFF) > ShiftState.OFF
     }
 
     private fun setPopupOffset(x: Int, y: Int) {
@@ -479,7 +479,7 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut
 
     private fun adjustCase(label: CharSequence): CharSequence? {
         var newLabel: CharSequence? = label
-        if (newLabel != null && newLabel.isNotEmpty() && mKeyboard!!.mShiftState > SHIFT_OFF && newLabel.length < 3 && Character.isLowerCase(newLabel[0])) {
+        if (newLabel != null && newLabel.isNotEmpty() && mKeyboard!!.mShiftState != ShiftState.OFF && newLabel.length < 3 && Character.isLowerCase(newLabel[0])) {
             newLabel = newLabel.toString().uppercase(Locale.getDefault())
         }
         return newLabel
@@ -604,8 +604,8 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut
             } else if (key.icon != null && mKeyboard != null) {
                 if (code == KEYCODE_SHIFT) {
                     val drawableId = when (mKeyboard!!.mShiftState) {
-                        SHIFT_OFF -> R.drawable.ic_caps_outline_vector
-                        SHIFT_ON_ONE_CHAR -> R.drawable.ic_caps_vector
+                        ShiftState.OFF -> R.drawable.ic_caps_outline_vector
+                        ShiftState.ON_ONE_CHAR -> R.drawable.ic_caps_vector
                         else -> R.drawable.ic_caps_underlined_vector
                     }
                     key.icon = resources.getDrawable(drawableId)
@@ -1131,7 +1131,7 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut
                 mMiniKeyboardSelectedKeyIndex = selectedKeyIndex
                 mMiniKeyboard!!.invalidateAllKeys()
 
-                val miniShiftStatus = if (isShifted()) SHIFT_ON_PERMANENT else SHIFT_OFF
+                val miniShiftStatus = if (isShifted()) ShiftState.ON_PERMANENT else ShiftState.OFF
                 mMiniKeyboard!!.setShifted(miniShiftStatus)
                 mPopupKeyboard.contentView = mMiniKeyboardContainer
                 mPopupKeyboard.width = mMiniKeyboardContainer!!.measuredWidth