Wie schließe ich die virtuelle Tastatur von einem Jetpack Compose TextField?

Ich verwende Jetpack Compose TextField und ich möchte die virtuelle Tastatur schließen, wenn der Benutzer die Aktionstaste (imeActionPerformed Parameter).

val text = +state { "" }
TextField(
    value = text.value,
    keyboardType = KeyboardType.Text,
    imeAction = ImeAction.Done,
    onImeActionPerformed = { 
        // TODO Close the virtual keyboard here <<<
    }
    onValueChange = { s -> text.value = s }
)

Du kannst den … benutzen LocalSoftwareKeyboardController Klasse, um die aktuelle Software-Tastatur zu steuern und dann die zu verwenden hide Methode:

var text by remember { mutableStateOf(TextFieldValue("Text")) }
val keyboardController = LocalSoftwareKeyboardController.current

TextField(
        value = text,
        onValueChange = {
            text = it
        },
        label = { Text("Label") },
        keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
        keyboardActions = KeyboardActions(
                onDone = {keyboardController?.hide()})
)

Diese Lösung schließt die Tastatur ohne Entfernen des Fokus vom Strom TextField.

Nur um den Unterschied hervorzuheben mit:

val focusManager = LocalFocusManager.current
focusManager.clearFocus()

Dieser Code schließt die Tastatur und entfernt den Fokus von der Textfeld.

Ausgehend von komponieren 1.0.0-alpha12 (und immer noch gültig in compose 1.2.0) das onImeActionPerformed ist veraltet und der vorgeschlagene Ansatz ist zu verwenden keyboardActions mit Kombination aus keyboardOptions:

    val focusManager = LocalFocusManager.current

    OutlinedTextField(
        value = ...,
        onValueChange = ...,
        label = ...,
        keyboardActions = KeyboardActions(onDone = { focusManager.clearFocus() }),
        keyboardOptions = KeyboardOptions.Default.copy(imeAction = ImeAction.Done, keyboardType = KeyboardType.Password),
    )

focusManager.clearFocus() kümmert sich um die Entlassung der Soft-Tastatur.

Im 1.0.0 Sie können entweder verwenden SoftwareKeyboardController oder FocusManager um dies zu tun.

Diese Antwort konzentriert sich auf ihre Unterschiede.

Konfiguration:

var text by remember { mutableStateOf("")}

TextField(
    value = text,
    onValueChange = { text = it },
    keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
    keyboardActions = KeyboardActions(onDone = { /* TODO */ }),
)

SoftwareKeyboardController:

Bezogen auf @Gabriele Mariottis Antworten.

val keyboardController = LocalSoftwareKeyboardController.current

// TODO =
keyboardController?.hide()

Dies schließt nur die Tastatur, tut es aber NICHT Löschen Sie den Fokus von jedem fokussierten TextField (beachten Sie den Cursor und die dicke Unterstreichung).

FokusManager:

Bezogen auf @azizbekians Antworten.

val focusManager = LocalFocusManager.current

// TODO =
focusManager.clearFocus()

Dies schließt die Tastatur UND löscht den Fokus vom TextField.

Ausblenden der Tastatur beim Klicken auf die Schaltfläche

Um mit der Lösung von Gabriele Mariotti hinzuzufügen, wenn Sie die Tastatur bedingt ausblenden möchten, z. B. nach einem Tastenklick, verwenden Sie Folgendes:

keyboardController?.hide()

Blenden Sie beispielsweise die Tastatur aus, nachdem Sie auf die Schaltfläche Hinzufügen geklickt haben:

var newWord by remember { mutableStateOf("") }
val keyboardController = LocalSoftwareKeyboardController.current

// Setup the text field with keyboard as provided by Gabriele Mariotti

...

Button(
        modifier = Modifier
                .height(56.dp),
        onClick = {
                if (!newWord.trim().isNullOrEmpty()) {
                        wordViewModel.onAddWord(newWord.trim())
                        newWord = ""
                        keyboardController?.hide()
                }
        ...

Bearbeiten nach der Veröffentlichung von Alpha-12:
Siehe Antwort von @azizbekian.

Pre-Alpha-12-Antwort

Hier habe ich die Lösung gefunden 🙂

fun hideKeyboard(activity: Activity) {
    val imm: InputMethodManager = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
    var view = activity.currentFocus
    if (view == null) {
        view = View(activity)
    }
    imm.hideSoftInputFromWindow(view.windowToken, 0)
}

Ich muss nur die obige Funktion von meiner Komponente aufrufen:

// getting the context
val context = +ambient(ContextAmbient)

// textfield state
val text = +state { "" }

TextField(
    value = text.value,
    keyboardType = KeyboardType.Text,
    imeAction = ImeAction.Done,
    onImeActionPerformed = { 
        if (imeAction == ImeAction.Done) {
            hideKeyboard(context as Activity)
        }
    }
    onValueChange = { s -> text.value = s }
)

Implementierung „androidx.compose.material3:material3:1.0.0-alpha02“

Textfeld mit Tastatur bei Ime-Aktion ausblenden

@OptIn(ExperimentalComposeUiApi::class)
    @Composable
    fun TextFieldWithHideKeyboardOnImeAction() {
        val keyboardController = LocalSoftwareKeyboardController.current
        var text by rememberSaveable { mutableStateOf("") }
        TextField(
            value = text,
            onValueChange = { text = it },
            label = { Text("Label") },
            keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
            keyboardActions = KeyboardActions(
                onDone = {
                    keyboardController?.hide()
                    // do something here
                }
            )
        )
    }

Ich habe einen Weg gefunden, ihn im CoreTextField herunterzufahren, benutze TextInputService, um den Schalter zu steuern

val focus = LocalTextInputService.current
var text by remember{ mutableStateOf("")}
TextField(
    value = text,
    onValueChange = { text = it },
    keyboardOptions = KeyboardOptions.Default.copy(imeAction = ImeAction.Done, keyboardType = KeyboardType.Text),
    keyboardActions = KeyboardActions(onDone = { focus?.hideSoftwareKeyboard() }),
    singleLine = true
)