Compruebe la orientación en el teléfono Android

¿Cómo puedo verificar si el teléfono Android está en Paisaje o Retrato?

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

 getResources().getConfiguration().orientation 

Puede verificar la orientación observando 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 para desarrolladores de Android .

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 desempeña su papel aquí. Vi casos extraños: por ejemplo, retrato alterno 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, width () y height () siempre son correctos (lo usa el administrador de ventanas, por lo que debería ser mejor). 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 quiere: saber si el ancho es más pequeño que la altura (vertical), lo contrario (horizontal) o si son iguales (cuadrados).

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

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.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"?>  true  

res / values-port / layouts.xml:

 < ?xml version="1.0" encoding="utf-8"?>  false  

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

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

Una forma completamente específica 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

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

❶ Desencadenar cuando cambio 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 : He intentado ambos implementos ❷ y ❸, pero en la orientación RealDevice (NexusOne SDK 2.3) devuelve la orientación incorrecta.

★ Así que recomiendo usar la solución ❷ para obtener la orientación de la pantalla que tiene más ventajas: clara, simple y funciona como un amuleto.

★ Verifique cuidadosamente el retorno de la orientación para garantizar que sea correcta, tal como esperábamos (puede tener limitada la especificación de los dispositivos físicos)

Espero que ayude,

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

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

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

Aún no entiendo cómo manejar eso.

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

He actualizado el código de Jarek para no usar 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

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

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

El SDK de Android puede decirte esto muy bien:

 getResources().getConfiguration().orientation 

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

 Display getOrient = getWindowManager().getDefaultDisplay(); int orientation = getOrient.getOrientation(); 

anula la función Activity.onConfigurationChanged (Configuration newConfig) y usa newConfig, orientation si desea recibir notificaciones sobre la nueva orientación antes de llamar a setContentView.

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.

entonces, a menos que sepas 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 esta persona?

Publicación anterior que sé. Cualquiera que sea la orientación, el intercambio, 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 características 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!

Úselo 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 la Oriantion

hay muchas formas de hacerlo, 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 } 

Simple y fácil 🙂

  1. Haga 2 diseños de xml (es decir, retrato y paisaje)
  2. En el archivo java, escribe:

     private int intOrientation; 

    en el método onCreate y antes de la escritura setContentView :

     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. 

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

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

También vale la pena señalar que hoy en día, hay menos buenas razones para buscar orientación explícita con getResources().getConfiguration().orientation si lo hace por motivos de diseño, ya que el soporte de múltiples ventanas introducido en Android 7 / API 24+ podría meterse con sus diseños bastante en cualquier orientación. Es mejor considerar el uso de , 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 conectados a su Actividad.