Obsługa widoczności metody wprowadzania

Gdy fokus wprowadzanego tekstu pojawi się w edytowalnym polu tekstowym lub poza niego, Android wyświetli lub ukrywa dane wejściowe, np. klawiaturę ekranową, odpowiednie. System decyduje też, jak interfejs użytkownika i pole tekstowe będą wyglądać powyżej. metody wprowadzania. Jeśli na przykład pionowa przestrzeń na ekranie jest ograniczone pole tekstowe, może wypełnić całą przestrzeń nad metodą wprowadzania.

W większości aplikacji wystarczy Ci te domyślne działania. W niektórych przypadkach możesz jednak potrzebować większej kontroli nad widocznością metody wprowadzania jak wpływa to na układ. Z tej lekcji dowiesz się, jak kontrolować i reagować widoczność metody wprowadzania.

Pokazuj klawiaturę programową po rozpoczęciu aktywności

Chociaż Android koncentruje się na pierwszym polu tekstowym w układzie, gdy działa, nie wyświetla klawiatury programowej. Takie zachowanie jest odpowiednie bo wpisywanie tekstu może nie być głównym zadaniem w danej aktywności. Jeśli jednak wprowadzanie tekstu jest podstawowym zadaniem, na przykład na ekranie logowania, zapewne chce, aby klawiatura ekranowa wyświetlała się domyślnie.

Aby widzieć metodę wprowadzania po rozpoczęciu aktywności, dodaj metodę android:windowSoftInputMode do atrybutu <activity> element o wartości "stateVisible". Na przykład:

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

Określ, jak powinien reagować interfejs użytkownika

Gdy na ekranie pojawia się klawiatura ekranowa, zmniejsza się ilość miejsca w interfejsie aplikacji. System decyduje, jak dostosować widoczność ale może nie działać dobrze. Aby zapewnić jak najlepsze działanie aplikacji, określ, jak system ma wyświetlać niewykorzystane.

Aby zadeklarować preferowane podejście w danej aktywności, użyj Atrybut android:windowSoftInputMode w elemencie <activity> pliku manifestu przy użyciu jednej z opcji .

Aby na przykład zapewnić, że system zmieni rozmiar układu do dostępnego dzięki której cała zawartość układu jest dostępna, nawet jeśli wymaga przewijania – użyj formatu "adjustResize":

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

Specyfikację korekty możesz połączyć z początkową klawiaturą ekranową widoczności z poprzedniej sekcji:

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

Określenie atrybutu "adjustResize" jest ważne, jeśli interfejs użytkownika zawiera elementy sterujące, może chcieć uzyskać dostęp natychmiast po wprowadzeniu tekstu lub w jego trakcie. Dla: na przykład w układzie względnym w celu umieszczenia paska przycisków na dole ekran, przy użyciu funkcji "adjustResize" zmienia rozmiar układu, aby wyświetlić pasek przycisków nad klawiaturą programową.

Pokazuj klawiaturę programową na żądanie

Jeśli w cyklu życia aktywności jest metoda, w ramach której chcesz zapewnić metoda wprowadzania jest widoczna, możesz użyć InputMethodManager aby go pokazać.

Na przykład ta metoda pobiera View, w którym użytkownik powinien wpisz coś, połączenia requestFocus(), aby go dać zaznacz, a potem wywołuje showSoftInput(), by otworzyć metodę wprowadzania:

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

Pokazuj pewnie klawiaturę programową

Są pewne sytuacje, na przykład gdy aktywność się rozpoczyna, używając InputMethodManager.showSoftInput() do wyświetlenia klawiatury ekranowej może spowodować, że klawiatura programowa nie będzie widoczna dla użytkownika.

Widoczność klawiatury programowej podczas korzystania z showSoftInput() jest zależna gdy:

• Widok musi być już połączony z klawiaturą programową. (W ten sposób wymaga zaznaczenia okna oraz edytora aby uaktywnić widok, View.requestFocus()).

• Na widoczność może mieć również wpływ zasada android:windowSoftInputMode atrybutów i flag używanych przez showSoftInput().

W niektórych przypadkach, na przykład podczas uruchamiania aktywności, nie są spełnione wymagane warunki. System nie uzna wyświetlenia za podłączona do klawiatury programowej, ignoruje wywołanie showSoftInput(), a klawiatura ekranowa nie jest widoczna.

Aby mieć pewność, że klawiatura programowa będzie prawidłowo wyświetlana, możesz użyć tych inne opcje:

• (Zalecane) Użyj WindowInsetsControllerCompat. Ten obiekt wyświetla klawiaturę programową w czasie Activity.onCreate(), tak jak w ten fragment kodu. Gwarantujemy, że rozmowa zostanie zaplanowana po upływie tego czasu jest skupiony.

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

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

• Opublikuj element wykonywalny. Dzięki temu aplikacja będzie czekać na zdarzenie zaznaczenia okna od użytkownika View.onWindowFocusChanged() przed wywołaniem 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);
      });
    }
  }
}

Ostrożnie obchodź się ze flagami widoczności środowiska wykonawczego

Przy przełączaniu widoczności klawiatury ekranowej w czasie działania uważaj, by nie przekazywać niektórych oznaczanie wartości tych metod. Jeśli na przykład aplikacja oczekuje tagu przy dzwonieniu wyświetlana jest klawiatura ekranowa View.getWindowInsetsController().show(ime()) za Activity.onCreate() w okresie gdy rozpocznie się aktywność, programiści aplikacji powinni pamiętać, aby nie ustawiać Flagi SOFT_INPUT_STATE_HIDDEN lub SOFT_INPUT_STATE_ALWAYS_HIDDEN na wypadek nieoczekiwanego ukrycia klawiatury programowej.

System zwykle automatycznie ukrywa klawiaturę programową

W większości przypadków system ukrywa klawiaturę programową. Ten mogą wystąpić następujące przypadki:

• Użytkownik kończy zadanie w polu tekstowym.
• Użytkownik naciska klawisz cofania lub gesty przesuwania podczas nawigowania wstecz.
• użytkownik przejdzie do innej aplikacji, która ma Flagi SOFT_INPUT_STATE_HIDDEN lub SOFT_INPUT_STATE_ALWAYS_HIDDEN gdy widok zyskuje ostrość.

Ukryj klawiaturę programową ręcznie na podstawie poprzedniego działania systemu

W niektórych sytuacjach aplikacja musi ręcznie ukryć klawiaturę programową – na Na przykład gdy pole tekstowe straci ważność w View.OnFocusChangeListener.onFocusChange Ostrożnie korzystaj z tej metody zamknięcie klawiatury programowej nieoczekiwanie utrudnia obsługę.

Jeśli aplikacja ręcznie ukrywa klawiaturę programową, musisz sprawdzić, czy klawiatura programowa została pokazana wyraźnie lub bezpośredni:

• Uznaje się, że klawiatura ekranowa została wyraźnie wyświetlona po połączenie z numerem showSoftInput().

• I odwrotnie, uznaje się, że klawiaturę programową jeden z tych warunków:

  • System pokazał klawiaturę programową podczas stosowania klawisza android:windowSoftInputMode
  • Twoja aplikacja przeszła SHOW_IMPLICIT w: showSoftInput()

Normalnie hideSoftInputFromWindow() ukrywa klawiaturę programową niezależnie od jak wysłano prośbę, ale dzięki HIDE_IMPLICIT_ONLY można je ograniczyć tylko do zamknięcia klawiatury ekranowej, której żąda ona bezpośrednio.

Pokaż okno lub widok nakładki na klawiaturze programowej

Czasami działanie edytora może wymagać utworzenia pliku, którego nie można edytować. okno lub nakładkę na klawiaturę programową.

Aplikacja ma kilka opcji, które zostały opisane w sekcjach poniżej.

Podsumowując, sprawdź, czy poprawnie obsługujesz flagi okna klawiatury programowej. Kierując reklamy na okno w taki sposób, aby spełniał on poniższe oczekiwania dotyczące porządkowania pionowego (z-warstwa):

• Brak flag (wielkość literowa): za warstwą klawiatury ekranowej i możliwość odbierania tekstu.
• FLAG_NOT_FOCUSABLE : znajduje się nad warstwą klawiatury programowej, ale nie odbiera tekstu.
• FLAG_ALT_FOCUSABLE_IM : można zaznaczyć nad warstwą klawiatury programowej, ale nie jest połączony klawiatura programowa. Blokuje też wszystkie widoki pod nim, aby nie łączyły się z klawiatura programowa. Przydaje się to, gdy okno aplikacji nie zawiera tekstu wprowadzania tekstu nad warstwą klawiatury programowej.
• FLAG_NOT_FOCUSABLE i FLAG_ALT_FOCUSABLE_IM : za warstwą klawiatury programowej, ale nie można odbierać tekstu.
• FLAG_NOT_FOCUSABLE i FLAG_NOT_TOUCH_MODAL : jest umieszczony nad klawiaturą programową i umożliwia przełączanie zdarzeń dotknięcia okno na klawiaturę programową.

Utwórz okno

Korzystanie z FLAG_ALT_FOCUSABLE_IM flagę okna, aby umieścić okno nad klawiaturą programową oraz zapobiega utracie ostrości przez klawiaturę programową:

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

Utwórz widok nakładki

Utwórz widok nakładki określający TYPE_APPLICATION_OVERLAY typ okna i FLAG_ALT_FOCUSABLE_IM flaga okna przez aktywność ukierunkowaną na klawiaturę programową.

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

Pokaż okno lub widok pod klawiaturą programową

Być może aplikacja musi utworzyć okno lub okno z tych właściwości:

• Wyświetla się pod klawiaturą programową zażądaną przez działanie edytora aby nie wpływały na nią dane tekstowe.
• jest powiadamiany o zmianach rozmiaru wstawki klawiatury programowej na wartość dostosować układ okna lub okna.

W takim przypadku aplikacja ma kilka opcji. W poniższych sekcjach opisać te opcje.

Utwórz okno

Utwórz okno, ustawiając FLAG_NOT_FOCUSABLE flaga okna i FLAG_ALT_FOCUSABLE_IM flaga okna:

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

Utwórz widok nakładki

Utwórz widok nakładki, ustawiając FLAG_NOT_FOCUSABLE flaga okna i FLAG_ALT_FOCUSABLE_IM flaga okna:

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