Intercept back button dalla tastiera soft

Ho l'attività con diversi campi di input. Quando viene triggersta la function tastiera morbida viene visualizzato. Quando il tasto indietro premere la tastiera soft chiude e per chiudere l'attività ho bisogno di premere di nuovo il button una volta ancora.

Quindi la domanda: è ansible intercettare il button di schiena per chiudere la tastiera morbida e completare l'attività in una sola pressione del button indietro senza creare Custom InputMethodService ?

  • Java.lang.ClassNotFoundException dopo l'aggiornamento dello studio Android
  • Android - unisce più immagini in un ImageView
  • Admob non ridimensiona correttamente l'orientamento dello schermo
  • Come get i dati delle voci di elenco in bindView quando fai clic su RadioButton in android?
  • Selezionare più file con Intent.ACTION_GET_CONTENT
  • Come posso impostare un tema diverso per un menu a discesa di Spinner?
  • PS So come intercettare il button di return in altri casi: onKeyDown() o onBackPressed() ma in questo caso non funziona: viene intercettata solo una seconda pressione del button di return.

    8 Solutions collect form web for “Intercept back button dalla tastiera soft”

    Sì, è completamente ansible mostrare e hide la tastiera e intercettare le chiamate al button indietro. È un piccolo sforzo supplementare, come è stato detto, che non esiste un modo diretto per farlo nell'API. La chiave è quella di ignorare la boolean dispatchKeyEventPreIme(KeyEvent) all'interno di un layout. Ciò che facciamo è creare il nostro layout. Ho scelto RelativeLayout perché era la base della mia attività.

     <?xml version="1.0" encoding="utf-8"?> <com.michaelhradek.superapp.utilities.SearchLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res/com.michaelhradek.superapp" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="@color/white"> 

    All'interno della nostra attività abbiamo impostato i nostri campi di input e chiamiamo la function setActivity(...) .

     private void initInputField() { mInputField = (EditText) findViewById(R.id.searchInput); InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY); mInputField.setOnEditorActionListener(new OnEditorActionListener() { @Override public boolean onEditorAction(TextView v, int actionId, KeyEvent event) { if (actionId == EditorInfo.IME_ACTION_SEARCH) { performSearch(); return true; } return false; } }); // Let the layout know we are going to be overriding the back button SearchLayout.setSearchActivity(this); } 

    Ovviamente, la function initInputField() imposta il field di input. Permette inoltre che il tasto enter esegua la funzionalità (nel mio caso una ricerca).

     @Override public void onBackPressed() { // It's expensive, if running turn it off. DataHelper.cancelSearch(); hideKeyboard(); super.onBackPressed(); } 

    Così quando l' onBackPressed() viene chiamato all'interno del nostro layout possiamo quindi fare quello che vogliamo come hide la tastiera:

     private void hideKeyboard() { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(mInputField.getWindowToken(), 0); } 

    Comunque, ecco il mio soprassalto del RelativeLayout.

     package com.michaelhradek.superapp.utilities; import android.app.Activity; import android.content.Context; import android.util.AttributeSet; import android.util.Log; import android.view.KeyEvent; import android.widget.RelativeLayout; /** * The root element in the search bar layout. This is a custom view just to * override the handling of the back button. * */ public class SearchLayout extends RelativeLayout { private static final String TAG = "SearchLayout"; private static Activity mSearchActivity;; public SearchLayout(Context context, AttributeSet attrs) { super(context, attrs); } public SearchLayout(Context context) { super(context); } public static void setSearchActivity(Activity searchActivity) { mSearchActivity = searchActivity; } /** * Overrides the handling of the back key to move back to the * previous sources or dismiss the search dialog, instead of * dismissing the input method. */ @Override public boolean dispatchKeyEventPreIme(KeyEvent event) { Log.d(TAG, "dispatchKeyEventPreIme(" + event + ")"); if (mSearchActivity != null && event.getKeyCode() == KeyEvent.KEYCODE_BACK) { KeyEvent.DispatcherState state = getKeyDispatcherState(); if (state != null) { if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) { state.startTracking(event, this); return true; } else if (event.getAction() == KeyEvent.ACTION_UP && !event.isCanceled() && state.isTracking(event)) { mSearchActivity.onBackPressed(); return true; } } } return super.dispatchKeyEventPreIme(event); } } 

    Purtroppo non posso prendere tutto il credito. Se controlli la sorgente Android per la casella Quick SearchDialog vedrai da where proveniva l'idea.

    OnKeyDown () e onBackPressed () non funzionano per questo caso. Devi usare onKeyPreIme .

    Inizialmente, è necessario creare text personalizzato di modifica che estende EditText. E poi è necessario implementare il metodo OnKeyPreIme che controlla KeyEvent.KEYCODE_BACK . Dopo di che, uno premere indietro abbastanza per risolvere il problema. Questa soluzione funziona perfettamente per me.

    CustomEditText.java

     public class CustomEditText extends EditText { Context context; public CustomEditText(Context context, AttributeSet attrs) { super(context, attrs); this.context = context; } @Override public boolean onKeyPreIme(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK) { // User has pressed Back key. So hide the keyboard InputMethodManager mgr = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE); mgr.hideSoftInputFromWindow(this.getWindowToken(), 0); // TODO: Hide your view as you do it in your activity } return false; } 

    Nel tuo XML

     <com.YOURAPP.CustomEditText android:id="@+id/CEditText" android:layout_height="wrap_content" android:layout_width="match_parent"/> 

    Nella tua attività

     public class MainActivity extends Activity { private CustomEditText editText; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); editText = (CustomEditText) findViewById(R.id.CEditText); } } 

    Ho scoperto che anche il metodo dispatchKeyEventPreIme della class Layout funziona bene. Basta impostare l'attività principale come un attributo e avviare un metodo predefinito.

     public class LinearLayoutGradient extends LinearLayout { MainActivity a; public void setMainActivity(MainActivity a) { this.a = a; } @Override public boolean dispatchKeyEventPreIme(KeyEvent event) { if (a != null) { InputMethodManager imm = (InputMethodManager) a .getSystemService(Context.INPUT_METHOD_SERVICE); if (imm.isActive() && event.getKeyCode() == KeyEvent.KEYCODE_BACK) { a.launchMethod; } } return super.dispatchKeyEventPreIme(event); } } 

    Ho avuto successo, superando dispatchKeyEvent :

     @Override public boolean dispatchKeyEvent(KeyEvent event) { if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) { finish(); return true; } return super.dispatchKeyEvent(event); } 

    Si nasconde la tastiera e termina l'attività.

    Come stai visualizzando la tastiera soft?

    Se si utilizza InputMethodManager.showSoftInput() , è ansible provare a passare in un ResultReceiver e implementare onReceiveResult() per gestire RESULT_HIDDEN

    http://developer.android.com/reference/android/view/inputmethod/InputMethodManager.html

    Ho avuto lo stesso problema, ma ho trovato l'intercettazione della chiave di return. Nel mio caso (HTC Desire, Android 2.2, Application Level API 4) chiude la tastiera e finisce immediatamente l'attività. Non so perché questo non dovrebbe funzionare anche per te:

     @Override public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK) { return true; } return super.onKeyDown(keyCode, event); } @Override public boolean onKeyUp(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK) { onBackPressed(); return true; } return super.onKeyUp(keyCode, event); } /** * Called when the activity has detected the user's press of the back key */ private void onBackPressed() { Log.e(TAG, "back pressed"); finish(); } 

    Utilizzare il metodo onKeyPreIme(int keyCode, KeyEvent event) e verificare KeyEvent.KEYCODE_BACK evento KeyEvent.KEYCODE_BACK . E 'molto semplice senza fare alcuna codifica fantasiosa.

    Prova questo codice nell'applicazione BackPressed ( Blocca button indietro in android ):

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

    Ti suggerisco di dare un'occhiata @ Chiudi / nascondi la tastiera Android Soft

    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.