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'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 .
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;
}
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)
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
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
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().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.
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
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();
}
}
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;
}
}
Le SDK Android peut vous dire très bien ceci:
getResources().getConfiguration().orientation
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?
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.
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;
}
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;
}
Simple et facile :)
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.
Je pense que cette solution est facile
if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT){
user_todat_latout = true;
} else {
user_todat_latout = false;
}
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
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!
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
}
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 ..!
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é.
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;
}