Sichtbarkeit der Eingabemethode verarbeiten

Wenn der Eingabefokus in ein oder aus einem bearbeitbaren Textfeld bewegt wird, zeigt Android oder die Eingabe, etwa die Bildschirmtastatur, angemessen sein. Das System entscheidet auch, wie deine Benutzeroberfläche und das Textfeld oben angezeigt werden. die Eingabemethode. Wenn der vertikale Bereich auf dem Bildschirm beschränkt ist, füllt das Textfeld möglicherweise den gesamten Raum über der Eingabemethode aus.

Für die meisten Apps sind diese Standardverhaltensweisen nicht erforderlich. In einigen Fällen Möglicherweise möchten Sie jedoch mehr Kontrolle über die Sichtbarkeit der Eingabemethode und wie sich das auf das Layout auswirkt. In dieser Lektion erfahren Sie, wie Sie Sichtbarkeit der Eingabemethode ändern.

Hinweis :Auf dieser Seite wird durchgehend auf den Begriff Tastatur verwiesen. steht für eine Bildschirmtastatur und ist die häufigste Art der weichen Eingabe. . Android unterstützt andere Arten von weichen Eingabemethoden, darunter auch Bilder, Eingabe und Zeichnen.

Softtastatur anzeigen, wenn die Aktivität beginnt

Obwohl Android den Fokus auf das erste Textfeld in Ihrem Layout lenkt, Aktivität beginnt, wird die Bildschirmtastatur nicht angezeigt. Dieses Verhalten ist angemessen da die Eingabe von Text möglicherweise nicht die Hauptaufgabe der Aktivität ist. Wenn jedoch ist die Eingabe von Text die Hauptaufgabe, z. B. auf einem Anmeldebildschirm, möchten Sie wahrscheinlich, dass die Bildschirmtastatur standardmäßig angezeigt wird.

Damit die Eingabemethode angezeigt wird, wenn Ihre Aktivität beginnt, fügen Sie den android:windowSoftInputMode-Attribut <activity>-Element mit dem Wert "stateVisible". Beispiel:

<application ... >
    <activity
        android:windowSoftInputMode="stateVisible" ... >
        ...
    </activity>
   ...
</application>

Hinweis :Wenn das Gerät des Nutzers mit einer Hardwaretastatur ausgestattet ist, kann die Bildschirmtastatur erscheint nicht.

Angeben, wie die UI reagieren soll

Wenn die Softtastatur auf dem Bildschirm angezeigt wird, reduziert sie den Platz. die für die Benutzeroberfläche Ihrer App verfügbar sind. Das System entscheidet, wie die sichtbaren Teile der Benutzeroberfläche, aber es funktioniert möglicherweise nicht richtig. Um ein optimales Verhalten für Ihre App angeben, wie das System Ihre UI in der verbleibenden Speicherplatz.

Um Ihre bevorzugte Behandlung für eine Aktivität festzulegen, verwenden Sie die Attribut android:windowSoftInputMode im <activity>-Element Ihres Manifests mit einer der Größen Werte.

Um beispielsweise sicherzustellen, dass das System Ihr Layout an die verfügbaren sodass Sie auf alle Ihre Layoutinhalte zugreifen können, selbst wenn Scrollen erforderlich – "adjustResize" verwenden:

<application ... >
   <activity
       android:windowSoftInputMode="adjustResize" ... >
       ...
   </activity>
   ...
</application>

Sie können die Anpassungsspezifikation mit der anfänglichen Bildschirmtastatur kombinieren. Sichtbarkeit aus dem vorherigen Abschnitt:

<activity
    android:windowSoftInputMode="stateVisible|adjustResize" ... >
    ...
</activity>

Die Angabe von "adjustResize" ist wichtig, wenn Ihre UI Steuerelemente enthält, die vom müssen Nutzer möglicherweise sofort nach oder während der Texteingabe darauf zugreifen. Für Wenn Sie beispielsweise ein relatives Layout verwenden, um eine Schaltflächenleiste am unteren Rand auf dem Bildschirm. Mit "adjustResize" wird die Größe des Layouts so geändert, dass die Schaltflächenleiste angezeigt wird. über der Bildschirmtastatur.

Softtastatur bei Bedarf anzeigen

Wenn es eine Methode im Lebenszyklus Ihrer Aktivität gibt, bei der Sie sicherstellen möchten, Eingabemethode angezeigt wird, können Sie den InputMethodManager um sie anzuzeigen.

Die folgende Methode verwendet beispielsweise View, in dem der Nutzer voraussichtlich etwas eingeben, Anrufe requestFocus() dafür geben Fokus und ruft dann showSoftInput() auf, um die Eingabemethode zu öffnen:

Kotlin

fun showSoftKeyboard(view: View) {
   if (view.requestFocus()) {
       val imm = getSystemService(InputMethodManager::class.java)
       imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
   }
}

Java

public void showSoftKeyboard(View view) {
   if (view.requestFocus()) {
       InputMethodManager imm = getSystemService(InputMethodManager.class);
       imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
   }
}

Hinweis :Sobald die Bildschirmtastatur sichtbar ist, können Sie sie nicht programmatisch ausblenden. Die blendet das System die Eingabemethode aus, wenn der Nutzer die Aufgabe im Textfeld beendet. Alternativ kann der Nutzer sie mit einer Systemsteuerung ausblenden, z. B. über die Schaltfläche

Achtung: Verwenden Sie das Flag SHOW_FORCED nicht in showSoftInput() zum Anfordern der Bildschirmtastatur. Andernfalls wird die Software kann die Tastatur auch nach dem Schließen der App geöffnet bleiben.

Softtastatur zuverlässig anzeigen

In bestimmten Situationen, z. B. dem Beginn einer Aktivität, Verwenden Sie InputMethodManager.showSoftInput(), um die Bildschirmtastatur aufzurufen. kann dies dazu führen, dass die Softwaretastatur für den Nutzer nicht sichtbar ist.

Die Sichtbarkeit der Bildschirmtastatur bei Verwendung von showSoftInput() ist abhängig unter folgenden Bedingungen:

• Die Ansicht muss bereits mit der Softwaretastatur verbunden sein. (Dies wiederum Für diese Funktion sind das Fenster fokussiert und der Editor erforderlich. um den Ansichtsfokus mit View.requestFocus())

• Die Sichtbarkeit kann auch durch die android:windowSoftInputMode beeinflusst werden. Attribut und Flags, die von showSoftInput() verwendet werden.

In bestimmten Anwendungsfällen, z. B. beim Beginn einer Aktivität, werden einige davon erforderlichen Bedingungen nicht erfüllt sind. Das System stuft die Ansicht nicht als die mit der Bildschirmtastatur verbunden ist, ignoriert den Aufruf showSoftInput(), und die Bildschirmtastatur für den Nutzer nicht sichtbar ist.

Damit die Softwaretastatur zuverlässig angezeigt wird, können Sie Folgendes verwenden: Alternativen:

• (Empfohlen) Verwenden Sie WindowInsetsControllerCompat. Dieses Objekt zeigt die Tastatur während Activity.onCreate() an, wie in den folgenden Code-Snippet. Der Anruf wird garantiert nach dem Zeitfenster geplant fokussiert ist.

Kotlin

editText.requestFocus()
WindowCompat.getInsetsController(window, editText)!!.show(WindowInsetsCompat.Type.ime())

Java

editText.requestFocus();
WindowCompat.getInsetsController(getWindow(), editText).show(WindowInsetsCompat.Type.ime());

• Posten Sie ein Runnable. Dadurch wird sichergestellt, dass Ihre App wartet, bis die Fenster-Fokusereignis von View.onWindowFocusChanged() vor dem Aufruf showSoftInput()

Kotlin

class MyEditText : EditText() {
  ...
  override fun onWindowFocusChanged(hasWindowFocus: Boolean) {
    if (hasWindowFocus) {
      requestFocus()
      post {
        val imm: InputMethodManager = getSystemService(InputMethodManager::class.java)
        imm.showSoftInput(this, 0)
      }
    }
  }
}

Java

public class MyEditText extends EditText {
  ...
  @Override
  public void onWindowFocusChanged(boolean hasWindowFocus) {
    if (hasWindowFocus) {
      requestFocus();
      post(() -> {
        InputMethodManager imm = getSystemService(InputMethodManager.class);
        imm.showSoftInput(this, 0);
      });
    }
  }
}

Mit Flags für die Laufzeitsichtbarkeit vorsichtig umgehen

Achten Sie beim Wechseln der Sichtbarkeit der Softtastatur zur Laufzeit darauf, dass bestimmte in diese Methoden einfügen. Wenn die Anwendung beispielsweise Bildschirmtastatur wird beim Anrufen angezeigt View.getWindowInsetsController().show(ime()) in Activity.onCreate() im Zeitraum sollte die Aktivität gestartet werden, sollten App-Entwickler darauf achten, SOFT_INPUT_STATE_HIDDEN- oder SOFT_INPUT_STATE_ALWAYS_HIDDEN-Flags für den Fall, dass die Bildschirmtastatur unerwartet verdeckt wird.

Das System blendet die Bildschirmtastatur normalerweise automatisch aus

In den meisten Fällen blendet das System die Bildschirmtastatur aus. Dieses Folgende Fälle sind möglich:

• Der Nutzer beendet die Aufgabe im Textfeld.
• Der Nutzer drückt die Zurück-Taste oder Wischgesten mit der Rückwärtsnavigation.
• Der Nutzer wechselt zu einer anderen App, Flags SOFT_INPUT_STATE_HIDDEN oder SOFT_INPUT_STATE_ALWAYS_HIDDEN wenn der Aufruf mehr fokussiert wird.

Hinweis: Wenn Sie den Fokus auf eine Ansicht stellen, bei der es sich nicht um ein Textfeld handelt, wird die Bildschirmtastatur nicht geschlossen. für sich allein.

Softtastatur je nach vorherigem Systemverhalten manuell ausblenden

In einigen Fällen muss Ihre App die Bildschirmtastatur manuell ausblenden. Wenn das Textfeld in einem anderen Bereich View.OnFocusChangeListener.onFocusChange Verwenden Sie diese Technik mit Bedacht Das Schließen der Softtastatur beeinträchtigt die Nutzererfahrung unerwartet.

Wenn Ihre App die Bildschirmtastatur manuell ausblendet, müssen Sie wissen, die Bildschirmtastatur explizit oder implizit angezeigt wurde:

• Es wird davon ausgegangen, dass die Bildschirmtastatur nach dem Ereignis explizit angezeigt wurde. einen Anruf an showSoftInput().

• Umgekehrt wird die Softtastatur als implizit in eine der folgenden Bedingungen:

  • Das System zeigte die Bildschirmtastatur beim Anwenden der android:windowSoftInputMode
  • Deine App hat SHOW_IMPLICIT übergeben an showSoftInput()

Normalerweise blendet hideSoftInputFromWindow() die Bildschirmtastatur unabhängig von wie sie angefordert wurde, aber mit HIDE_IMPLICIT_ONLY Sie kann auf eine implizit angeforderte Bildschirmtastatur beschränkt werden.

Dialogfeld oder Overlay-Ansicht über der Bildschirmtastatur anzeigen

In einigen Situationen muss die Bearbeiteraktivität möglicherweise eine nicht bearbeitbare oder Overlay-Fenster über dem Bildschirm.

Ihre App bietet einige Optionen, die in den folgenden Abschnitten beschrieben werden.

Kurz gesagt: Achten Sie darauf, die Fenster-Flags der Bildschirmtastatur richtig zu handhaben Ausrichtung auf das Zeitfenster so, dass es die folgenden Erwartungen erfüllt zur vertikalen Reihenfolge (Z-Layer):

• Keine Markierungen (normale Groß-/Kleinschreibung): Diese Option befindet sich hinter der Softtastatur-Ebene und kann Text empfangen.
• FLAG_NOT_FOCUSABLE : Über der Softtastaturebene, kann jedoch keinen Text empfangen
• FLAG_ALT_FOCUSABLE_IM : Über der Softtastaturebene kann fokussiert werden, ist aber nicht mit dem Bildschirmtastatur. Außerdem wird verhindert, dass darunter Ansichten mit dem Bildschirmtastatur. Dies ist nützlich, wenn ein App-Dialogfeld ohne Text angezeigt werden soll über der Soft-Keyboard-Ebene.
• FLAG_NOT_FOCUSABLE und FLAG_ALT_FOCUSABLE_IM : Hinter der Softtastatur-Ebene, kann jedoch keinen Text empfangen
• FLAG_NOT_FOCUSABLE und FLAG_NOT_TOUCH_MODAL : Oben auf der Softtastatur, und ermöglicht das Durchlaufen von Touch-Events das Fenster auf die Bildschirmtastatur.

Dialogfeld erstellen

Verwenden Sie den FLAG_ALT_FOCUSABLE_IM. Markierung für das Dialogfenster festlegen, damit das Dialogfeld über der Bildschirmtastatur bleibt und So verhindern Sie, dass der Fokus der Bildschirmtastatur gestärkt wird:

Kotlin

val content = TextView(this)
content.text = "Non-editable dialog on top of soft keyboard"
content.gravity = Gravity.CENTER
val builder = AlertDialog.Builder(this)
  .setTitle("Soft keyboard layering demo")
  .setView(content)
mDialog = builder.create()
mDialog!!.window!!
  .addFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM)
mDialog!!.show()

Java

TextView content = new TextView(this);
content.setText("Non-editable dialog on top of soft keyboard");
content.setGravity(Gravity.CENTER);
final AlertDialog.Builder builder = new AlertDialog.Builder(this)
    .setTitle("Soft keyboard layering demo")
    .setView(content);
mDialog = builder.create();
mDialog.getWindow().addFlags(FLAG_ALT_FOCUSABLE_IM);
mDialog.show();

Overlay-Ansicht erstellen

Overlay-Ansicht mit TYPE_APPLICATION_OVERLAY erstellen Fenstertyp und FLAG_ALT_FOCUSABLE_IM Fenster-Flag durch die Soft-Keyboard-Targeting-Aktivität.

Hinweis :Dazu muss der Nutzer die spezielle SYSTEM_ALERT_WINDOW-Berechtigung gewähren. Berechtigung für deine App.

Kotlin

val params = WindowManager.LayoutParams(
  width,  /* Overlay window width */
  height,  /* Overlay window height */
  WindowManager.LayoutParams.TYPE_APPLICATION, /* Overlay window type */
  WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM /* No need to allow for text input on top of the soft keyboard */
    or WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL,  /* Allow touch event send to soft keyboard behind the overlay */
  PixelFormat.TRANSLUCENT
)
params.title = "Overlay window"
mOverlayView!!.layoutParams = params
windowManager.addView(mOverlayView, params)

Java

WindowManager.LayoutParams params = new WindowManager.LayoutParams(
    width, /* Overlay window width */
    height, /* Overlay window height */
    TYPE_APPLICATION, /* Overlay window type */
    FLAG_ALT_FOCUSABLE_IM /* No need to allow for text input on top of the soft keyboard */
        | FLAG_NOT_TOUCH_MODAL, /* Allow touch event send to soft keyboard behind the overlay */
    PixelFormat.TRANSLUCENT);
params.setTitle("Overlay window");
mOverlayView.setLayoutParams(params);
getWindowManager().addView(mOverlayView, params);

Dialogfeld oder Ansicht unter der Bildschirmtastatur anzeigen

Ihre App muss möglicherweise ein Dialogfeld oder ein Fenster mit der folgenden Properties:

• Wird unter der von einer Editor-Aktivität angeforderten Tastatur angezeigt sodass sie nicht von der Texteingabe beeinflusst wird.
• Berücksichtigt alle Änderungen an der Größe der Softtastatur in das Layout des Dialogfelds oder des Fensters anzupassen.

In diesem Fall hat Ihre App mehrere Möglichkeiten. Die folgenden Abschnitte beschreiben diese Optionen.

Dialogfeld erstellen

Erstellen Sie ein Dialogfeld, indem Sie sowohl FLAG_NOT_FOCUSABLE Fenster-Flag und FLAG_ALT_FOCUSABLE_IM Kennzeichen für Fenster:

Kotlin

val content = TextView(this)
content.text = "Non-editable dialog behind soft keyboard"
content.gravity = Gravity.CENTER
val builder = AlertDialog.Builder(this)
  .setTitle("Soft keyboard layering demo")
  .setView(content)
mDialog = builder.create()
mDialog!!.window!!
  .addFlags(FLAG_NOT_FOCUSABLE or FLAG_ALT_FOCUSABLE_IM)
mDialog!!.show()

Java

TextView content = new TextView(this);
content.setText("Non-editable dialog behind soft keyboard");
content.setGravity(Gravity.CENTER);
final AlertDialog.Builder builder = new AlertDialog.Builder(this)
    .setTitle("Soft keyboard layering demo")
    .setView(content);

mDialog = builder.create();
mDialog.getWindow()
    .addFlags(FLAG_NOT_FOCUSABLE | FLAG_ALT_FOCUSABLE_IM);
mDialog.show();

Overlay-Ansicht erstellen

Erstellen Sie eine Overlay-Ansicht, indem Sie FLAG_NOT_FOCUSABLE festlegen. Fenster-Flag und FLAG_ALT_FOCUSABLE_IM Kennzeichen für Fenster:

Kotlin

val params = WindowManager.LayoutParams(
  width,  /* Overlay window width */
  height,  /* Overlay window height */
  WindowManager.LayoutParams.TYPE_APPLICATION,  /* Overlay window type */
  WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
      or WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
  PixelFormat.TRANSLUCENT
)
params.title = "Overlay window"
mOverlayView!!.layoutParams = params
windowManager.addView(mOverlayView, params)

Java

WindowManager.LayoutParams params = new WindowManager.LayoutParams(
    width, /* Overlay window width */
    height, /* Overlay window height */
    TYPE_APPLICATION, /* Overlay window type */
    FLAG_NOT_FOCUSABLE | FLAG_ALT_FOCUSABLE_IM,
    PixelFormat.TRANSLUCENT);
params.setTitle("Overlay window");
mOverlayView.setLayoutParams(params);
getWindowManager().addView(mOverlayView, params);