web-dev-qa-db-fra.com

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

Comment puis-je vérifier si le téléphone Android est en mode Paysage ou Portrait? 

javaandroidorientation
360
Mohit Deshpande

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

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 sont disponibles dans Développeur Android .

588
hackbod

Si vous utilisez l'orientation getResources (). GetConfiguration () sur certains périphériques, vous vous tromperez. Nous avons utilisé cette approche initialement dans http://apphance.com . Grâce à la journalisation à distance d'Apphance, nous avons pu la voir sur différents appareils et nous avons vu que la fragmentation joue ici son rôle. J'ai vu des cas étranges: par exemple, alterner 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 pas changer 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

Par contre, width () et height () sont toujours correctes (il est utilisé par le gestionnaire de fenêtres, il devrait donc être mieux). Je dirais que la meilleure idée est de vérifier TOUJOURS la largeur/la hauteur. Si vous pensez à un moment, c'est exactement ce que vous voulez - savoir si la largeur est inférieure à la hauteur (portrait), l'opposé (paysage) ou si elles sont identiques (carrées).

Ensuite, il s’agit de 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;
}
167
Jarek Potiuk

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

Créez le fichier layouts.xml dans les dossiers res/values-land et res/values-port avec 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)
50
Paul

Une façon complètement 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

46
Nguyen Minh Binh

Voici une démonstration d'extrait de code sur la façon d'obtenir l'orientation de l'écran recommandée par hackbod et Martijn :

❶ Déclencher lors du changement Orientation:

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

Obtenir l'orientation actuelle sous hackbod recommend:

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

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

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

★ Note: J'essayais à la fois d'implémenter & ❸, mais sur RealDevice (NexusOne SDK 2.3) Orientation, l'orientation renvoyée était incorrecte.

★ Donc, je recommande d'utiliser la solution pour obtenir une orientation de l'écran plus avantageuse: clairement, simple et fonctionne à merveille. 

★ Vérifiez soigneusement le retour de l'orientation pour vous assurer de l'exactitude de nos attentes (possibilité dépendante des spécifications des périphériques physiques)

J'espère que ça vous aidera

26
NguyenDat
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;
        }
16
anshul

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

Vous devez simplement faire attention aux différents types de paysages, au paysage que l'appareil utilise normalement et à l'autre.

Je ne comprends toujours pas comment gérer ça.

13
neteinstein

Un certain temps a passé depuis que la plupart de ces réponses ont été postées et certaines utilisent 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_SQUARE n'est plus supporté.

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

11
Baz

Vérifiez l'orientation de l'écran au moment 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();        
    }
}
6
Kumar

Il y a une autre façon de le faire:

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;
    }       
}
5
maximus

Le SDK Android peut vous dire très bien ceci:

getResources().getConfiguration().orientation
4
Single 'n Looking

je pense que l’utilisation de getRotationv () n’aide pas, car http://developer.Android.com/reference/Android/view/Display.html#getRotation%28%29 getRotation () Retourne la rotation de l'écran à partir de son orientation "naturelle".

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

j'ai trouvé un moyen plus facile, 

  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
steveh

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

Display getOrient = getWindowManager().getDefaultDisplay();

int orientation = getOrient.getOrientation();

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

2
Daniel

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 comparé à autre réponse obsolète , les éléments suivants fournissent 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
ManuelTS

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

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

code correct 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
yueyue_projects

Simple et facile :)

  1. Faire 2 mises en page xml (portrait et paysage)

  2. Dans le fichier Java, écrivez:

    private int intOrientation;

    à la méthode onCreate et avant la 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.
1
Kerelos

Je pense que cette solution est facile

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

Utilisez 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 ficelle vous avez l'orientant

1
user5037478

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

   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
Codebeat

il y a beaucoup de façons de faire cela, 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
Mehroz Munir

Dans le fichier d'activité:

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

    private void checkOrientation(Configuration newConfig){
        // Checks the orientation of the screen
        if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
            Log.d(TAG, "Current Orientation : Landscape");
            // Your magic here for landscape mode          
        } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT){
            Log.d(TAG, "Current Orientation : Portrait");
            // Your magic here for portrait mode         
        }
    }

ET dans le fichier manifeste:

<activity Android:name=".ActivityName"
            Android:configChanges="orientation|screenSize">

J'espère que ça vous aidera ..!

0
Viral Patel

Il est également intéressant de noter que de nos jours, il y a moins de raison de vérifier l'orientation explicite avec getResources().getConfiguration().orientation si vous le faites pour des raisons de disposition, car Prise en charge de plusieurs fenêtres introduite dans Android 7/API 24+ pourrait perturber vos présentations un peu dans les deux sens. Mieux vaut envisager d'utiliser <ConstraintLayout> et des dispositions alternatives dépendant de la largeur ou de la hauteur disponible , ainsi que d'autres astuces permettant de déterminer la disposition utilisée, par ex. la présence ou non de certains fragments attachés à votre activité.

0
qix

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;
}
0
android developer