android-layout hide soft - Chiudi / nascondi la tastiera virtuale di Android




15 Answers

Puoi forzare Android a nascondere la tastiera virtuale utilizzando InputMethodManager , chiamando hideSoftInputFromWindow , passando il token della finestra che contiene la tua vista focalizzata.

// Check if no view has focus:
View view = this.getCurrentFocus();
if (view != null) {  
    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

Ciò costringerà la tastiera a essere nascosta in tutte le situazioni. In alcuni casi si vorrà passare in InputMethodManager.HIDE_IMPLICIT_ONLY come secondo parametro per assicurarsi di nascondere solo la tastiera quando l'utente non ha forzato esplicitamente la visualizzazione (tenendo premuto il menu).

Nota: se vuoi farlo in Kotlin, usa: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

keyboard fragment check

Ho un EditText e un Button nel mio layout.

Dopo aver scritto nel campo di modifica e facendo clic sul Button , voglio nascondere la tastiera virtuale. Presumo che questo è un semplice pezzo di codice, ma dove posso trovare un esempio di esso?




Ho un'altra soluzione per nascondere la tastiera:

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);

Qui passa HIDE_IMPLICIT_ONLY nella posizione di showFlag e 0 nella posizione di hiddenFlag . Chiuderà forzatamente la tastiera morbida.




Si prega di provare questo codice qui sotto in onCreate()

EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);



protected void hideSoftKeyboard(EditText input) {
    input.setInputType(0);
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}



Saurabh Pareek ha la migliore risposta finora.

Potrebbe anche usare le bandiere corrette, però.

/* hide keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
    .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

/* show keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
    .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);

Esempio di uso reale

/* click button */
public void onClick(View view) {      
  /* hide keyboard */
  ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
      .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

  /* start loader to check parameters ... */
}

/* loader finished */
public void onLoadFinished(Loader<Object> loader, Object data) {
    /* parameters not valid ... */

    /* show keyboard */
    ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
        .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);

    /* parameters valid ... */
}



La risposta breve

Nel listener di OnClick chiama onEditorAction di EditText con IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

    @Override
    public void onClick(View v) {
        someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE)
    }
});

Il drill-down

Ritengo che questo metodo sia migliore, più semplice e più allineato con il modello di progettazione di Android. Nel semplice esempio sopra (e di solito nella maggior parte dei casi comuni) avrete un EditText che ha / ha avuto il focus e di solito è stato anche quello a invocare la tastiera in primo luogo (è sicuramente in grado di invocarlo in molti scenari comuni). Allo stesso modo, dovrebbe essere quello di rilasciare la tastiera, di solito ciò può essere fatto da un ImeAction . android:imeOptions="actionDone" come funziona EditText con android:imeOptions="actionDone" , vuoi ottenere lo stesso comportamento con lo stesso metodo.

Controlla questa risposta correlata




Sto usando una tastiera personalizzata per inserire un numero esadecimale in modo da non far visualizzare la tastiera IMM ...

In v3.2.4_r1 setSoftInputShownOnFocus(boolean show) stato aggiunto per controllare il meteo o non per visualizzare la tastiera quando un TextView ottiene il focus, ma è ancora nascosto in modo che il riflesso debba essere usato:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    try {
        Method method = TextView.class.getMethod("setSoftInputShownOnFocus", boolean.class);
        method.invoke(mEditText, false);
    } catch (Exception e) {
        // Fallback to the second method
    }
}

Per le versioni precedenti, ho ottenuto risultati molto buoni (ma tutt'altro che perfetti) con un OnGlobalLayoutListener , aggiunto con l'aiuto di un ViewTreeObserver dalla mia vista root e quindi controllando se la tastiera è mostrata in questo modo:

@Override
public void onGlobalLayout() {
    Configuration config = getResources().getConfiguration();

    // Dont allow the default keyboard to show up
    if (config.keyboardHidden != Configuration.KEYBOARDHIDDEN_YES) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(mRootView.getWindowToken(), 0);
    }
}

Quest'ultima soluzione potrebbe mostrare la tastiera per una frazione di secondo e creare problemi con le maniglie di selezione.

Quando nella tastiera viene visualizzato a schermo intero, onGlobalLayout non viene chiamato. Per evitare ciò, utilizzare TextView#setImeOptions(int) o nella dichiarazione XML di TextView:

android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi"

Aggiornamento: trova solo le finestre di dialogo da utilizzare per non mostrare mai la tastiera e funziona in tutte le versioni:

getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
        WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);



Ho passato più di due giorni a lavorare su tutte le soluzioni pubblicate nel thread e le ho trovate carenti in un modo o nell'altro. Il mio esatto requisito è quello di avere un pulsante che con affidabilità al 100% mostri o nascondi la tastiera su schermo. Quando la tastiera è nascosta, non dovrebbe essere visualizzata nuovamente, indipendentemente dai campi di input su cui l'utente fa clic. Quando è nel suo stato visibile, la tastiera non dovrebbe scomparire indipendentemente da quali pulsanti l'utente fa clic. Questo deve funzionare su Android 2.2+ fino ai dispositivi più recenti.

Puoi vedere un'implementazione funzionante di questo nella mia RPN pulita dell'app.

Dopo aver testato molte delle risposte suggerite su un numero di telefoni diversi (inclusi i dispositivi Froyo e Gingerbread), è apparso evidente che le app Android possono essere affidabili:

  1. Nascondi temporaneamente la tastiera. Riapparirà di nuovo quando un utente mette a fuoco un nuovo campo di testo.
  2. Mostra la tastiera all'avvio di un'attività e imposta un flag sull'attività per indicare che la tastiera deve essere sempre visibile. Questo flag può essere impostato solo quando un'iniziativa viene inizializzata.
  3. Contrassegna un'attività per non mostrare mai o consentire l'uso della tastiera. Questo flag può essere impostato solo quando un'iniziativa viene inizializzata.

Per me, nascondere temporaneamente la tastiera non è abbastanza. Su alcuni dispositivi riapparirà non appena viene messo a fuoco un nuovo campo di testo. Poiché la mia app utilizza più campi di testo su una pagina, la messa a fuoco di un nuovo campo di testo farà sì che la tastiera nascosta ritorni di nuovo in posizione.

Sfortunatamente gli articoli 2 e 3 sulla lista funzionano solo quando si avvia un'attività. Una volta che l'attività è diventata visibile, non è possibile nascondere o mostrare la tastiera in modo permanente. Il trucco è di riavviare effettivamente la tua attività quando l'utente preme il pulsante di attivazione / disattivazione della tastiera. Nella mia app quando l'utente preme il pulsante di attivazione / disattivazione della tastiera, viene eseguito il seguente codice:

private void toggleKeyboard(){

    if(keypadPager.getVisibility() == View.VISIBLE){
        Intent i = new Intent(this, MainActivity.class);
        i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
        Bundle state = new Bundle();
        onSaveInstanceState(state);
        state.putBoolean(SHOW_KEYBOARD, true);
        i.putExtras(state);

        startActivity(i);
    }
    else{
        Intent i = new Intent(this, MainActivity.class);
        i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
        Bundle state = new Bundle();
        onSaveInstanceState(state);
        state.putBoolean(SHOW_KEYBOARD, false);
        i.putExtras(state);

        startActivity(i);
    }
}

Ciò fa sì che l'attività corrente abbia il suo stato salvato in un pacchetto, e quindi l'attività viene avviata, passando attraverso un valore booleano che indica se la tastiera deve essere mostrata o nascosta.

All'interno del metodo onCreate viene eseguito il seguente codice:

if(bundle.getBoolean(SHOW_KEYBOARD)){
    ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(newEquationText,0);
    getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
}
else{
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
            WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
}

Se è necessario visualizzare la tastiera software, viene chiesto a InputMethodManager di mostrare la tastiera e la finestra viene istruita per rendere sempre visibile l'ingresso software. Se la tastiera virtuale deve essere nascosta, viene impostato WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM.

Questo approccio funziona in modo affidabile su tutti i dispositivi su cui ho provato: da un telefono HTC di 4 anni con Android 2.2 fino a un nexus 7 con 4.2.2. L'unico svantaggio di questo approccio è che devi stare attento con la gestione del pulsante Indietro. Poiché la mia app ha essenzialmente solo uno schermo (è una calcolatrice), posso eseguire l'override suBackPressed () e tornare alla schermata iniziale dei dispositivi.




Grazie a questa risposta SO , ho ricavato il seguente che, nel mio caso, funziona bene quando si scorrono i frammenti di un ViewPager ...

private void hideKeyboard() {   
    // Check if no view has focus:
    View view = this.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

private void showKeyboard() {   
    // Check if no view has focus:
    View view = this.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
    }
}



Se si desidera chiudere la tastiera a sfioramento durante un'unità o un test funzionale, è possibile farlo facendo clic sul pulsante "indietro" del test:

// Close the soft keyboard from a Test
getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);

Inserisco il "pulsante indietro" tra virgolette, poiché quanto sopra non attiva onBackPressed()l'attività in questione. Chiude semplicemente la tastiera.

Assicurati di fermarti un attimo prima di proseguire, poiché richiede un po 'di tempo per chiudere il pulsante Indietro, quindi i clic successivi su Views, ecc., Non saranno registrati fino a dopo una breve pausa (1 secondo è abbastanza lungo ).




Questo ha funzionato per me per tutto il comportamento bizzarro della tastiera

private boolean isKeyboardVisible() {
    Rect r = new Rect();
    //r will be populated with the coordinates of your view that area still visible.
    mRootView.getWindowVisibleDisplayFrame(r);

    int heightDiff = mRootView.getRootView().getHeight() - (r.bottom - r.top);
    return heightDiff > 100; // if more than 100 pixels, its probably a keyboard...
}

protected void showKeyboard() {
    if (isKeyboardVisible())
        return;
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if (getCurrentFocus() == null) {
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    } else {
        View view = getCurrentFocus();
        inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_FORCED);
    }
}

protected void hideKeyboard() {
    if (!isKeyboardVisible())
        return;
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View view = getCurrentFocus();
    if (view == null) {
        if (inputMethodManager.isAcceptingText())
            inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_NOT_ALWAYS, 0);
    } else {
        if (view instanceof EditText)
            ((EditText) view).setText(((EditText) view).getText().toString()); // reset edit text bug on some keyboards bug
        inputMethodManager.hideSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}



Usa questo

this.getWindow().setSoftInputMode(
            WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);



Ho quasi provato tutte queste risposte, ho avuto alcuni problemi casuali in particolare con la samsung galaxy s5.

Quello che finisco è forzare lo spettacolo e nasconderlo, e funziona perfettamente:

/**
 * Force show softKeyboard.
 */
public static void forceShow(@NonNull Context context) {
    InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}

/**
 * Force hide softKeyboard.
 */
public static void forceHide(@NonNull Activity activity, @NonNull EditText editText) {
    if (activity.getCurrentFocus() == null || !(activity.getCurrentFocus() instanceof EditText)) {
        editText.requestFocus();
    }
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
    activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
}



Metodo semplice e facile da usare, basta chiamare hideKeyboardFrom (YourActivity.questo); per nascondere la tastiera

/**
 * This method is used to hide keyboard
 * @param activity
 */
public static void hideKeyboardFrom(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}



Ho il caso, in cui il mio EditTextpuò essere posizionato anche in un AlertDialog, quindi la tastiera dovrebbe essere chiusa al licenziamento. Il seguente codice sembra funzionare ovunque:

public static void hideKeyboard( Activity activity ) {
    InputMethodManager imm = (InputMethodManager)activity.getSystemService( Context.INPUT_METHOD_SERVICE );
    View f = activity.getCurrentFocus();
    if( null != f && null != f.getWindowToken() && EditText.class.isAssignableFrom( f.getClass() ) )
        imm.hideSoftInputFromWindow( f.getWindowToken(), 0 );
    else 
        activity.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN );
}



Related