Verifique la orientación en el teléfono Android


Respuestas:


676

La configuración actual, como se usa para determinar qué recursos recuperar, está disponible desde el Configurationobjeto Recursos :

getResources().getConfiguration().orientation;

Puede verificar la orientación mirando su valor:

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

Se puede encontrar más información en el desarrollador de Android .


2
Oh, perdón, entendí mal, pensé que estabas diciendo que el servicio no vería cambiar la configuración si la configuración cambia. Lo que está describiendo es que ... bueno, no está viendo nada, porque nada está cambiando, porque el iniciador ha bloqueado la orientación de la pantalla y no permite que cambie. Entonces, es correcto que la orientación no cambie, porque la orientación no ha cambiado. La pantalla sigue siendo vertical.
hackbod

Lo más parecido que puedo hacer es leer la orientación de los sensores que involucra matemáticas que no estoy realmente interesado en descifrar en este momento.
Arquímedes Trajano

13
No hay nada de qué molestarse. La pantalla no ha girado, todavía está en vertical, no hay rotación para ver. Si desea controlar cómo el usuario mueve su teléfono independientemente de cómo se rote la pantalla, entonces sí, debe mirar directamente el sensor y decidir cómo desea interpretar la información que obtiene sobre cómo se mueve el dispositivo.
hackbod

44
Esto fallará si la orientación de la pantalla es fija.
AndroidDev

77
Si la actividad bloquea la pantalla ( android:screenOrientation="portrait"), este método devolverá el mismo valor independientemente de cómo el usuario gire el dispositivo. En ese caso, usaría el acelerómetro o el sensor de gravedad para determinar la orientación correctamente.
Gato

169

Si usa la orientación getResources (). GetConfiguration (). En algunos dispositivos, se equivocará. Usamos ese enfoque inicialmente en http://apphance.com . Gracias al registro remoto de Apphance pudimos verlo en diferentes dispositivos y vimos que la fragmentación juega su papel aquí. Vi casos extraños: por ejemplo, alternar retrato y cuadrado (?!) en 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

o no cambiar la orientación en absoluto:

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

Por otro lado, ancho () y alto () siempre son correctos (lo usa el administrador de ventanas, por lo que debería serlo). Yo diría que la mejor idea es hacer la verificación de ancho / alto SIEMPRE. Si piensa en un momento, esto es exactamente lo que desea: saber si el ancho es menor que la altura (vertical), lo opuesto (horizontal) o si son iguales (cuadrado).

Entonces todo se reduce a este código 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
¡Gracias! Sin embargo, la inicialización de la "orientación" es superflua.
MrMaffen

getWidthy getHeightno están en desuso.
FindOut_Quran

3
@ user3441905, sí lo son. Usar en su getSize(Point outSize)lugar. Estoy usando API 23.
WindRider

@ jarek-potiuk está en desuso.
Hades

53

Otra forma de resolver este problema es no confiar en el valor de retorno correcto de la pantalla sino confiar en la resolución de los recursos de Android.

Cree el archivo layouts.xmlen las carpetas res/values-landy res/values-portcon el siguiente contenido:

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>

En su código fuente ahora puede acceder a la orientación actual de la siguiente manera:

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

1
Me gusta, ya que utiliza la orientación de cualquier manera el sistema ya está determinando
KrustyGString

1
¡La mejor respuesta para la comprobación de paisajes / retratos!
vtlinh

¿Cuál será su valor en el archivo de valores predeterminados?
Shashank Mishra

46

Una forma completa de especificar la orientación actual del teléfono:

    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


66
Hay un error tipográfico en su publicación: debería decir .getRotation () not getOrientation
Keith el

1
+1 por esto. Necesitaba saber la orientación exacta, no solo el paisaje frente al retrato. getOrientation () es correcto a menos que esté en SDK 8+, en cuyo caso debe usar getRotation (). Los modos 'inverso' son compatibles con SDK 9+.
Paul

66
@Keith @Paul No recuerdo cómo getOrientation()funciona, pero esto no es correcto si se usa getRotation(). Obtener "Returns the rotation of the screen from its "natural" orientation." fuente de rotación . Entonces, en un teléfono que dice ROTATION_0 es vertical, es probable que sea correcto, pero en una tableta su orientación "natural" es probablemente horizontal y ROTATION_0 debería devolver horizontal en lugar de vertical.
jp36

Parece que este es el método preferido para unirse: developer.android.com/reference/android/view/…
jaysqrd

Esta es una respuesta incorrecta. ¿Por qué se votó? getOrientation (valores float [] R, float []) calcula la orientación del dispositivo en función de la matriz de rotación.
user1914692

29

Aquí está la demostración del fragmento de código. Hackbod y Martijn recomendaron cómo obtener la orientación de la pantalla :

❶ Activar cuando cambia la orientación:

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

❷ Obtenga la orientación actual como hackbod recomienda:

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

❸Hay una solución alternativa para obtener la orientación actual de la pantalla ❷ siga la solución de Martijn :

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

Nota : Intenté implementar ambos ❷ y ❸, pero en Orientación RealDevice (NexusOne SDK 2.3) devuelve la orientación incorrecta.

★ Por lo tanto, recomiendo usar la solución ❷ para obtener la orientación de la pantalla que tiene más ventaja: claramente, simple y funciona como un encanto.

★ Verifique cuidadosamente el retorno de la orientación para asegurar que sea correcta como se esperaba (puede ser limitada dependiendo de la especificación de los dispositivos físicos)

Espero que ayude


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

Úselo getResources().getConfiguration().orientationde la manera correcta.

Solo tiene que tener cuidado con los diferentes tipos de paisajes, el paisaje que el dispositivo usa normalmente y el otro.

Aún no entiendo cómo manejar eso.


12

Ha pasado algún tiempo desde que se publicaron la mayoría de estas respuestas y algunas utilizan métodos y constantes obsoletos.

He actualizado el código de Jarek para que ya no use estos métodos y 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;
}

Tenga en cuenta que el modo Configuration.ORIENTATION_SQUAREya no es compatible.

Encontré que esto es confiable en todos los dispositivos en los que lo he probado en contraste con el método que sugiere el uso de getResources().getConfiguration().orientation


Tenga en cuenta que getOrient.getSize (tamaño) requiere 13 niveles de API
Lester

6

Verifique la orientación de la pantalla en tiempo de ejecución.

@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

Hay una forma más de hacerlo:

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

El SDK de Android puede decirte esto muy bien:

getResources().getConfiguration().orientation

4

Probado en 2019 en API 28, independientemente de que el usuario haya configurado la orientación vertical o no, y con un código mínimo en comparación con otra respuesta obsoleta , lo siguiente ofrece la orientación correcta:

/** @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

Creo que este código puede funcionar después de que el cambio de orientación surta efecto

Display getOrient = getWindowManager().getDefaultDisplay();

int orientation = getOrient.getOrientation();

anule la función Activity.onConfigurationChanged (Configuración newConfig) y use newConfig, orientación si desea recibir una notificación sobre la nueva orientación antes de llamar a setContentView.


2

Creo que usar getRotationv () no ayuda porque http://developer.android.com/reference/android/view/Display.html#getRotation%28%29 getRotation () Devuelve la rotación de la pantalla desde su "natural" orientación.

entonces, a menos que conozca la orientación "natural", la rotación no tiene sentido.

Encontré una manera más fácil

  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

por favor dime si hay un problema con este alguien?


2

Tal es la superposición de todos los teléfonos como oneplus3

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

código correcto de la siguiente manera:

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

Publicación antigua lo sé. Sea cual sea la orientación o se cambie, etc. Diseñé esta función que se usa para configurar el dispositivo en la orientación correcta sin la necesidad de saber cómo se organizan las funciones de retrato y paisaje en el dispositivo.

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

    }

¡Funciona de maravilla!


1

Usa de esta manera,

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

en la cadena tienes el Oriantion


1

Hay muchas maneras de hacer esto, este código funciona para mí

 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

Creo que esta solución es fácil

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

En general, las respuestas son mucho más útiles si incluyen una explicación de lo que se pretende que haga el código y por qué eso resuelve el problema sin introducir otros.
Tom Aranda

sí, lo siento, pensé que no es necesario explicar exactamente este bloque de orientación de verificación de código si es igual a Configuration.ORIENTATION_PORTRAIT que es una aplicación mala en retrato :)
Issac Nabil

1

Solo código simple de dos líneas

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

0

Simple y fácil :)

  1. Hacer 2 diseños xml (es decir, vertical y horizontal)
  2. En el archivo java, escriba:

    private int intOrientation;

    en el onCreatemétodo y antes de setContentViewescribir:

    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

También vale la pena señalar que hoy en día, hay menos buenas razones para verificar la orientación explícita getResources().getConfiguration().orientationsi lo hace por razones de diseño, ya que el Soporte de múltiples ventanas introducido en Android 7 / API 24+ podría alterar un poco sus diseños. orientación. Es mejor considerar el uso <ConstraintLayout>y diseños alternativos que dependen del ancho o la altura disponibles , junto con otros trucos para determinar qué diseño se está utilizando, por ejemplo, la presencia o no de ciertos Fragmentos que se unen a su Actividad.


0

Puede usar esto (según aquí ):

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;
}
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.