Erkennen, wann der Benutzer die Softtastatur geschlossen hat

Ich habe ein EditText-Widget in meiner Ansicht. Wenn der Benutzer das EditText-Widget auswählt, werden einige Anweisungen angezeigt und die Softtastatur wird angezeigt.

Ich verwende einen OnEditorActionListener, um zu erkennen, wann der Benutzer die Texteingabe abgeschlossen hat, und ich entlasse die Tastatur, verstecke die Anweisungen und führe eine Aktion aus.

Mein Problem ist, wenn der Benutzer die Tastatur durch Drücken der Taste ZURÜCK schließt. Das Betriebssystem schließt die Tastatur, aber meine Anweisungen (die ich ausblenden muss) sind immer noch sichtbar.

Ich habe versucht, OnKeyDown zu überschreiben, aber das scheint nicht aufgerufen zu werden, wenn die Taste BACK zum Schließen der Tastatur verwendet wird.

Ich habe versucht, einen OnKeyListener im EditText-Widget festzulegen, aber das scheint auch nicht aufgerufen zu werden.

Wie kann ich erkennen, wann die Softtastatur geschlossen wird?

Ich kenne einen Weg, dies zu tun. Unterklasse den EditText und implementiere:

@Override
public boolean onKeyPreIme(int keyCode, KeyEvent event) {
  if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
    // Do your thing.
    return true;  // So it is not propagated.
  }
  return super.dispatchKeyEvent(event);
}

Hier ist ein Link zur Verwendung Ihrer benutzerdefinierten Ansichten (für die Unterklasse EditText): http://developer.android.com/guide/topics/ui/custom-components.html

Jay, deine Lösung ist gut! Vielen Dank :)

public class EditTextBackEvent extends EditText {

    private EditTextImeBackListener mOnImeBack;

    public EditTextBackEvent(Context context) {
        super(context);
    }

    public EditTextBackEvent(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public EditTextBackEvent(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    public boolean onKeyPreIme(int keyCode, KeyEvent event) {
        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK && 
            event.getAction() == KeyEvent.ACTION_UP) {
            if (mOnImeBack != null) 
                mOnImeBack.onImeBack(this, this.getText().toString());
        }
        return super.dispatchKeyEvent(event);
    }

    public void setOnEditTextImeBackListener(EditTextImeBackListener listener) {
        mOnImeBack = listener;
    }

}

public interface EditTextImeBackListener {
    public abstract void onImeBack(EditTextBackEvent ctrl, String text);
}

Ich habe Jays Lösung leicht geändert, indem ich super.onKeyPreIme () aufgerufen habe:

_e = new EditText(inflater.getContext()) {
@Override
public boolean onKeyPreIme(int keyCode, KeyEvent event) {
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK){
            cancelTextInput();
        }
        return super.onKeyPreIme(keyCode, event);
    }
};

Wunderbare Lösung, Jay, +1!

Hier ist mein benutzerdefinierter EditText, um festzustellen, ob die Tastatur angezeigt wird oder nicht

/**
 * Created by TheFinestArtist on 9/24/15.
 */
public class KeyboardEditText extends EditText {

    public KeyboardEditText(Context context) {
        super(context);
    }

    public KeyboardEditText(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public KeyboardEditText(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
        super.onFocusChanged(focused, direction, previouslyFocusedRect);
        if (listener != null)
            listener.onStateChanged(this, true);
    }

    @Override
    public boolean onKeyPreIme(int keyCode, @NonNull KeyEvent event) {
        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK
                && event.getAction() == KeyEvent.ACTION_UP) {
            if (listener != null)
                listener.onStateChanged(this, false);
        }
        return super.onKeyPreIme(keyCode, event);
    }

    /**
     * Keyboard Listener
     */
    KeyboardListener listener;

    public void setOnKeyboardListener(KeyboardListener listener) {
        this.listener = listener;
    }

    public interface KeyboardListener {
        void onStateChanged(KeyboardEditText keyboardEditText, boolean showing);
    }
}

Es ist jetzt 2019 ...
Also habe ich mit Kotlin eine ordentlichere Lösung geschaffen

1.Erstellen Sie eine Erweiterungsfunktion:

fun Activity.addKeyboardToggleListener(onKeyboardToggleAction: (shown: Boolean) -> Unit): KeyboardToggleListener? {
    val root = findViewById<View>(android.R.id.content)
    val listener = KeyboardToggleListener(root, onKeyboardToggleAction)
    return root?.viewTreeObserver?.run {
        addOnGlobalLayoutListener(listener)
        listener
    }
}

2.Wo sich der Toggle-Listener befindet:

open class KeyboardToggleListener(
        private val root: View?,
        private val onKeyboardToggleAction: (shown: Boolean) -> Unit
) : ViewTreeObserver.OnGlobalLayoutListener {
    private var shown = false
    override fun onGlobalLayout() {
        root?.run {
            val heightDiff = rootView.height - height
            val keyboardShown = heightDiff > dpToPx(200f)
            if (shown != keyboardShown) {
                onKeyboardToggleAction.invoke(keyboardShown)
                shown = keyboardShown
            }
        }
    }
}

fun View.dpToPx(dp: Float) = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, resources.displayMetrics).roundToInt()

3. Verwenden Sie es in einer so einfachen Aktivität :

addKeyboardToggleListener {shown ->
          // hurray! Now you know when the keyboard is shown and hidden!!
      }

Erstellen Sie einfach eine Klasse, die Edittext erweitert, und verwenden Sie diesen Edittext in Ihrem Code. Sie sollten lediglich die folgende Methode im benutzerdefinierten Edittext überschreiben:

@Override
 public boolean onKeyPreIme(int keyCode, KeyEvent event) {
 if (keyCode == KeyEvent.KEYCODE_BACK) {

    //Here it catch all back keys
    //Now you can do what you want.

} else if (keyCode == KeyEvent.KEYCODE_MENU) {
    // Eat the event
    return true;
}
return false;}

Hier ist eine Lösung mit dem Key Listener. Ich habe keine Ahnung, warum dies funktioniert, aber OnKeyListener funktioniert, wenn Sie onKeyPreIme in Ihrem benutzerdefinierten EditText nur überschreiben.

SomeClass.java

customEditText.setOnKeyListener((v, keyCode, event) -> {
            if(event.getAction() == KeyEvent.ACTION_DOWN) {
                switch (keyCode) {
                    case KeyEvent.KEYCODE_BACK:
                        getPresenter().onBackPressed();
                        break;
                }
            }
            return false;
        }); 

CustomEditText.java

@Override
    public boolean onKeyPreIme(int keyCode, KeyEvent event) {
        return super.dispatchKeyEvent(event);
    }

Mit der Antwort von @ olivier_sdg, aber konvertiert nach Kotlin:

class KeyboardEditText : AppCompatEditText {

    var listener: Listener? = null
  
    constructor(context: Context) : super(context)
    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)
    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr)
  
    override fun onKeyPreIme(keyCode: Int, event: KeyEvent): Boolean {
        if (event.keyCode == KeyEvent.KEYCODE_BACK && event.action == KeyEvent.ACTION_UP) {
            listener?.onImeBack(this)
        }
        return super.dispatchKeyEvent(event)
    }
  
    interface Listener {
        fun onImeBack(editText: KeyboardEditText)
    }

}

Verwendung:

keyboardEditText.listener = object : KeyboardEditText.Listener {
    override fun onImeBack(editText: KeyboardEditText) {
        //Back detected
    }
}

Für alle, die dasselbe in Xamarin tun möchten, habe ich einige der wichtigsten Antworten übersetzt, da es etwas anders ist. Ich habe hier einen Kern erstellt , aber zusammenfassend erstellen Sie einen benutzerdefinierten EditText und überschreiben ihn OnKeyPreImewie folgt :

public class CustomEditText : EditText
{
    public event EventHandler BackPressed;

    // ...

    public override bool OnKeyPreIme([GeneratedEnum] Keycode keyCode, KeyEvent e)
    {
        if (e.KeyCode == Keycode.Back && e.Action == KeyEventActions.Up)
        {
            BackPressed?.Invoke(this, new EventArgs());
        }

        return base.OnKeyPreIme(keyCode, e);
    }
}

... und dann in der Ansicht ...

editText = FindViewById<CustomEditText>(Resource.Id.MyEditText);
editText.BackPressed += (s, e) => 
{
    // <insert code here>
};

hideSoftInputFromWindow Gibt true zurück, wenn die Tastatur geschlossen wird. Verwenden Sie den Wert, um das Schließen der Tastatur in Android zu erkennen

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

        if (imm.hideSoftInputFromWindow(findFocus().getWindowToken(),
                InputMethodManager.HIDE_NOT_ALWAYS)) {
            //keyboard is closed now do what you need here
        }