web-dev-qa-db-fra.com

Obtenir les dimensions du clavier logiciel

Existe-t-il un moyen de connaître la taille du clavier affichée à l'écran?

J'utilise Cocos2dx pour la programmation, mais je veux connaître la hauteur du clavier affiché à l'écran dans la partie d'Android ou de Cocos, peu importe.

Je sais que Keyboard a une méthode getHeight () mais je ne veux pas créer de nouveaux claviers, je veux utiliser la valeur par défaut.

androidkeyboardcocos2d-x
25
Rudy_TM

On l'a fait avec ça

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);

                }
            });

Nous ne redimensionnons les vues avec le clavier, nous pourrions donc utiliser ceci. 

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

Le résultat en est la quantité d'espace utilisée par votre application à l'écran (fonctionne même lorsque l'activité est pas redimensionnée). Évidemment, l'espace restant sur l'écran sera utilisé par le clavier (s'il est visible)

Identifiant trouvé ici: https://github.com/freshplanet/ANE-KeyboardSize/blob/master/Android/src/com/freshplanet/ane/KeyboardSize/getKeyboardY.Java

20
FDIM

si votre activité n'est pas en plein écran, utilisez le code ci-dessous:

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;
                }
            });
9
Habbot Phan

Si vous souhaitez calculer la hauteur du clavier virtuel alors que votre activité ne change pas de taille (adjustPan), vous pouvez utiliser cet exemple:

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

Il utilise une fenêtre cachée afin de calculer la différence de hauteur entre la fenêtre et la vue racine de l'activité. 

5
Siebe Brouwer

Je sais que ceci est un ancien post, mais j'ai remarqué que la solution choisie pour moi ne fonctionnait pas sur tous les appareils. Il semblait y avoir un écart et j'ai donc implémenté ceci et cela semble être un piège à tous:

        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;
            }
        });

Lorsque l’auditeur est appelé pour la première fois, il mesure l’écran sans clavier et, s’il existe un écart, je le comptabilise la prochaine fois. S'il n'y a pas de différence, je règle la différence sur 1 pour qu'il ne soit plus égal à 0.

3
noshaf

Vous ne pouvez pas dire. Non, vraiment: vous ne pouvez tout simplement pas dire.

Le clavier n'a pas besoin d'être de forme particulière. Il ne doit pas nécessairement être placé au bas de l'écran ( plusieurs du le plus populaire options ne sont pas ), il n'est pas obligé de conserver sa valeur taille lorsque vous modifiez les champs de texte (presque aucun ne dépend des drapeaux). Il n'est même pas nécessaire que ce soit rectangulaire . Il est également possible que vous preniez simplement le écran complet .

3
ctate

dans cocos2d-x, nous avons CCEditBox.

Dans Extensions-> GUI-> CCEditBox, vous pouvez trouver la classe CCEditBox.

La beauté est qu’il cache le clavier en tapotant ailleurs sur la scène. et déplace automatiquement le clavier vers le haut si votre boîte de montage est placée trop bas sur la scène.

Si vous utilisez cocos2d-x v2.1.3, vous pouvez accéder au projet exemple en allant à

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

Je vais simplement l'utiliser à la place de CCTextField à partir de maintenant. je suis tombé dessus hier :)

2
Azhar Yousuf

Après des heures de recherche, j’ai trouvé une solution si vous souhaitez définir windowSoftInput="adjustPan"

Voici l'extrait de code:

    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);
        }
    }
});

Dans ce code, après avoir trouvé la hauteur du clavier, je fais défiler la vue pour qu'elle ne soit pas couverte par le clavier, principale raison de la recherche de la hauteur du clavier.

Selon les docs : 

void getWindowVisibleDisplayFrame(Rect outRect): Récupère la taille d'affichage visible dans laquelle la fenêtre à laquelle cette vue est attachée a été positionnée. 

1
Ali Zeynali

Réponse complète et a parfaitement fonctionné pour moi: 

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

Le ROOT_VIEW d’un écran d’affichage Android peut être visualisé comme une simple vue d’écran avec VISIBLE DISPLAY FRAME qui affiche la vue de votre activité.

Ce CADRE D'AFFICHAGE VISIBLE est ajusté lorsque SOFT KEYBOARD est affiché ou caché de l'écran.

NOTE: Veuillez regarder les deux images en cliquant sur les liens ci-dessous pour une meilleure compréhension 

Ainsi, la vue de dessus d’un écran d’affichage peut être visualisée comme suit: RootView de l’affichage

L'ajustement de VISIBLE DISPLAY FRAME avec l'ouverture et la fermeture de SOFT KEYBOARD peut être visualisé comme suit: VISIBLE_DISPLAY_SCREEN ajustement

Ce réglage du VISUAL DISPLAY FRAME peut être très bien utilisé pour connaître la hauteur du clavier comme:

(lorsque le clavier logiciel est ouvert)

SOFT_KEYBOARD_HEIGHT = ROOT_VIEW_HEIGHT - (VISUAL_DISPLAY_FRAME_HEIGHT + EXTRA_SCREEN_HEIGHT)

Le code pour atteindre ce qui précède est: 

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;
            }
        }
    });

NOTE: la fonction onGlobalLayout () sera appelée uniquement lorsque la disposition globale change, comme lors de l'ouverture du clavier virtuel. Donc, le clavier logiciel doit être ouvert au moins une fois pour obtenir la hauteur du clavier logiciel.

Cela a fonctionné pour moi;)

0
Pratik Gawali

Désolé de ne pas pouvoir commenter, deux ou trois réponses m'ont aidé à résoudre mon problème. Elles étaient liées à l'utilisation de AddOnGlobalLayoutListener, puis à la détermination de la hauteur restante avant et après l'apparition d'un clavier.

La solution que j'ai utilisée était basée sur la réponse de Rudy_TM.

CEPENDANT, une chose que je devais trouver était que pour que cette méthode fonctionne, vous devez avoir la ligne suivante quelque part

Window.SetSoftInputMode(SoftInput.AdjustResize);

Avant, j'avais SoftInput.AdjustNothing (ou quelque chose comme ça) et ça ne marcherait pas. Maintenant cela fonctionne parfaitement. Merci pour les réponses!

0
Kalikovision