Consente di gestire la visibilità del metodo di immissione.

Quando lo stato attivo dell'input si sposta all'interno o all'esterno di un campo di testo modificabile, Android mostra o nasconde l'input, ad esempio la tastiera sullo schermo, ad esempio appropriato. Il sistema determina anche l'aspetto dell'interfaccia utente e del campo di testo sopra il metodo di inserimento. Ad esempio, quando lo spazio verticale sullo schermo è vincolato, il campo di testo potrebbe riempire tutto lo spazio sopra il metodo di inserimento.

Per la maggior parte delle app, questi comportamenti predefiniti sono tutto ciò che serve. In alcuni casi, potresti aver bisogno di un maggiore controllo sulla visibilità del metodo di inserimento l'impatto sul layout. Questa lezione spiega come controllare e rispondere la visibilità del metodo di input.

Mostra la tastiera su schermo all'avvio dell'attività

Android dà priorità al primo campo di testo nel layout quando inizia l'attività, la tastiera non viene visualizzata. Questo comportamento è appropriato perché l'inserimento del testo potrebbe non essere l'attività principale dell'attività. Tuttavia, se l'inserimento di testo è effettivamente l'attività principale, ad esempio nella schermata di accesso, probabilmente vorrai che la tastiera software venga visualizzata per impostazione predefinita.

Per visualizzare il metodo di inserimento quando inizia l'attività, aggiungi il metodo android:windowSoftInputMode al Elemento <activity> con il valore "stateVisible". Ad esempio:

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

Specifica come deve rispondere la UI

Quando la tastiera su schermo viene visualizzata, riduce la quantità di spazio disponibili per l'interfaccia utente della tua app. È il sistema a decidere come regolare della UI, ma potrebbe non funzionare correttamente. Per garantire un comportamento ottimale specifica la modalità di visualizzazione della UI nel di spazio rimanente.

Per dichiarare il trattamento preferito in un'attività, utilizza Attributo android:windowSoftInputMode nell'elemento <activity> del tuo manifest con uno dei pulsanti "Adjust" e i relativi valori.

Ad esempio, per garantire che il sistema ridimensiona il layout al che mantiene tutti i contenuti del layout accessibili, anche se richiede lo scorrimento. Utilizza "adjustResize":

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

Puoi combinare la specifica di regolazione con la tastiera software iniziale le specifiche sulla visibilità della sezione precedente:

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

Specificare "adjustResize" è importante se la tua UI include controlli che l'utente potrebbe dover accedere subito dopo o durante l'inserimento di testo. Per Ad esempio, se utilizzi un layout relativo per posizionare una barra dei pulsanti nella parte inferiore del sullo schermo, l'utilizzo di "adjustResize" ridimensiona il layout in modo che venga visualizzata la barra dei pulsanti sopra la tastiera software.

Mostra la tastiera su richiesta

Se nel ciclo di vita della tua attività è presente un metodo per cui vuoi assicurarti il metodo di immissione è visibile, puoi utilizzare InputMethodManager per mostrarlo.

Ad esempio, il seguente metodo prende un View in cui l'utente dovrebbe digita qualcosa, chiama requestFocus() per concedere lo stato attivo, quindi chiama showSoftInput() per aprire il metodo di immissione:

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

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

Mostra la tastiera su schermo in modo affidabile

Esistono alcune situazioni, ad esempio quando inizia un'attività, in cui utilizzando InputMethodManager.showSoftInput() per visualizzare la tastiera su schermo la tastiera software potrebbe non essere visibile all'utente.

La visibilità della tastiera su schermo quando viene utilizzato showSoftInput() dipende alle seguenti condizioni:

• La visualizzazione deve essere già collegata alla tastiera software. (Ciò, a sua volta, richiede che la finestra sia evidenziata e che l'editor per richiedere lo stato attivo con View.requestFocus()).

• La visibilità può essere influenzata anche dall'android:windowSoftInputMode e i flag utilizzati da showSoftInput().

In alcuni casi d'uso, ad esempio quando inizia un'attività, alcuni di questi se le condizioni richieste non sono soddisfatte. Il sistema non considera la vista come connesso alla tastiera software, ignora la chiamata a showSoftInput(), e la tastiera non è visibile all'utente.

Per assicurarti che la tastiera software venga visualizzata in modo affidabile, puoi utilizzare quanto segue alternative:

• (Consigliato) Usa WindowInsetsControllerCompat. Questo oggetto mostra la tastiera su schermo durante Activity.onCreate() come mostrato in successivo snippet di codice. È garantito che la chiamata venga programmata dopo la finestra temporale è focalizzato.

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

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

• Pubblicare un elemento eseguibile. In questo modo ti assicuri che l'app resti in attesa di ricevere il evento di stato attivo della finestra da View.onWindowFocusChanged() prima della chiamata showSoftInput().

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

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

Gestisci con attenzione i flag di visibilità di runtime

Quando attivi/disattivi la visibilità della tastiera su schermo in fase di runtime, fai attenzione a non superare in questi metodi. Ad esempio, se l'applicazione prevede la tastiera software viene visualizzata durante la chiamata View.getWindowInsetsController().show(ime()) a Activity.onCreate() nel periodo inizia l'attività, gli sviluppatori dell'applicazione devono prestare attenzione a non Flag SOFT_INPUT_STATE_HIDDEN o SOFT_INPUT_STATE_ALWAYS_HIDDEN durante l'avvio iniziale nel caso in cui la tastiera su schermo venga nascosta inaspettatamente.

Il sistema di solito nasconde automaticamente la tastiera su schermo

Nella maggior parte delle situazioni, il sistema gestisce come nascondere la tastiera su schermo. Questo può essere uno dei seguenti casi:

• L'utente completa l'attività nel campo di testo.
• L'utente preme il tasto Indietro o i gesti di scorrimento con la navigazione indietro.
• L'utente passa a un'altra app, la quale ha impostato Flag SOFT_INPUT_STATE_HIDDEN o SOFT_INPUT_STATE_ALWAYS_HIDDEN quando la visualizzazione acquisisce maggiore attenzione.

Nascondi manualmente la tastiera su schermo in base al comportamento precedente del sistema

La tua app deve nascondere manualmente la tastiera su schermo in alcune situazioni, ad esempio ad esempio quando il campo di testo perde lo stato attivo View.OnFocusChangeListener.onFocusChange Usa questa tecnica con accortezza. ; la chiusura della tastiera software compromette inaspettatamente l'esperienza utente.

Se la tua app nasconde manualmente la tastiera su schermo, devi sapere se La tastiera su schermo è stata mostrata in modo esplicito o implicitamente:

• Si considera che la tastiera su schermo sia stata mostrata esplicitamente dopo una chiamata al numero showSoftInput().

• Al contrario, si considera che la tastiera su schermo sia stata mostrata implicitamente una delle seguenti condizioni:

  • Il sistema ha mostrato la tastiera su schermo durante l'applicazione android:windowSoftInputMode.
  • L'app ha inviato SHOW_IMPLICIT a showSoftInput().

Normalmente, hideSoftInputFromWindow() nasconde la tastiera su schermo indipendentemente come è stata richiesta, ma con HIDE_IMPLICIT_ONLY può essere limitato alla sola chiusura di una tastiera su schermo richiesta implicitamente.

Mostra una finestra di dialogo o una visualizzazione sovrapposta sulla parte superiore della tastiera su schermo

In alcuni casi, l'attività dell'editor potrebbe dover creare un'immagine finestra di dialogo o sovrapposta sulla tastiera software.

La tua app ha alcune opzioni, descritte nelle sezioni seguenti.

In sintesi, assicurati di gestire correttamente i flag delle finestre della tastiera su schermo che abbia come target la finestra in modo da soddisfare le seguenti aspettative sull'ordinamento verticale (z-layer):

• Nessun flag (caso normale): si trova dietro il livello della tastiera virtuale e può ricevere testo.
• FLAG_NOT_FOCUSABLE : si trova sopra il livello della tastiera virtuale, ma non può ricevere testo.
• FLAG_ALT_FOCUSABLE_IM : sopra il livello della tastiera virtuale, può essere attivata, ma non è collegata al tastiera software. Inoltre, impedisce a tutte le viste sottostanti di connettersi al tastiera software. È utile per mostrare una finestra di dialogo dell'app che non utilizza testo sopra il livello della tastiera su schermo.
• FLAG_NOT_FOCUSABLE e FLAG_ALT_FOCUSABLE_IM : dietro il livello della tastiera su schermo, ma non può ricevere testo.
• FLAG_NOT_FOCUSABLE e FLAG_NOT_TOUCH_MODAL : sopra la tastiera su schermo e consenti il passaggio degli eventi touch la finestra sulla tastiera software.

Crea una finestra di dialogo

Utilizza la FLAG_ALT_FOCUSABLE_IM flag finestra di dialogo per mantenere la finestra di dialogo in cima alla tastiera software e per per evitare che la tastiera diventi attiva:

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()

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();

Creare una visualizzazione sovrapposta

Creare una visualizzazione overlay specificando TYPE_APPLICATION_OVERLAY. tipo di finestra e FLAG_ALT_FOCUSABLE_IM flag finestra dall'attività scelta come target della tastiera su schermo.

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)

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);

Mostra una finestra di dialogo o una visualizzazione sotto la tastiera su schermo

L'app potrebbe dover creare una finestra di dialogo con seguenti proprietà:

• Viene visualizzata sotto la tastiera su schermo richiesta dall'attività di un editor in modo che non venga influenzata dall'input di testo.
• Rimane a conoscenza delle modifiche alle modifiche alle dimensioni del riquadro della tastiera su schermo per regolare il layout della finestra di dialogo o della finestra.

In questo caso, l'app ha diverse opzioni. Le seguenti sezioni puoi descrivere queste opzioni.

Crea una finestra di dialogo

Crea una finestra di dialogo impostando sia FLAG_NOT_FOCUSABLE il flag di finestra e FLAG_ALT_FOCUSABLE_IM flag finestra:

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()

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();

Creare una visualizzazione sovrapposta

Crea una visualizzazione in overlay impostando FLAG_NOT_FOCUSABLE il flag di finestra e FLAG_ALT_FOCUSABLE_IM flag finestra:

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)

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);