Refactor: Reduce Return Statements Across Multiple Functions

app/src/main/java/be/scri/fragments/LanguageSettingsFragment.kt

@@ -295,15 +295,16 @@ class LanguageSettingsFragment : Fragment() {
     }
 
     fun getLanguageStringFromi18n(language: String): Int {
-        when (language) {
-            "German" -> return R.string.app__global_german
-            "French" -> return R.string.app__global_french
-            "Spanish" -> return R.string.app__global_spanish
-            "Italian" -> return R.string.app__global_italian
-            "Russian" -> return R.string.app__global_russian
-            "Portuguese" -> return R.string.app__global_portuguese
-            "Swedish" -> return R.string.app__global_swedish
-            else -> return R.string.app__global_english
-        }
+        val languageMap =
+            mapOf(
+                "German" to R.string.app__global_german,
+                "French" to R.string.app__global_french,
+                "Spanish" to R.string.app__global_spanish,
+                "Italian" to R.string.app__global_italian,
+                "Russian" to R.string.app__global_russian,
+                "Portuguese" to R.string.app__global_portuguese,
+                "Swedish" to R.string.app__global_swedish,
+            )
+        return languageMap[language] ?: R.string.app__global_english
     }
 }

app/src/main/java/be/scri/helpers/AlphanumericComparator.kt

@@ -29,9 +29,7 @@ class AlphanumericComparator {
                 if (result == 0) {
                     for (i in 0 until thisChunkLength) {
                         result = thisChunk[i] - thatChunk[i]
-                        if (result != 0) {
-                            return result
-                        }
+                        if (result != 0) break
                     }
                 }
             } else {

app/src/main/java/be/scri/services/SimpleKeyboardIME.kt

@@ -65,13 +65,8 @@ abstract class SimpleKeyboardIME :
 
     override fun hasTextBeforeCursor(): Boolean {
         val inputConnection = currentInputConnection ?: return false
-        val textBeforeCursor = inputConnection.getTextBeforeCursor(Int.MAX_VALUE, 0)
-        if (textBeforeCursor.isNullOrBlank()) {
-            return false
-        }
-        val trimmedText = textBeforeCursor.trim()
-        val lastChar = trimmedText.lastOrNull()
-        return lastChar != '.'
+        val textBeforeCursor = inputConnection.getTextBeforeCursor(Int.MAX_VALUE, 0).orEmpty().trim()
+        return textBeforeCursor.isNotEmpty() && textBeforeCursor.lastOrNull() != '.'
     }
 
     override fun commitPeriodAfterSpace() {

app/src/main/java/be/scri/views/MyKeyboardView.kt

@@ -967,29 +967,18 @@ class MyKeyboardView
             )
         }
 
-        private fun openPopupIfRequired(me: MotionEvent): Boolean {
-            // Check if we have a popup layout specified first.
-            if (mPopupLayout == 0) {
-                return false
-            }
-
-            if (mCurrentKey < 0 || mCurrentKey >= mKeys.size) {
-                return false
-            }
-
-            val popupKey = mKeys[mCurrentKey]
-            val result = onLongPress(popupKey, me)
-            if (result) {
-                mAbortKey = true
-                showPreview(NOT_A_KEY)
-            }
+    private fun openPopupIfRequired(me: MotionEvent): Boolean {
+        if (mPopupLayout == 0 || mCurrentKey !in mKeys.indices) {
+            return false
+        }
 
-            return result
+        val popupKey = mKeys[mCurrentKey]
+        val result = onLongPress(popupKey, me)
+        if (result) {
+            mAbortKey = true
+            showPreview(NOT_A_KEY)
         }
 
-        /**
-         * Called when a key is long pressed.
-         * By default this will open any popup keyboard associated with this key through the attributes
          * popupLayout and popupCharacters.
          * @param popupKey the key that was long pressed
          * @return true if the long press is handled, false otherwise.
@@ -1197,36 +1186,37 @@ class MyKeyboardView
             return onModifiedTouchEvent(me)
         }
 
-        private fun onModifiedTouchEvent(me: MotionEvent): Boolean {
-            var touchX = me.x.toInt()
-            var touchY = me.y.toInt()
-            if (touchY >= -mVerticalCorrection) {
-                touchY += mVerticalCorrection
-            }
+    @Suppress("ReturnCount")
+    private fun onModifiedTouchEvent(me: MotionEvent): Boolean {
+        var touchX = me.x.toInt()
+        var touchY = me.y.toInt()
+        if (touchY >= -mVerticalCorrection) {
+            touchY += mVerticalCorrection
+        }
 
-            val action = me.actionMasked
-            val eventTime = me.eventTime
-            val keyIndex = getPressedKeyIndex(touchX, touchY)
+        val action = me.actionMasked
+        val eventTime = me.eventTime
+        val keyIndex = getPressedKeyIndex(touchX, touchY)
 
-            // Ignore all motion events until a DOWN.
-            if (mAbortKey && action != MotionEvent.ACTION_DOWN && action != MotionEvent.ACTION_CANCEL) {
-                return true
-            }
+        var handled = false
 
-            // Needs to be called after the gesture detector gets a turn, as it may have displayed the mini keyboard
-            if (mMiniKeyboardOnScreen && action != MotionEvent.ACTION_CANCEL) {
-                return true
-            }
+        // Ignore all motion events until a DOWN.
+        if (mAbortKey && action != MotionEvent.ACTION_DOWN && action != MotionEvent.ACTION_CANCEL) {
+            handled = true
+        }
+
+        // Handle mini keyboard case
+        if (mMiniKeyboardOnScreen && action != MotionEvent.ACTION_CANCEL) {
+            handled = true
+        }
 
+        if (!handled) {
             when (action) {
                 MotionEvent.ACTION_POINTER_DOWN -> {
-                    // if the user presses a key while still holding down the previous,
-                    // type in both chars and ignore the later gestures
-                    // can happen at fast typing, easier to reproduce by increasing LONGPRESS_TIMEOUT
                     ignoreTouches = true
                     mHandler!!.removeMessages(MSG_LONGPRESS)
                     dismissPopupKeyboard()
-                    detectAndSendKey(keyIndex, me.x.toInt(), me.y.toInt(), eventTime)
+                    detectAndSendKey(keyIndex, touchX, touchY, eventTime)
 
                     val newPointerX = me.getX(1).toInt()
                     val newPointerY = me.getY(1).toInt()
@@ -1235,13 +1225,11 @@ class MyKeyboardView
                     detectAndSendKey(secondKeyIndex, newPointerX, newPointerY, eventTime)
 
                     val secondKeyCode = mKeys.getOrNull(secondKeyIndex)?.code
-                    if (secondKeyCode != null) {
-                        mOnKeyboardActionListener!!.onPress(secondKeyCode)
-                    }
+                    secondKeyCode?.let { mOnKeyboardActionListener!!.onPress(it) }
 
                     showPreview(NOT_A_KEY)
                     invalidateKey(mCurrentKey)
-                    return true
+                    handled = true
                 }
                 MotionEvent.ACTION_DOWN -> {
                     mAbortKey = false
@@ -1251,39 +1239,30 @@ class MyKeyboardView
                     mCurrentKeyTime = 0
                     mLastKey = NOT_A_KEY
                     mCurrentKey = keyIndex
-                    mDownTime = me.eventTime
-                    mLastMoveTime = mDownTime
-
-                    val onPressKey =
-                        if (keyIndex != NOT_A_KEY) {
-                            mKeys[keyIndex].code
-                        } else {
-                            0
-                        }
+                    mDownTime = eventTime
+                    mLastMoveTime = eventTime
 
+                    val onPressKey = if (keyIndex != NOT_A_KEY) mKeys[keyIndex].code else 0
                     mOnKeyboardActionListener!!.onPress(onPressKey)
 
-                    var wasHandled = false
                     if (mCurrentKey >= 0 && mKeys[mCurrentKey].repeatable) {
                         mRepeatKeyIndex = mCurrentKey
-
                         val msg = mHandler!!.obtainMessage(MSG_REPEAT)
                         mHandler!!.sendMessageDelayed(msg, REPEAT_START_DELAY.toLong())
-                        // if the user long presses Space, move the cursor after swipine left/right
+
                         if (mKeys[mCurrentKey].code == KEYCODE_SPACE) {
                             mLastSpaceMoveX = -1
                         } else {
                             repeatKey(true)
                         }
 
-                        // Delivering the key could have caused an abort
                         if (mAbortKey) {
                             mRepeatKeyIndex = NOT_A_KEY
-                            wasHandled = true
+                            handled = true
                         }
                     }
 
-                    if (!wasHandled && mCurrentKey != NOT_A_KEY) {
+                    if (!handled && mCurrentKey != NOT_A_KEY) {
                         val msg = mHandler!!.obtainMessage(MSG_LONGPRESS, me)
                         mHandler!!.sendMessageDelayed(msg, LONGPRESS_TIMEOUT.toLong())
                     }
@@ -1331,9 +1310,7 @@ class MyKeyboardView
                             mLastSpaceMoveX = mLastX
                         }
                     } else if (!continueLongPress) {
-                        // Cancel old longpress
                         mHandler!!.removeMessages(MSG_LONGPRESS)
-                        // Start new longpress if key has changed
                         if (keyIndex != NOT_A_KEY) {
                             val msg = mHandler!!.obtainMessage(MSG_LONGPRESS, me)
                             mHandler!!.sendMessageDelayed(msg, LONGPRESS_TIMEOUT.toLong())
@@ -1362,9 +1339,10 @@ class MyKeyboardView
                         touchX = mLastCodeX
                         touchY = mLastCodeY
                     }
+
                     showPreview(NOT_A_KEY)
                     Arrays.fill(mKeyIndices, NOT_A_KEY)
-                    // If we're not on a repeating key (which sends on a DOWN event)
+
                     if (mRepeatKeyIndex == NOT_A_KEY && !mMiniKeyboardOnScreen && !mAbortKey) {
                         detectAndSendKey(mCurrentKey, touchX, touchY, eventTime)
                     }
@@ -1381,6 +1359,7 @@ class MyKeyboardView
                         }
                         lastSpaceBarTapTime = currentTime
                     }
+
                     invalidateKey(keyIndex)
                     mRepeatKeyIndex = NOT_A_KEY
                     mOnKeyboardActionListener!!.onActionUp()
@@ -1396,13 +1375,17 @@ class MyKeyboardView
                     invalidateKey(mCurrentKey)
                 }
             }
-
-            mLastX = touchX
-            mLastY = touchY
-            return true
         }
 
-        private fun repeatKey(initialCall: Boolean): Boolean {
+        mLastX = touchX
+        mLastY = touchY
+
+        return handled || true
+    }
+
+
+
+    private fun repeatKey(initialCall: Boolean): Boolean {
             val key = mKeys[mRepeatKeyIndex]
             if (!initialCall && key.code == KEYCODE_SPACE) {
                 if (!mIsLongPressingSpace) {

detekt.yml

@@ -8,7 +8,7 @@ style:
     WildcardImport:
         active: false
     ReturnCount:
-        active: false
+        active: true
     UnusedPrivateProperty:
         active: true
     UnusedParameter: