Vérifier l'orientation sur le téléphone Android


Réponses:


676

La configuration actuelle, utilisée pour déterminer les ressources à récupérer, est disponible à partir de l' Configurationobjet Resources :

getResources().getConfiguration().orientation;

Vous pouvez vérifier l'orientation en regardant sa valeur:

int orientation = getResources().getConfiguration().orientation;
if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
    // In landscape
} else {
    // In portrait
}

Plus d'informations peuvent être trouvées dans le développeur Android .


2
Oh désolé, j'ai mal compris, je pensais que vous disiez que le service ne verrait pas la configuration changer si la configuration change. Ce que vous décrivez, c'est que ... eh bien, il ne voit rien, car rien ne change, parce que le lanceur a verrouillé l'orientation de l'écran et ne lui permet pas de changer. Il est donc correct que .orientation ne change pas, car l'orientation n'a pas changé. L'écran est toujours en portrait.
hackbod

La chose la plus proche que je puisse faire est de lire l'orientation des capteurs, ce qui implique des mathématiques que je ne suis pas trop désireux de comprendre pour le moment.
Archimedes Trajano

13
Il n'y a rien à redouter. L'écran n'a pas pivoté, il est toujours en portrait, il n'y a pas de rotation à voir. Si vous souhaitez surveiller la façon dont l'utilisateur déplace son téléphone, quelle que soit la rotation de l'écran, alors oui, vous devez regarder directement le capteur et décider comment vous souhaitez interpréter les informations que vous obtenez sur la façon dont l'appareil se déplace.
hackbod

4
Cela échouera si l'orientation de l'écran est fixe.
AndroidDev

7
Si l'activité verrouille l'affichage ( android:screenOrientation="portrait"), cette méthode renvoie la même valeur quelle que soit la façon dont l'utilisateur fait pivoter l'appareil. Dans ce cas, vous utiliseriez l'accéléromètre ou le capteur de gravité pour déterminer correctement l'orientation.
Cat

169

Si vous utilisez l'orientation getResources (). GetConfiguration (). Sur certains appareils, vous vous tromperez. Nous avons utilisé cette approche initialement dans http://apphance.com . Grâce à la journalisation à distance d'Apphance, nous avons pu le voir sur différents appareils et nous avons vu que la fragmentation joue son rôle ici. J'ai vu des cas étranges: par exemple en alternant portrait et carré (?!) Sur HTC Desire HD:

CONDITION[17:37:10.345] screen: rotation: 270 orientation: square
CONDITION[17:37:12.774] screen: rotation: 0 orientation: portrait
CONDITION[17:37:15.898] screen: rotation: 90
CONDITION[17:37:21.451] screen: rotation: 0
CONDITION[17:38:42.120] screen: rotation: 270 orientation: square

ou ne change pas d'orientation du tout:

CONDITION[11:34:41.134] screen: rotation: 0
CONDITION[11:35:04.533] screen: rotation: 90
CONDITION[11:35:06.312] screen: rotation: 0
CONDITION[11:35:07.938] screen: rotation: 90
CONDITION[11:35:09.336] screen: rotation: 0

D'un autre côté, width () et height () sont toujours corrects (ils sont utilisés par le gestionnaire de fenêtres, donc il vaut mieux). Je dirais que la meilleure idée est de faire TOUJOURS la vérification largeur / hauteur. Si vous pensez à un moment, c'est exactement ce que vous voulez - savoir si la largeur est plus petite que la hauteur (portrait), l'opposé (paysage) ou si elles sont identiques (carré).

Ensuite, cela revient à ce code simple:

public int getScreenOrientation()
{
    Display getOrient = getWindowManager().getDefaultDisplay();
    int orientation = Configuration.ORIENTATION_UNDEFINED;
    if(getOrient.getWidth()==getOrient.getHeight()){
        orientation = Configuration.ORIENTATION_SQUARE;
    } else{ 
        if(getOrient.getWidth() < getOrient.getHeight()){
            orientation = Configuration.ORIENTATION_PORTRAIT;
        }else { 
             orientation = Configuration.ORIENTATION_LANDSCAPE;
        }
    }
    return orientation;
}

3
Merci! L'initialisation de "l'orientation" est cependant superflue.
MrMaffen

getWidthet getHeightne sont pas dépréciés.
FindOut_Quran

3
@ user3441905, oui ils le sont. Utilisez getSize(Point outSize)plutôt. J'utilise l'API 23.
WindRider

@ jarek-potiuk c'est obsolète.
Hadès

53

Une autre façon de résoudre ce problème est de ne pas compter sur la valeur de retour correcte de l'affichage mais de compter sur la résolution des ressources Android.

Créez le fichier layouts.xmldans les dossiers res/values-landet res/values-portavec le contenu suivant:

res / values-land / layouts.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="is_landscape">true</bool>
</resources>

res / values-port / layouts.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="is_landscape">false</bool>
</resources>

Dans votre code source, vous pouvez maintenant accéder à l'orientation actuelle comme suit:

context.getResources().getBoolean(R.bool.is_landscape)

1
J'aime cela car il utilise la manière dont le système détermine déjà l'orientation
KrustyGString

1
Meilleure réponse pour la vérification paysage / portrait!
vtlinh

Quelle sera sa valeur dans le fichier de valeurs par défaut?
Shashank Mishra

46

Un moyen complet de spécifier l'orientation actuelle du téléphone:

    public String getRotation(Context context){
    final int rotation = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getOrientation();
           switch (rotation) {
            case Surface.ROTATION_0:
                return "portrait";
            case Surface.ROTATION_90:
                return "landscape";
            case Surface.ROTATION_180:
                return "reverse portrait";
            default:
                return "reverse landscape";
            }
        }

Chear Binh Nguyen


6
Il y a une faute de frappe dans votre message - elle devrait dire .getRotation () pas getOrientation
Keith

1
+1 pour cela. J'avais besoin de connaître l'orientation exacte, pas seulement le paysage ou le portrait. getOrientation () est correct, sauf si vous êtes sur le SDK 8+, auquel cas vous devez utiliser getRotation (). Les modes «inversés» sont pris en charge dans le SDK 9+.
Paul

6
@Keith @Paul Je ne me souviens pas comment ça getOrientation()marche, mais ce n'est pas correct si j'utilise getRotation(). Obtenez la "Returns the rotation of the screen from its "natural" orientation." source de rotation . Ainsi, sur un téléphone disant ROTATION_0 est portrait est probablement correct, mais sur une tablette son orientation "naturelle" est probablement paysage et ROTATION_0 devrait retourner paysage plutôt que portrait.
jp36

Il semble que ce soit la méthode préférée pour rejoindre l'avant: developer.android.com/reference/android/view/…
jaysqrd

C'est une mauvaise réponse. Pourquoi at-il été voté? getOrientation (valeurs float [] R, float []) calcule l'orientation du périphérique en fonction de la matrice de rotation.
user1914692

29

Voici une démonstration d'extrait de code comment obtenir l'orientation de l'écran a été recommandée par hackbod et Martijn :

❶ Déclencher lors du changement d'orientation:

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
        int nCurrentOrientation = _getScreenOrientation();
    _doSomeThingWhenChangeOrientation(nCurrentOrientation);
}

❷ Obtenez l'orientation actuelle comme le recommande hackbod :

private int _getScreenOrientation(){    
    return getResources().getConfiguration().orientation;
}

❸Il existe une solution alternative pour obtenir l'orientation actuelle de l'écran ❷ suivez la solution Martijn :

private int _getScreenOrientation(){
        Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
        return display.getOrientation();
}

Remarque : j'ai essayé d'implémenter ❷ et ❸, mais sur RealDevice (NexusOne SDK 2.3) Orientation, il renvoie la mauvaise orientation.

★ Je recommande donc d'utiliser la solution utilisée ❷ pour obtenir une orientation d'écran qui présente plus d'avantages: clairement, simple et fonctionne comme un charme.

★ Vérifiez soigneusement le retour de l'orientation pour vous assurer qu'elle est correcte comme prévu (peut être limité en fonction des spécifications des appareils physiques)

J'espère que ça aide,


16
int ot = getResources().getConfiguration().orientation;
switch(ot)
        {

        case  Configuration.ORIENTATION_LANDSCAPE:

            Log.d("my orient" ,"ORIENTATION_LANDSCAPE");
        break;
        case Configuration.ORIENTATION_PORTRAIT:
            Log.d("my orient" ,"ORIENTATION_PORTRAIT");
            break;

        case Configuration.ORIENTATION_SQUARE:
            Log.d("my orient" ,"ORIENTATION_SQUARE");
            break;
        case Configuration.ORIENTATION_UNDEFINED:
            Log.d("my orient" ,"ORIENTATION_UNDEFINED");
            break;
            default:
            Log.d("my orient", "default val");
            break;
        }

13

Utilisez getResources().getConfiguration().orientationc'est la bonne façon.

Il suffit de faire attention aux différents types de paysages, le paysage que l'appareil utilise normalement et l'autre.

Je ne comprends toujours pas comment gérer cela.


12

Un certain temps s'est écoulé depuis que la plupart de ces réponses ont été publiées et certaines utilisent désormais des méthodes et des constantes obsolètes.

J'ai mis à jour le code de Jarek pour ne plus utiliser ces méthodes et constantes:

protected int getScreenOrientation()
{
    Display getOrient = getWindowManager().getDefaultDisplay();
    Point size = new Point();

    getOrient.getSize(size);

    int orientation;
    if (size.x < size.y)
    {
        orientation = Configuration.ORIENTATION_PORTRAIT;
    }
    else
    {
        orientation = Configuration.ORIENTATION_LANDSCAPE;
    }
    return orientation;
}

Notez que le mode Configuration.ORIENTATION_SQUAREn'est plus pris en charge.

J'ai trouvé cela fiable sur tous les appareils sur lesquels je l'ai testé contrairement à la méthode suggérant l'utilisation de getResources().getConfiguration().orientation


Notez que getOrient.getSize (taille) nécessite un niveau 13 api
Lester

6

Vérifiez l'orientation de l'écran lors de l'exécution.

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

    // Checks the orientation of the screen
    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        Toast.makeText(this, "landscape", Toast.LENGTH_SHORT).show();

    } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT){
        Toast.makeText(this, "portrait", Toast.LENGTH_SHORT).show();        
    }
}

5

Il existe une autre façon de procéder:

public int getOrientation()
{
    if(getResources().getDisplayMetrics().widthPixels>getResources().getDisplayMetrics().heightPixels)
    { 
        Toast t = Toast.makeText(this,"LANDSCAPE",Toast.LENGTH_SHORT);
        t.show();
        return 1;
    }
    else
    {
        Toast t = Toast.makeText(this,"PORTRAIT",Toast.LENGTH_SHORT);
        t.show();
        return 2;
    }       
}


4

Testé en 2019 sur l'API 28, quel que soit l'utilisateur ayant défini l'orientation portrait ou non, et avec un code minimal par rapport à une autre réponse obsolète , ce qui suit fournit l'orientation correcte:

/** @return The {@link Configuration#ORIENTATION_SQUARE}, {@link Configuration#ORIENTATION_PORTRAIT}, {@link Configuration#ORIENTATION_LANDSCAPE} constants based on the current phone screen pixel relations. */
private int getScreenOrientation()
{
    DisplayMetrics dm = context.getResources().getDisplayMetrics(); // Screen rotation effected

    if(dm.widthPixels == dm.heightPixels)
        return Configuration.ORIENTATION_SQUARE;
    else
        return dm.widthPixels < dm.heightPixels ? Configuration.ORIENTATION_PORTRAIT : Configuration.ORIENTATION_LANDSCAPE;
}

2

Je pense que ce code peut fonctionner après que le changement d'orientation a pris effet

Display getOrient = getWindowManager().getDefaultDisplay();

int orientation = getOrient.getOrientation();

remplacer la fonction Activity.onConfigurationChanged (Configuration newConfig) et utiliser newConfig, orientation si vous souhaitez être averti de la nouvelle orientation avant d'appeler setContentView.


2

je pense que l'utilisation de getRotationv () n'aide pas parce que http://developer.android.com/reference/android/view/Display.html#getRotation%28%29 getRotation () Renvoie la rotation de l'écran à partir de son "naturel" orientation.

donc à moins que vous ne connaissiez l'orientation "naturelle", la rotation n'a pas de sens.

j'ai trouvé un moyen plus simple,

  Display display = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
  Point size = new Point();
  display.getSize(size);
  int width = size.x;
  int height = size.y;
  if(width>height)
    // its landscape

s'il vous plaît dites-moi s'il y a un problème avec cette personne?


2

tel est superposé tous les téléphones tels que oneplus3

public static boolean isScreenOriatationPortrait(Context context) {
         return context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT;
         }

code droit comme suit:

public static int getRotation(Context context){
        final int rotation = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getOrientation();

        if(rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180){
            return Configuration.ORIENTATION_PORTRAIT;
        }

        if(rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270){
            return Configuration.ORIENTATION_LANDSCAPE;
        }

        return -1;
    }

1

Ancien poste, je sais. Quelle que soit l'orientation ou la permutation, etc. J'ai conçu cette fonction qui permet de régler l'appareil dans la bonne orientation sans avoir besoin de savoir comment les fonctions portrait et paysage sont organisées sur l'appareil.

   private void initActivityScreenOrientPortrait()
    {
        // Avoid screen rotations (use the manifests android:screenOrientation setting)
        // Set this to nosensor or potrait

        // Set window fullscreen
        this.activity.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

        DisplayMetrics metrics = new DisplayMetrics();
        this.activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

         // Test if it is VISUAL in portrait mode by simply checking it's size
        boolean bIsVisualPortrait = ( metrics.heightPixels >= metrics.widthPixels ); 

        if( !bIsVisualPortrait )
        { 
            // Swap the orientation to match the VISUAL portrait mode
            if( this.activity.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT )
             { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); }
            else { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT ); }
        }
        else { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR); }

    }

Fonctionne comme un charme!


1

Utilisez de cette façon,

    int orientation = getResources().getConfiguration().orientation;
    String Orintaion = "";
    switch (orientation)
    {
        case Configuration.ORIENTATION_UNDEFINED: Orintaion = "Undefined"; break;
        case Configuration.ORIENTATION_LANDSCAPE: Orintaion = "Landscrape"; break;
        case Configuration.ORIENTATION_PORTRAIT:  Orintaion = "Portrait"; break;
        default: Orintaion = "Square";break;
    }

dans la chaîne, vous avez l'Oriantion


1

il y a plusieurs façons de le faire, ce morceau de code fonctionne pour moi

 if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
             // portrait mode
} else if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
                      // landscape
        }

1

Je pense que cette solution est simple

if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT){
  user_todat_latout = true;
} else {
  user_todat_latout = false;
}

Généralement, les réponses sont beaucoup plus utiles si elles incluent une explication de ce que le code est censé faire et pourquoi cela résout le problème sans en introduire d'autres.
Tom Aranda

oui désolé pour cela, je pense qu'il n'a pas besoin d'expliquer exactement ce bloc d'orientation de vérification de code s'il est égal à Configuration.ORIENTATION_PORTRAIT c'est une application moyenne en portrait :)
Issac Nabil

1

Code simple à deux lignes

if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
    // do something in landscape
} else {
    //do in potrait
}

0

Simple et facile :)

  1. Créez 2 dispositions xml (c.-à-d. Portrait et paysage)
  2. Dans le fichier java, écrivez:

    private int intOrientation;

    à la onCreateméthode et avant d' setContentViewécrire:

    intOrientation = getResources().getConfiguration().orientation;
    if (intOrientation == Configuration.ORIENTATION_PORTRAIT)
        setContentView(R.layout.activity_main);
    else
        setContentView(R.layout.layout_land);   // I tested it and it works fine.

0

Il convient également de noter que de nos jours, il y a moins de bonnes raisons de vérifier l'orientation explicite getResources().getConfiguration().orientationsi vous le faites pour des raisons de mise en page, car la prise en charge multi-fenêtres introduite dans Android 7 / API 24+ pourrait gâcher vos mises en page un peu orientation. Mieux vaut envisager d'utiliser <ConstraintLayout>, et des dispositions alternatives en fonction de la largeur ou de la hauteur disponible , ainsi que d'autres astuces pour déterminer quelle disposition est utilisée, par exemple la présence ou non de certains fragments attachés à votre activité.


0

Vous pouvez utiliser ceci (basé sur ici ):

public static boolean isPortrait(Activity activity) {
    final int currentOrientation = getCurrentOrientation(activity);
    return currentOrientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT || currentOrientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
}

public static int getCurrentOrientation(Activity activity) {
    //code based on https://www.captechconsulting.com/blog/eric-miles/programmatically-locking-android-screen-orientation
    final Display display = activity.getWindowManager().getDefaultDisplay();
    final int rotation = display.getRotation();
    final Point size = new Point();
    display.getSize(size);
    int result;
    if (rotation == Surface.ROTATION_0
            || rotation == Surface.ROTATION_180) {
        // if rotation is 0 or 180 and width is greater than height, we have
        // a tablet
        if (size.x > size.y) {
            if (rotation == Surface.ROTATION_0) {
                result = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
            }
        } else {
            // we have a phone
            if (rotation == Surface.ROTATION_0) {
                result = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
            }
        }
    } else {
        // if rotation is 90 or 270 and width is greater than height, we
        // have a phone
        if (size.x > size.y) {
            if (rotation == Surface.ROTATION_90) {
                result = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
            }
        } else {
            // we have a tablet
            if (rotation == Surface.ROTATION_90) {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
            }
        }
    }
    return result;
}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.