Bloqueo de orientación en android mediante programación

He creado algunos métodos de utilidad para ayudar a lidiar con la orientación de bloqueo, no dude en utilizar esta clase.

Ejemplo de uso:

• En una actividad: OrientationUtils.lockOrientationPortrait(MyActivityName.this)
• En un fragmento: OrientationUtils.lockOrientationLandscape(getActivity())

Código:

 /** Static methods related to device orientation. */ public class OrientationUtils { private OrientationUtils() {} /** Locks the device window in landscape mode. */ public static void lockOrientationLandscape(Activity activity) { activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); } /** Locks the device window in portrait mode. */ public static void lockOrientationPortrait(Activity activity) { activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); } /** Allows user to freely use portrait or landscape mode. */ public static void unlockOrientation(Activity activity) { activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED); } } 

Aquí está mi clase OrientationUtils en GitHub que puede utilizarse en cualquier aplicación de Android: https://github.com/danialgoodwin/android-simply-advanced-helper/blob/master/SimplyAdvancedHelperLibrary/src/net/simplyadvanced/utils/OrientationUtils. Java

 Activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED); 

Bloquea la pantalla (actividad) en la orientación que sea.

Requiere Nivel de API> = 18

Esta es una clase que escribí para manejar el bloqueo y el desbloqueo de la orientación de la pantalla. Yo llamo a toggleScreenOrientationLock(this, prefs, isChecked) de un botón de conmutación checkedChangedListener, y restoreScreenLock(this, prefs) de onCreate (). En ambos casos this es tu actividad y prefs es un objeto SharedPrefences , usado para guardar información sobre el estado del bloqueo.

La parte complicada del código es la función getScreenOrientation() , que robé y limpié de aquí . Voy a tratar de explicar la lógica detrás de cómo esto funciona.

Cuando definimos la orientación del dispositivo con setRequestedOrienation() , necesitamos saber si el dispositivo está en modo horizontal o vertical y necesitamos saber si es una orientación inversa (girada 180 grados).

La getResources().getConfiguration().orientation responderá a la pregunta de qué orientación estamos. Si pudiéramos factorizar la rotación del dispositivo, podríamos decir si fue girado 180 o no. Desafortunadamente, dependiendo del dispositivo, ROTATE_0 puede ser retrato o paisaje. Los teléfonos suelen asignar ROTATE_0 a vertical y comprimidos al paisaje.

Así que la solución utilizada aquí es usar las dimensiones de la pantalla para determinar si está en el paisaje o el retrato en su lugar. Si la pantalla es más ancha de lo alto, entonces deducimos que el dispositivo está en una orientación horizontal, y viceversa para el retrato. Entonces podemos factorizar la rotación para averiguar si la orientación se invierte o no.

Por ejemplo, si la pantalla es más ancha que alta, entonces sabemos que estamos en una orientación horizontal. Si la rotación es 0 o 180 (en la lógica del código, esto es igual a! IsRotatedOrthogonally), entonces sabemos que 0 es LANDSCAPE y 180 es REVERSE_LANDSCAPE.

Se ha observado en otra parte que esto no funcionará en todos los dispositivos, ya que si 90 o 270 es la orientación invertida es específica del dispositivo. Pero esto es probablemente lo mejor que vas a hacer; En el peor de los casos, una orientación girará 180 grados cuando se bloquea, lo que es lo que probablemente sucedería si se intentó bloquear la pantalla de otra manera.

 public class ScreenLocker { final private static String ROTATION_LOCKED_KEY = "LockedOrientationVal"; final private static String ROTATION_IS_LOCKED_KEY = "IsRotationLocked"; final private static String ROTATION_SAVED_KEY = "SavedOrientationVal"; public static int getScreenOrientation(Activity activity) { final Display display = activity.getWindowManager().getDefaultDisplay(); final int rotation = display.getRotation(); Point size = new Point(); display.getSize(size); final boolean isWiderThanTall = size.x > size.y; final boolean isRotatedOrthogonally = (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270); int orientation; if (isRotatedOrthogonally) { if (isWiderThanTall) orientation = (rotation == Surface.ROTATION_90) ? ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE : ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE; else orientation = (rotation == Surface.ROTATION_90) ? ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT : ActivityInfo.SCREEN_ORIENTATION_PORTRAIT; // normal and reversed switched intended } else { if (isWiderThanTall) orientation = (rotation == Surface.ROTATION_0) ? ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE : ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE; else orientation = (rotation == Surface.ROTATION_0) ? ActivityInfo.SCREEN_ORIENTATION_PORTRAIT : ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT; } return orientation; } public static void toggleScreenOrientationLock(Activity activity,SharedPreferences prefs, boolean lock) { if(lock) lockScreenOrientation(activity, prefs); else unlockScreenOrientation(activity, prefs); } // call this from your activity's onCreate() or onResume() public static boolean restoreScreenLock(Activity activity, SharedPreferences prefs) { final boolean isLocked = prefs.getBoolean(ROTATION_IS_LOCKED_KEY, false); final int previousLockedOrientation = prefs.getInt(ROTATION_LOCKED_KEY, -999); if(isLocked && previousLockedOrientation != -999) { prefs.edit().putInt(ROTATION_SAVED_KEY, activity.getRequestedOrientation()).apply(); activity.setRequestedOrientation(previousLockedOrientation); return true; } return false; } private static void lockScreenOrientation(Activity activity, SharedPreferences prefs) { final int currentOrientation = activity.getRequestedOrientation(); final int lockOrientation = getScreenOrientation(activity); // checking isCurrentlyLocked prevents the ROTATION_LOCKED_KEY and ROTATION_SAVED_KEY // becoming identical, which results in the screen not being able to be unlocked. final boolean isCurrentlyLocked = prefs.getBoolean(ROTATION_IS_LOCKED_KEY, false); if(!isCurrentlyLocked) { activity.setRequestedOrientation(lockOrientation); prefs.edit() .putInt(ROTATION_SAVED_KEY, currentOrientation) .putInt(ROTATION_LOCKED_KEY, lockOrientation) .putBoolean(ROTATION_IS_LOCKED_KEY, true) .apply(); } } private static void unlockScreenOrientation(Activity activity, SharedPreferences prefs) { final int savedOrientation = prefs.getInt(ROTATION_SAVED_KEY, activity.getRequestedOrientation()); activity.setRequestedOrientation(savedOrientation); prefs.edit().putBoolean(ROTATION_IS_LOCKED_KEY, false).apply(); } } 

Aquí hay otra solución sencilla que funciona bien para mí.

 private void orientationManager(boolean lock) { int currentOrientation = getResources().getConfiguration().orientation; if(lock) { if (currentOrientation == Configuration.ORIENTATION_LANDSCAPE) { setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE); } else { setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT); } } else { setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED); } } 

Necesitaba bloquear orientationManager(true); La orientación actual de la pantalla cuando los diálogos fueron abiertos y desbloquear orientationManager(false); Cuando se cerró el diálogo.