Come mostrare la tastiera virtuale quando è focalizzato l'edittext

Voglio mostrare automaticamente la tastiera virtuale quando EditTextè focalizzata (se il dispositivo non ha una tastiera fisica) e ho due problemi:

1. Quando Activityviene visualizzato my, my EditTextè focalizzato ma la tastiera non è visualizzata, è necessario fare di nuovo clic su di essa per mostrare la tastiera (dovrebbe essere visualizzata quando Activityviene visualizzata my ).

2. E quando faccio clic su Fine sulla tastiera, la tastiera viene ignorata, ma EditTextrimane focalizzata e non voglio (perché la mia modifica è terminata ).

Per riprendere, il mio problema è avere qualcosa di più simile all'iPhone: che mantiene la tastiera sincronizzata con il mio EditTextstato (focalizzato / non focalizzato) e ovviamente non presenta una tastiera soft se ce n'è una fisica.

Per forzare la visualizzazione della tastiera virtuale, è possibile utilizzare

EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
yourEditText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);

E per rimuovere la messa a fuoco EditText, purtroppo devi avere un manichino Viewper afferrare la messa a fuoco.

spero che questo possa essere d'aiuto

Per chiuderlo puoi usare

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(yourEditText.getWindowToken(), 0);

Funziona per usarlo in una finestra di dialogo

public void showKeyboard(){
    InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}

public void closeKeyboard(){
    InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
}

Ho avuto lo stesso problema. Immediatamente dopo editText, la VISIBILITÀ cambia da GONE a VISIBLE, ho dovuto impostare la messa a fuoco e visualizzare la tastiera software. Ho raggiunto questo usando il seguente codice:

new Handler().postDelayed(new Runnable() {

    public void run() {
//        ((EditText) findViewById(R.id.et_find)).requestFocus();
//              
        EditText yourEditText= (EditText) findViewById(R.id.et_find);
//        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
//        imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);

        yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
        yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));                           
    }
}, 200);

Funziona per me con un ritardo di 100 ms, ma non è riuscito senza alcun ritardo o con solo un ritardo di 1 ms.

La parte commentata del codice mostra un altro approccio, che funziona solo su alcuni dispositivi. Ho testato su OS versioni 2.2 (emulatore), 2.2.1 (dispositivo reale) e 1.6 (emulatore).

Questo approccio mi ha risparmiato molto dolore.

Per far apparire la tastiera, usare

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);

Questo metodo è più affidabile rispetto al richiamo diretto di InputMethodManager.

Per chiuderlo, usa

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);

Quando nient'altro funziona, forzalo ad essere mostrato :

editText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);

E poi, se si desidera chiuderlo, ad esempio in onPause (), è possibile chiamare:

InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);

Il seguente codice viene rubato dal codice sorgente 4.1 di Google per SearchView. Sembra funzionare, anche su versioni minori di Android.

private Runnable mShowImeRunnable = new Runnable() {
    public void run() {
        InputMethodManager imm = (InputMethodManager) getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        if (imm != null) {
            imm.showSoftInput(editText, 0);
        }
    }
};

private void setImeVisibility(final boolean visible) {
    if (visible) {
        post(mShowImeRunnable);
    } else {
        removeCallbacks(mShowImeRunnable);
        InputMethodManager imm = (InputMethodManager) getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        if (imm != null) {
            imm.hideSoftInputFromWindow(getWindowToken(), 0);
        }
    }
}

Inoltre, è necessario aggiungere il seguente codice quando viene creato il controllo / attività. (Nel mio caso è un controllo composito, piuttosto che un'attività).

this.editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    public void onFocusChange(View v, boolean hasFocus) {
        setImeVisibility(hasFocus);
    }
});

android:windowSoftInputMode="stateAlwaysVisible" -> nel file manifest.

edittext.requestFocus(); -> nel codice.

Si aprirà la tastiera virtuale su cui il testo di modifica ha lo stato attivo richiesto mentre viene visualizzata l'attività.

Ho avuto un po 'di fortuna in alcuni casi semplici con il codice qui sotto. Non ho finito tutti i test ma ...

EditText input = (EditText) findViewById(R.id.Input);
input.requestFocus();    
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));

E presto la tastiera si presenta.

Puoi provare a forzare la visualizzazione della tastiera virtuale, funziona per me:

...
dialog.show();
input.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

A volte la risposta di raukodraug non funziona. L'ho fatto in questo modo con alcune prove ed errori:

public static void showKeyboard(Activity activity) {
    if (activity != null) {
        activity.getWindow()
                .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
    }
}

public static void hideKeyboard(Activity activity) {
    if (activity != null) {
        activity.getWindow()
                .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
    }
}

E la parte EditText :

    editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            if (!hasFocus) {
                hideKeyboard(getActivity());
            } else {
                showKeyboard(getActivity());
            }
        }
    });

Per nascondere la tastiera, usa questa:

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

e per mostrare la tastiera:

getActivity().getWindow().setSoftInputMode(
    WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

E per Kotlin basta usare queste estensioni:

fun EditText.showKeyboard() {
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
}

fun EditText.hideKeyboard() {
    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.hideSoftInputFromWindow(this.windowToken, 0)
}

Per frammento, assicurati che funzioni:

 displayName = (EditText) view.findViewById(R.id.displayName);
    InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

showSoftInput non funzionava affatto per me.

Ho pensato di dover impostare la modalità di input: (qui nel componente Activity nel manifest)

android:windowSoftInputMode="stateVisible" 

Credere o no che il mio problema con la tastiera virtuale sia stato risolto quando ho scoperto che le animazioni delle attività possono disabilitare la tastiera virtuale. Quando chiami l'intento con il

i.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);

e

overridePendingTransition(0, 0);

Può nascondere la tastiera virtuale e non esiste un modo per mostrarla.

Ho avuto lo stesso problema in varie situazioni diverse e le soluzioni che ho trovato funzionano in alcuni ma non funzionano in altri, quindi ecco una soluzione combinata che funziona nella maggior parte delle situazioni che ho trovato:

public static void showVirtualKeyboard(Context context, final View view) {
    if (context != null) {
        final InputMethodManager imm =  (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        view.clearFocus();

        if(view.isShown()) {
            imm.showSoftInput(view, 0);
            view.requestFocus();
        } else {
            view.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() {
                @Override
                public void onViewAttachedToWindow(View v) {
                    view.post(new Runnable() {
                        @Override
                        public void run() {
                            view.requestFocus();
                            imm.showSoftInput(view, 0);
                        }
                    });

                    view.removeOnAttachStateChangeListener(this);
                }

                @Override
                public void onViewDetachedFromWindow(View v) {
                    view.removeOnAttachStateChangeListener(this);
                }
            });
        }
    }
}

editText.post(new Runnable() {
    @Override
    public void run() {
        InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
    }
});

Ho combinato tutto qui e per me funziona:

public static void showKeyboardWithFocus(View v, Activity a) {
    try {
        v.requestFocus();
        InputMethodManager imm = (InputMethodManager) a.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
        a.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Ha funzionato per me. Puoi provare anche con questo per mostrare la tastiera:

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);

snippet di codice. . .

public void hideKeyboard(Context activityContext){

    InputMethodManager imm = (InputMethodManager)
            activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);

    //android.R.id.content ( http://stackoverflow.com/a/12887919/2077479 )
    View rootView = ((Activity) activityContext)
            .findViewById(android.R.id.content).getRootView();

    imm.hideSoftInputFromWindow(rootView.getWindowToken(), 0);
}

public void showKeyboard(Context activityContext, final EditText editText){

    final InputMethodManager imm = (InputMethodManager)
            activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);

    if (!editText.hasFocus()) {
        editText.requestFocus();
    }

    editText.post(new Runnable() {
        @Override
        public void run() {
            imm.showSoftInput(editText, InputMethodManager.SHOW_FORCED);
        }
    });
}

Kotlin estensione per mostrare la tastiera a fuoco.

Questa è una combinazione di risposte precedenti, che erano troppo lunghe o incomplete.

Questa estensione pubblica un file eseguibile nella coda messaggi che mostra la tastiera virtuale dopo aver richiesto lo stato attivo:

fun View.showSoftKeyboard() {
    post {
        if (this.requestFocus()) {
            val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
            imm?.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
        }
    }
}

Chiamalo da qualsiasi vista quando necessario in seguito:

editText.showSoftKeyboard()

basta aggiungere android: windowSoftInputMode = "stateHidden" nel file manifest ...

final InputMethodManager keyboard = (InputMethodManager) ctx.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

All'interno del tuo manifest:

android:windowSoftInputMode="stateAlwaysVisible"- tastiera inizialmente lanciata. android:windowSoftInputMode="stateAlwaysHidden" - tastiera inizialmente nascosta.

Mi piace usare anche "adjustPan"perché all'avvio della tastiera lo schermo si regola automaticamente.

 <activity
      android:name="YourActivity"
      android:windowSoftInputMode="stateAlwaysHidden|adjustPan"/>

Aggiungi semplicemente questa riga nella vista Modifica testo:

android:isScrollContainer="true"

e TADA - la tastiera ha iniziato ad apparire automaticamente!

Ho avuto un problema simile e ho scoperto questa soluzione semplice e strana.

Come già accennato qui da user3392439, l'aspetto della tastiera su focus in qualche modo collegato in modo stranamente con la presenza del componente di scorrimento nel file XML.

Anche la presenza di un'altra vista EditText che comprende la linea sopra menzionata nello stesso XML fa apparire la tastiera indipendentemente da quale di EditTexts sia attualmente focalizzato.

Se hai almeno una vista visibile che comprende il componente di scorrimento nel tuo file XML, la tastiera apparirà automaticamente messa a fuoco.

Se non è presente lo scorrimento, è necessario fare clic su Modifica testo per visualizzare la tastiera.

Tutte le soluzioni fornite sopra ( interazione InputMethodManager in OnFocusChangeListener.onFocusChange listener collegato a EditText funziona perfettamente se si dispone di una modifica singola nell'attività.

Nel mio caso ho due modifiche.

 private EditText tvX, tvY;
 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
 tvX.setOnFocusChangeListener(this);
    tvY.setOnFocusChangeListener(this);

@Override
public void onFocusChange(View v, boolean hasFocus) {       
    InputMethodManager imm =  (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if(tvX.hasFocus() || tvY.hasFocus()) {            
        imm.showSoftInput(v, 0);            
    } else {
        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);         
    }       
};

Ho osservato che onFocusChange è attivato per tvX con hasFocus = true (tastiera mostrata) ma poi per tvY con hasFocus = true (tastiera nascosta). Alla fine, nessuna tastiera era visibile.

La soluzione generale dovrebbe avere un'istruzione corretta se "mostra tastiera se il testo EditText ha lo stato attivo"

Nella sezione onResume () dell'attività puoi chiamare il metodo bringKeyboard ();

 onResume() {
     EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
     bringKeyboard(yourEditText);
 }


  protected boolean bringKeyboard(EditText view) {
    if (view == null) {
        return false;
    }
    try {
      // Depending if edittext has some pre-filled values you can decide whether to bring up soft keyboard or not
        String value = view.getText().toString();
        if (value == null) {
            InputMethodManager imm = (InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
            return true;
        }
    } catch (Exception e) {
        Log.e(TAG, "decideFocus. Exception", e);
    }
    return false;
  }

Nessuna delle risposte ha funzionato per me. Ecco un modo semplice.

searchEditText.setVisibility(View.VISIBLE);
                final Handler handler=new Handler();
                handler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        searchEditText.requestFocus();
                    }
                }, 400);

Ho appena ritardato il metodo requestFocus () per 400ms.

Ho scoperto un comportamento strano, dal momento che in una delle mie app, la tastiera virtuale stava mostrando automaticamente quando si entrava nell'attività (c'è un editText.requestFocus () in onCreate).

Scavando ulteriormente, ho scoperto che questo era perché c'è un ScrollView attorno al layout. Se rimuovo ScrollView, il comportamento è come descritto nella dichiarazione del problema originale: solo facendo clic sul editText già focalizzato viene visualizzata la tastiera software.

Se non funziona per te, prova a inserire uno ScrollView - è comunque innocuo.

Ho avuto un problema simile usando le animazioni di visualizzazione . Quindi ho messo un ascoltatore di animazioni per assicurarmi di aspettare che finisse l'animazione prima di provare a richiedere un accesso da tastiera sul edittext mostrato.

    bottomUp.setAnimationListener(new Animation.AnimationListener() {
        @Override
        public void onAnimationStart(Animation animation) {
        }

        @Override
        public void onAnimationEnd(Animation animation) {
            if (textToFocus != null) {
                // Position cursor at the end of the text
                textToFocus.setSelection(textToFocus.getText().length());
                // Show keyboard
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.showSoftInput(textToFocus, InputMethodManager.SHOW_IMPLICIT);
            }
        }

        @Override
        public void onAnimationRepeat(Animation animation) {
        }
    });

Sono d'accordo con raukodraug per l'utilizzo in uno swithview è necessario richiedere / cancellare lo stato attivo in questo modo:

    final ViewSwitcher viewSwitcher = (ViewSwitcher) findViewById(R.id.viewSwitcher);
    final View btn = viewSwitcher.findViewById(R.id.address_btn);
    final View title = viewSwitcher.findViewById(R.id.address_value);

    title.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            viewSwitcher.showPrevious();
            btn.requestFocus();
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.showSoftInput(btn, InputMethodManager.SHOW_IMPLICIT);
        }
    });

    // EditText affiche le titre evenement click
    btn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            btn.clearFocus();
            viewSwitcher.showNext();
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(btn.getWindowToken(), 0);
            // Enregistre l'adresse.
            addAddress(view);
        }
    });

Saluti.