studio - Android EditText, teclado suave mostrar/ocultar el evento?

mostrar teclado android studio

Question

¿Es posible detectar el evento de que Soft Keyboard se mostró u ocultó para EditText?

Answer 1

A muchos desarrolladores de Android les gusta modificar el diseño en función de si se muestra el teclado virtual o no. Para la solución, puede ver Android: Detectar el teclado abierto. Me funciona y creo que es muy útil también.

Answer 2

En mi caso, quería ocultar una barra inferior cuando se mostraba el teclado. Consideré que lo mejor era ocultar la barra cuando el diseño tenía menos del tamaño porcentual del tamaño de diseño normal. Así que utilicé esta solución que funciona bien teniendo en cuenta que el teclado blando usualmente toma 20% o más de altura de pantalla. Simplemente cambie el porcentaje constante por cualquier valor que pueda pensar que está bien. Necesita el atributo android: windowSoftInputMode = "adjustResize" en el manifiesto y el diseño debe ser la raíz para trabajar.

Extiende desde cualquier diseño que desees en lugar de RelativeLayout.

public class SoftKeyboardLsnedRelativeLayout extends RelativeLayout {
    private boolean isKeyboardShown = false;
    private List<SoftKeyboardLsner> lsners=new ArrayList<SoftKeyboardLsner>();
    private float layoutMaxH = 0f; // max measured height is considered layout normal size
    private static final float DETECT_ON_SIZE_PERCENT = 0.8f;

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

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

    @SuppressLint("NewApi")
    public SoftKeyboardLsnedRelativeLayout(Context context, AttributeSet attrs,
            int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        final int newH = MeasureSpec.getSize(heightMeasureSpec);
        if (newH > layoutMaxH) {
            layoutMaxH = newH;
        }
        if (layoutMaxH != 0f) {
            final float sizePercent = newH / layoutMaxH;
            if (!isKeyboardShown && sizePercent <= DETECT_ON_SIZE_PERCENT) {
                isKeyboardShown = true;
                for (final SoftKeyboardLsner lsner : lsners) {
                    lsner.onSoftKeyboardShow();
                }
            } else if (isKeyboardShown && sizePercent > DETECT_ON_SIZE_PERCENT) {
                isKeyboardShown = false;
                for (final SoftKeyboardLsner lsner : lsners) {
                    lsner.onSoftKeyboardHide();
                }
            }
        }
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

    public void addSoftKeyboardLsner(SoftKeyboardLsner lsner) {
        lsners.add(lsner);
    }

    public void removeSoftKeyboardLsner(SoftKeyboardLsner lsner) {
        lsners.remove(lsner);
    }

    // Callback
    public interface SoftKeyboardLsner {
        public void onSoftKeyboardShow();
        public void onSoftKeyboardHide();
    }
}

Ejemplo:

layout / my_layout.xml

<?xml version="1.0" encoding="utf-8"?>
<yourclasspackage.SoftKeyboardLsnedRelativeLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/myLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    ...
</yourclasspackage.SoftKeyboardLsnedRelativeLayout>

MyActivity.java

public class MyActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.my_layout);
        SoftKeyboardLsnedRelativeLayout layout = (SoftKeyboardLsnedRelativeLayout) findViewById(R.id.myLayout);
        layout.addSoftKeyboardLsner(new SoftKeyboardLsner() {
            @Override
            public void onSoftKeyboardShow() {
                Log.d("SoftKeyboard", "Soft keyboard shown");
            }

            @Override
            public void onSoftKeyboardHide() {
                Log.d("SoftKeyboard", "Soft keyboard hidden");
            }
        });
    }
}

Answer 3

En realidad, no hay tal evento que atrapar. El IME simplemente muestra y oculta su ventana; la retroalimentación que recibe de esto es el administrador de ventanas causando que el contenido de su propia ventana cambie de tamaño si lo ha puesto en modo de cambio de tamaño.

Answer 4

Hola, he usado la siguiente solución alternativa:

En cuanto a mi vista de contenido es una subclase de LinearLayout (podría ser cualquier otra vista o grupo de vista), anularía en el método de medición lilke siguiente:

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    final int proposedheight = MeasureSpec.getSize(heightMeasureSpec);
    final int actualHeight = getHeight();

    if (actualHeight > proposedheight){
        // Keyboard is shown
    } else {
        // Keyboard is hidden
    }

    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}

Esta solución me ayudó a ocultar algunos controles cuando se muestra el teclado y devolver lo contrario.

Espero que esto sea útil.

Answer 5

Pruebe estos métodos: showSoftInput(View, int, ResultReceiver) y hideSoftInputFromWindow(IBinder, int, ResultReceiver) . Puede anular el onReceiveResult(int resultCode, Bundle resultData) de la clase ResultReceiver para manejar el evento show / hide.

Answer 6

Puede capturar esto sobrescribiendo el método onConfigurationChanged de su actividad:

@Override
public void onConfigurationChanged(Configuration newConfig) {
   super.onConfigurationChanged(newConfig);

   if(newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_NO) {
      ((SherlockFragmentActivity)getActivity()).getSupportActionBar().hide();
   }
   else if(newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_YES){
      ((SherlockFragmentActivity)getActivity()).getSupportActionBar().show();
   }
}

Answer 7

Resolví este problema usando onGlobalLayoutListener:

 final View activityRootView = findViewById(R.id.top_root);
        activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
            public void onGlobalLayout() {
                int heightDiff = activityRootView.getRootView().getHeight() - activityRootView.getHeight();

                if (heightDiff > 100) {
                    // keyboard is up
                } else {
                    // keyboard is down
                }
            }
        });

Aquí activityRootView es la vista de raíz de tu actividad.