android - samsung - Obteniendo las dimensiones del teclado suave.

teclado para celular

Question

¿Hay alguna forma de saber el tamaño del teclado que se muestra en la pantalla?

Estoy usando Cocos2dx para la programación, pero quiero saber la altura del teclado que se muestra en la pantalla en la parte de Android o en la parte de Cocos, no importa.

Sé que el teclado tiene un método getHeight () pero no quiero crear nuevos teclados, quiero usar el predeterminado.

Answer 1

Después de horas de búsqueda, encontré una solución si desea configurar windowSoftInput="adjustPan"

Aquí está el fragmento de código:

    final View root  = findViewById(android.R.id.content);
    root.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
    Rect r = new Rect();
    {
        root.getWindowVisibleDisplayFrame(r);
    }
    @Override
    public void onGlobalLayout() {
        Rect r2 = new Rect();
        root.getWindowVisibleDisplayFrame(r2);
        int keyboardHeight = r.height() - r2.height();
        if (keyboardHeight > 100) {
            root.scrollTo(0, keyboardHeight);
        }
        else {
            root.scrollTo(0, 0);
        }
    }
});

En este código, después de encontrar la altura del teclado, desplazo la vista hasta que no está cubierta por el teclado, que es la razón principal para encontrar la altura del teclado.

Según los docs :

void getWindowVisibleDisplayFrame(Rect outRect) : recupera el tamaño de visualización visible general en el que se ha colocado la ventana a la que está conectada esta vista.

Answer 2

El ROOT_VIEW de una pantalla de visualización de Android se puede visualizar como una vista de pantalla única con VISIBLE DISPLAY FRAME, que muestra la vista de su actividad.

Este MARCO DE VISUALIZACIÓN VISIBLE se ajusta cuando SOFT KEYBOARD se muestra u oculta de la pantalla.

NOTA: Por favor, mire las dos imágenes haciendo clic en los enlaces que figuran a continuación para una mejor comprensión.

Por lo tanto, ROOT VIEW de una pantalla de visualización se puede visualizar como: RootView de la pantalla de visualización

El ajuste de VISIBLE DISPLAY FRAME con la apertura y el cierre de SOFT KEYBOARD se puede visualizar como: VISIBLE_DISPLAY_SCREEN ajuste

Este ajuste de VISUAL DISPLAY FRAME se puede utilizar muy bien para averiguar la altura del teclado como:

(cuando el teclado suave está abierto)

SOFT_KEYBOARD_HEIGHT = ROOT_VIEW_HEIGHT - (VISUAL_DISPLAY_FRAME_HEIGHT + EXTRA_SCREEN_HEIGHT)

El código para lograr lo anterior es:

int mExtraScreenHeight=-1, mKeyboardHeight=-1;
boolean mKeyboardOpen;



    rootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
        @Override
        public void onGlobalLayout() {

            int rootViewHeight, visibleDisplayFrameHeight, fakeHeight;

            /* (rootViewHeight - visibleDisplayFrameHeight) is not the real height of the keyboard
                it is the fake height as it also consist of extra screen height
                so FAKE_HEIGHT = KEYBOARD_HEIGHT + EXTRA_SCREEN_HEIGHT

                To get keyboard height extra screen height must be removed from fake height
             */

            Rect rect = new Rect();
            rootView.getWindowVisibleDisplayFrame(rect);

            rootViewHeight = rootView.getRootView().getHeight();
            visibleDisplayFrameHeight = rect.height();

            fakeHeight = rootViewHeight-visibleDisplayFrameHeight;

            if (mExtraScreenHeight == -1){
                mExtraScreenHeight=fakeHeight;
            }
            /* Suppose the soft keyboard is open then the VISIBLE_DISPLAY_FRAME is in reduced size
                due to the space taken up by extra screen and the keyboard but when the soft keyboard closes
                then KEYBOARD_HEIGHT=0 and thus FAKE_HEIGHT = EXTRA_SCREEN_HEIGHT
             */
            else if (fakeHeight <= mExtraScreenHeight){
                mExtraScreenHeight=fakeHeight;
                mKeypadOpen=false;
            }
            else if (fakeHeight > mExtraScreenHeight){
                mKeypadHeight=fakeHeight-mExtraScreenHeight;
                mKeypadOpen=true;
            }
        }
    });

NOTA : la función onGlobalLayout () solo se activará cuando cambie el diseño global, como cuando se abre el teclado virtual. Por lo tanto, el teclado virtual debe estar abierto al menos una vez para obtener la altura del teclado suave.

Funcionó para mí;)

Answer 3

En cocos2d-x tenemos CCEditBox.

Dentro de las extensiones-> GUI-> CCEditBox, puedes encontrar la clase CCEditBox.

La belleza es que oculta el teclado de tocar en otro lugar en la escena. y mueve automáticamente el teclado hacia arriba en caso de que su cuadro de edición se haya colocado demasiado bajo en la escena.

Si está utilizando cocos2d-x v2.1.3, puede navegar hasta el Proyecto de muestra yendo a

samples-> cpp-> TestCpp-> Classes-> ExtensionTest-> EditBoxTest.

Solo voy a usarlo en lugar de CCTextField de ahora en adelante. Acabo de encontrarlo ayer :)

Answer 4

Lo hicimos con esto.

myLayout.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {

                @Override
                public void onGlobalLayout() {

                    Rect r = new Rect();
                    parent.getWindowVisibleDisplayFrame(r);

                    int screenHeight = parent.getRootView().getHeight();
                    int heightDifference = screenHeight - (r.bottom - r.top);
                    Log.d("Keyboard Size", "Size: " + heightDifference);

                }
            });

Solo redimensionamos las vistas con el teclado, por lo que podríamos usar esto.

Answer 5

Lo siento por no poder comentar, dos o tres de las respuestas me ayudaron a resolver mi problema y estaban relacionadas con el uso del AddOnGlobalLayoutListener y luego la determinación de la altura restante antes y después de que apareciera un teclado.

La solución que utilicé se basó en la respuesta de Rudy_TM.

SIN EMBARGO, una cosa que tuve que encontrar fue que para que ese método funcione, debes tener la siguiente línea en algún lugar

Window.SetSoftInputMode(SoftInput.AdjustResize);

Antes tenía SoftInput.AdjustNothing (o algo así) y no funcionaba. Ahora funciona perfecto. Gracias por las respuestas!

Answer 6

No se puede decir No, en serio: simplemente no se puede decir.

El teclado no necesita tener ninguna forma particular. No es necesario colocarlo en la parte inferior de la pantalla ( many de las opciones más populares no lo son ), no tiene que mantener su tamaño actual cuando cambia los campos de texto (casi ninguno lo hace, dependiendo de las banderas). Ni siquiera tiene que ser rectangular . También puede hacerse cargo de toda la pantalla .

Answer 7

Respuesta completa y funcionó perfectamente para mí:

  Rect r = new Rect();
  View rootview = this.getWindow().getDecorView(); // this = activity
  rootview.getWindowVisibleDisplayFrame(r);
  int keyboardHeight = rootview.getHeight() - r.bottom;

Answer 8

Sé que este es un post antiguo, pero noté que la solución elegida para mí no funcionaba en todos los dispositivos. Parecía haber una discrepancia, así que implementé esto y parece ser una trampa para todos:

        final int[] discrepancy = new int[1];
        discrepancy[0] = 0;

        // this gets the height of the keyboard
        content.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {

            @Override
            public void onGlobalLayout() {
                Rect r = new Rect();
                View rootview = activity.getWindow().getDecorView(); // this = activity
                rootview.getWindowVisibleDisplayFrame(r);

                int screen_height = rootview.getRootView().getHeight();
                int keyboard_height = screen_height - (r.bottom + r.top) - discrepancy[0];

                if (discrepancy[0] == 0) {
                    discrepancy[0] = keyboard_height;
                    if (keyboard_height == 0) discrepancy[0] = 1;
                }

                int margin_bottom = keyboard_height + Helper.getDp(10, activity);

                RelativeLayout.LayoutParams params = (RelativeLayout.LayoutParams) carousel_container.getLayoutParams();
                params.setMargins(0, 0, 0, margin_bottom);

                //boolean visible = heightDiff > screenHeight / 3;
            }
        });

Cuando se llama por primera vez al oyente, mide la pantalla sin un teclado y si hay una discrepancia, la contesto la próxima vez. Si no hay discrepancia, establezco la discrepancia en 1 solo para que ya no sea 0.

Answer 9

Si desea calcular la altura del teclado virtual mientras su actividad no cambia de tamaño (ajuste de pantalla), puede usar esta muestra:

https://github.com/siebeprojects/samples-keyboardheight

Utiliza una ventana oculta para calcular la diferencia de altura entre la ventana y la vista raíz de la actividad.

Answer 10

Si su actividad no es de pantalla completa, utilice el siguiente código:

content.getViewTreeObserver().addOnGlobalLayoutListener(
            new ViewTreeObserver.OnGlobalLayoutListener() {

                @Override
                public void onGlobalLayout() {
                    // TODO Auto-generated method stub
                    if (keyBoardHeight <= 100) {
                        Rect r = new Rect();
                        content.getWindowVisibleDisplayFrame(r);

                        int screenHeight = content.getRootView()
                                .getHeight();
                        int heightDifference = screenHeight
                                - (r.bottom - r.top);
                        int resourceId = getResources()
                                .getIdentifier("status_bar_height",
                                        "dimen", "android");
                        if (resourceId > 0) {
                            heightDifference -= getResources()
                                    .getDimensionPixelSize(resourceId);
                        }
                        if (heightDifference > 100) {
                            keyBoardHeight = heightDifference;
                        }

                        Log.d("Keyboard Size", "Size: " + heightDifference);
                    }
                    // boolean visible = heightDiff > screenHeight / 3;
                }
            });

Answer 11

Rect r = new Rect();
View rootview = this.getWindow().getDecorView(); // this = activity
rootview.getWindowVisibleDisplayFrame(r);

El resultado de esto es la cantidad de espacio que usa su aplicación en la pantalla (funciona incluso cuando la actividad no se redimensiona). Obviamente, el espacio de pantalla restante será utilizado por el teclado (si está visible)

Encontré el identificador aquí: https://github.com/freshplanet/ANE-KeyboardSize/blob/master/android/src/com/freshplanet/ane/KeyboardSize/getKeyboardY.java