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

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

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 .

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

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)

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

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,

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

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.

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

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

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

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

getResources().getConfiguration().orientation

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

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.

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?

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

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!

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

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
        }

Je pense que cette solution est simple

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

Code simple à deux lignes

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

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.

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é.

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