java - screensize - Verifique la orientación en el teléfono Android

onconfigurationchanged android

Question

¿Cómo puedo comprobar si el teléfono Android está en horizontal o vertical?

Answer 1

Antiguo post lo sé. Cualquiera que sea la orientación puede ser o está intercambiada, etc. Diseñé esta función que se utiliza para configurar el dispositivo en la orientación correcta sin la necesidad de saber cómo están organizadas 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!

Answer 2

Aquí está la demostración del fragmento de código, cómo obtener orientación a la pantalla, recomendada por y Martijn :

❶ Activar cuando cambie la orientación:

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

❷ Obtener orientación actual como Martijn 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é ambos implementando ❷ & ❸, pero en RealDevice (NexusOne SDK 2.3) Orientación devuelve la orientación incorrecta.

★ Por lo tanto, recomiendo utilizar la solución para obtener la orientación de la pantalla, que tiene más ventajas: clara, sencilla y funciona como un encanto.

★ Verifique cuidadosamente el retorno de la orientación para asegurarnos de que es correcta (se puede tener una dependencia limitada de la especificación de los dispositivos físicos)

Espero que te ayude,

Answer 3

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

Answer 4

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 (Configuration newConfig) y use newConfig, orientación si desea recibir una notificación sobre la nueva orientación antes de llamar a setContentView.

Answer 5

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 de su "natural" orientación.

así que a menos que sepa 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 dígame si hay algún problema con esta persona.

Answer 6

El SDK de Android puede decirte esto muy bien:

getResources().getConfiguration().orientation

Answer 7

En el archivo de actividad:

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

Y en el archivo Manifiesto:

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

Espero que te ayude ..!

Answer 8

Ha pasado algo de tiempo desde que la mayoría de estas respuestas se publicaron y algunos ahora usan métodos y constantes en desuso.

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_SQUARE ya 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

Answer 9

Hay muchas formas de hacer esto, este código me funciona.

 if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
             // portrait mode
} else if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
                      // landscape
        }

Answer 10

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

Answer 11

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

Cree el archivo layouts.xml en las carpetas res/values-land y res/values-port con 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)

Answer 12

Puedes usar esto (basado 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; }

Answer 13

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, alternando vertical 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, el ancho () y el alto () siempre son correctos (es usado por el administrador de ventanas, así que mejor debería serlo). Yo diría que la mejor idea es hacer la verificación de ancho / altura SIEMPRE. Si piensa en un momento, esto es exactamente lo que desea: saber si el ancho es menor que la altura (retrato), lo opuesto (paisaje) o si son iguales (cuadrado).

Luego se reduce a este simple código:

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

Answer 14

Simple y fácil :)

1. Hacer 2 diseños xml (es decir, retrato y paisaje)

2. En el archivo java, escriba:

   private int intOrientation;

   onCreate método onCreate y antes de setContentView escriba:

   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.

Answer 15

También vale la pena señalar que hoy en día, hay menos motivos para comprobar la orientación explícita con getResources().getConfiguration().orientation si lo está haciendo por motivos de diseño, como podría ser el soporte de múltiples ventanas introducido en Android 7 / API 24+ ensucie bastante con sus diseños en cualquier orientación. Es mejor considerar el uso de <ConstraintLayout> y los 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 adjuntan a su Actividad.

Answer 16

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

Answer 17

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 Cuerda tienes la Orianción.

Answer 18

Use getResources().getConfiguration().orientation es la forma correcta.

Solo tiene que estar atento a los diferentes tipos de paisajes, el paisaje que normalmente utiliza el dispositivo y el otro.

Todavía no entiendo cómo manejar eso.

Answer 19

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

Answer 20

como esto es superponer 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;
    }

Answer 21

La configuración actual, tal como se usa para determinar qué recursos recuperar, está disponible en el objeto Configuration de los recursos:

getResources().getConfiguration().orientation

Puedes 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 los documentos de Android Developer .

Answer 22

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