refactor: enhance inline suggestion

- Make InlineSuggestionsUi inside AlwaysUi
- Improve the UI design
- Add preference to enable or disable it

Author: WhiredPlanck

app/src/main/java/com/osfans/trime/data/prefs/AppPrefs.kt

@@ -92,11 +92,13 @@ class AppPrefs(
         companion object {
             const val COMPOSING_TEXT_MODE = "composing_text_mode"
             const val ASCII_SWITCH_TIPS = "ascii_switch_tips"
+            const val INLINE_SUGGESTIONS = "inline_suggestions"
             const val PREFERRED_VOICE_INPUT = "preferred_voice_input"
         }
 
         val composingTextMode = enum(R.string.composing_text_mode, COMPOSING_TEXT_MODE, ComposingTextMode.DISABLE)
         val asciiSwitchTips = switch(R.string.ascii_switch_tips, ASCII_SWITCH_TIPS, true)
+        val inlineSuggestions = switch(R.string.inline_suggestions, INLINE_SUGGESTIONS, true)
 
         val preferredVoiceInput = list(
             R.string.preferred_voice_input,

app/src/main/java/com/osfans/trime/ime/bar/QuickBar.kt

@@ -7,9 +7,14 @@ package com.osfans.trime.ime.bar
 
 import android.content.Context
 import android.os.Build
+import android.util.Size
 import android.view.View
+import android.view.ViewGroup
 import android.view.inputmethod.EditorInfo
+import android.view.inputmethod.InlineSuggestion
+import android.view.inputmethod.InlineSuggestionsResponse
 import android.widget.ViewAnimator
+import android.widget.inline.InlineContentView
 import androidx.annotation.Keep
 import androidx.annotation.RequiresApi
 import androidx.lifecycle.lifecycleScope
@@ -23,10 +28,9 @@ import com.osfans.trime.data.theme.KeyActionManager
 import com.osfans.trime.data.theme.Theme
 import com.osfans.trime.ime.bar.ui.AlwaysUi
 import com.osfans.trime.ime.bar.ui.CandidateUi
-import com.osfans.trime.ime.bar.ui.InlineSuggestionUi
 import com.osfans.trime.ime.bar.ui.TabUi
 import com.osfans.trime.ime.broadcast.InputBroadcastReceiver
-import com.osfans.trime.ime.candidates.CandidateModule
+import com.osfans.trime.ime.candidates.compact.CompactCandidateModule
 import com.osfans.trime.ime.candidates.unrolled.window.FlexboxUnrolledCandidateWindow
 import com.osfans.trime.ime.core.TrimeInputMethodService
 import com.osfans.trime.ime.dependency.InputScope
@@ -39,13 +43,18 @@ import com.osfans.trime.ime.window.BoardWindowManager
 import com.osfans.trime.ui.main.ClipEditActivity
 import com.osfans.trime.util.AppUtils
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import me.tatarka.inject.annotations.Inject
 import splitties.dimensions.dp
 import splitties.views.dsl.core.add
 import splitties.views.dsl.core.lParams
 import splitties.views.dsl.core.matchParent
+import java.util.concurrent.Executor
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
 
 @InputScope
 @Inject
@@ -55,7 +64,7 @@ class QuickBar(
     private val rime: RimeSession,
     private val theme: Theme,
     private val windowManager: BoardWindowManager,
-    lazyCandidate: Lazy<CandidateModule>,
+    lazyCandidate: Lazy<CompactCandidateModule>,
     lazyCommonKeyboardActionListener: Lazy<CommonKeyboardActionListener>,
 ) : InputBroadcastReceiver {
 
@@ -76,6 +85,7 @@ class QuickBar(
     private var clipboardTimeoutJob: Job? = null
 
     private var isClipboardFresh: Boolean = false
+    private var isInlineSuggestionPresent: Boolean = false
 
     @Keep
     private val onClipboardUpdateListener = ClipboardHelper.OnClipboardUpdateListener {
@@ -107,6 +117,7 @@ class QuickBar(
         val newState =
             when {
                 isClipboardFresh -> AlwaysUi.State.Clipboard
+                isInlineSuggestionPresent -> AlwaysUi.State.InlineSuggestion
                 else -> AlwaysUi.State.Toolbar
             }
         if (newState == alwaysUi.currentState) return
@@ -148,17 +159,13 @@ class QuickBar(
     }
 
     private val candidateUi by lazy {
-        CandidateUi(context, candidate.compactCandidateModule.view).apply {
+        CandidateUi(context, candidate.view).apply {
             unrollButton.apply {
                 onSwipeListener = swipeDownHideKeyboardCallback
             }
         }
     }
 
-    private val inlineSuggestionUi by lazy {
-        InlineSuggestionUi(context, candidate.suggestionCandidateModule.view)
-    }
-
     private val tabUi by lazy {
         TabUi(context, theme)
     }
@@ -188,7 +195,7 @@ class QuickBar(
     private fun setUnrollButtonToAttach() {
         candidateUi.unrollButton.setOnClickListener { view ->
             windowManager.attachWindow(
-                FlexboxUnrolledCandidateWindow(context, service, rime, theme, this, windowManager, candidate.compactCandidateModule),
+                FlexboxUnrolledCandidateWindow(context, service, rime, theme, this, windowManager, candidate),
             )
         }
         candidateUi.unrollButton.setIcon(R.drawable.ic_baseline_expand_more_24)
@@ -241,7 +248,6 @@ class QuickBar(
             add(alwaysUi.root, lParams(matchParent, matchParent))
             add(candidateUi.root, lParams(matchParent, matchParent))
             add(tabUi.root, lParams(matchParent, matchParent))
-            add(inlineSuggestionUi.root, lParams(matchParent, matchParent))
 
             evalAlwaysUiState()
             ClipboardHelper.addOnUpdateListener(onClipboardUpdateListener)
@@ -266,12 +272,59 @@ class QuickBar(
         barStateMachine.push(QuickBarStateMachine.TransitionEvent.WindowDetached)
     }
 
+    private val suggestionSize by lazy {
+        Size(ViewGroup.LayoutParams.WRAP_CONTENT, context.dp(themedHeight))
+    }
+
+    private val directExecutor by lazy {
+        Executor { it.run() }
+    }
+
     @RequiresApi(Build.VERSION_CODES.R)
-    fun handleInlineSuggestions(isEmpty: Boolean) {
-        barStateMachine.push(
-            QuickBarStateMachine.TransitionEvent.SuggestionUpdated,
-            QuickBarStateMachine.BooleanKey.SuggestionEmpty to isEmpty,
-        )
+    fun handleInlineSuggestions(response: InlineSuggestionsResponse): Boolean {
+        val suggestions = response.inlineSuggestions
+        if (suggestions.isEmpty()) {
+            isInlineSuggestionPresent = false
+            return true
+        }
+        var pinned: InlineSuggestion? = null
+        val scrollable = mutableListOf<InlineSuggestion>()
+        var extraPinnedCount = 0
+        suggestions.forEach {
+            if (it.info.isPinned) {
+                if (pinned == null) {
+                    pinned = it
+                } else {
+                    scrollable.add(extraPinnedCount++, it)
+                }
+            } else {
+                scrollable.add(it)
+            }
+        }
+        service.lifecycleScope.launch {
+            alwaysUi.inlineSuggestionsUi.setPinnedView(
+                pinned?.let { inflateInlineContentView(it) },
+            )
+        }
+        service.lifecycleScope.launch {
+            val views = scrollable.map { s ->
+                service.lifecycleScope.async {
+                    inflateInlineContentView(s)
+                }
+            }.awaitAll()
+            alwaysUi.inlineSuggestionsUi.setScrollableViews(views)
+        }
+        isInlineSuggestionPresent = true
+        evalAlwaysUiState()
+        return true
+    }
+
+    @RequiresApi(Build.VERSION_CODES.R)
+    private suspend fun inflateInlineContentView(suggestion: InlineSuggestion): InlineContentView? = suspendCoroutine { c ->
+        // callback view might be null
+        suggestion.inflate(context, suggestionSize, directExecutor) { v ->
+            c.resume(v)
+        }
     }
 
     override fun onRimeOptionUpdated(value: RimeMessage.OptionMessage.Data) {

app/src/main/java/com/osfans/trime/ime/bar/QuickBarStateMachine.kt

@@ -6,10 +6,8 @@
 package com.osfans.trime.ime.bar
 
 import com.osfans.trime.ime.bar.QuickBarStateMachine.BooleanKey.CandidateEmpty
-import com.osfans.trime.ime.bar.QuickBarStateMachine.BooleanKey.SuggestionEmpty
 import com.osfans.trime.ime.bar.QuickBarStateMachine.State.Always
 import com.osfans.trime.ime.bar.QuickBarStateMachine.State.Candidate
-import com.osfans.trime.ime.bar.QuickBarStateMachine.State.Suggestion
 import com.osfans.trime.ime.bar.QuickBarStateMachine.State.Tab
 import com.osfans.trime.util.BuildTransitionEvent
 import com.osfans.trime.util.EventStateMachine
@@ -20,12 +18,10 @@ object QuickBarStateMachine {
         Always,
         Candidate,
         Tab,
-        Suggestion,
     }
 
     enum class BooleanKey : EventStateMachine.BooleanStateKey {
         CandidateEmpty,
-        SuggestionEmpty,
     }
 
     enum class TransitionEvent(
@@ -34,31 +30,23 @@ object QuickBarStateMachine {
         CandidatesUpdated({
             from(Always) transitTo Candidate on (CandidateEmpty to false)
             from(Candidate) transitTo Always on (CandidateEmpty to true)
-            from(Suggestion) transitTo Candidate on (CandidateEmpty to false)
         }),
         BarBoardWindowAttached({
             from(Always) transitTo Tab
             from(Candidate) transitTo Tab
-            from(Suggestion) transitTo Tab
         }),
         WindowDetached({
             // candidate state has higher priority so here it goes first
             from(Tab) transitTo Candidate on (CandidateEmpty to false)
-            from(Tab) transitTo Suggestion on (SuggestionEmpty to false)
             from(Tab) transitTo Always
         }),
-        SuggestionUpdated({
-            from(Always) transitTo Suggestion on (SuggestionEmpty to false)
-            from(Suggestion) transitTo Always on (SuggestionEmpty to true)
-        }),
     }
 
     fun new(block: (State) -> Unit) = EventStateMachine<State, TransitionEvent, BooleanKey>(
         initialState = Always,
         externalBooleanStates =
         mutableMapOf(
             CandidateEmpty to true,
-            SuggestionEmpty to true,
         ),
     ).apply {
         onNewStateListener = block

app/src/main/java/com/osfans/trime/ime/bar/ui/AlwaysUi.kt

@@ -35,6 +35,7 @@ class AlwaysUi(
     enum class State {
         Toolbar,
         Clipboard,
+        InlineSuggestion,
     }
 
     var currentState = State.Toolbar
@@ -61,10 +62,13 @@ class AlwaysUi(
 
     val clipboardUi = ClipboardSuggestionUi(ctx)
 
+    val inlineSuggestionsUi = InlineSuggestionsUi(ctx)
+
     private val animator =
         ViewAnimator(ctx).apply {
             add(buttonsUi.root, lParams(matchParent, matchParent))
             add(clipboardUi.root, lParams(matchParent, matchParent))
+            add(inlineSuggestionsUi.root, lParams(matchParent, matchParent))
         }
 
     override val root: ConstraintLayout = constraintLayout {
@@ -112,6 +116,7 @@ class AlwaysUi(
         when (state) {
             State.Toolbar -> animator.displayedChild = 0
             State.Clipboard -> animator.displayedChild = 1
+            State.InlineSuggestion -> animator.displayedChild = 2
         }
         currentState = state
     }