Comment puis-je vérifier si le téléphone Android est en mode paysage ou portrait?
Comment puis-je vérifier si le téléphone Android est en mode paysage ou portrait?
Réponses:
La configuration actuelle, utilisée pour déterminer les ressources à récupérer, est disponible à partir de l' Configuration
objet 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 .
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.
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;
}
getWidth
et getHeight
ne sont pas dépréciés.
getSize(Point outSize)
plutôt. J'utilise l'API 23.
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.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)
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
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.
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().orientation
c'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_SQUARE
n'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 :)
Dans le fichier java, écrivez:
private int intOrientation;
à la onCreate
mé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().orientation
si 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;
}