screen orientation android manifest
Android: permitir el retrato y el paisaje para las tabletas, pero forzar el retrato en el teléfono? (8)
Suplemento a la respuesta aceptada
Puede hacer los siguientes pasos en Android Studio para agregar los directorios res/values-sw600dp y res/values-large con sus archivos bools.xml .
valores-sw600dp
En primer lugar, desde la pestaña Proyecto, seleccione el filtro Proyecto (en lugar de Android) en el navegador.
A continuación, haga clic derecho en el directorio app/src/main/res . Elija Nuevo > Directorio de recursos de Android .
Seleccione el ancho de pantalla más pequeño , y luego presione el botón >> .
Escriba 600 para el ancho de pantalla más pequeño. El nombre del directorio se generará automáticamente. Decir ok.
A continuación, haga clic derecho en el archivo recién creado values-sw600dp . Elija Nuevo > Archivo de recursos de valores . Escriba bools para el nombre.
valores-grandes
Agregar un directorio de values-large solo es necesario si admite Android 3.2 anterior (nivel de API 13). De lo contrario, puede omitir este paso. El directorio values-large corresponde a values-sw600dp . ( values-xlarge corresponde a values-sw720dp )
Para crear el directorio de values-large , siga los mismos pasos que en el ejemplo anterior, pero en este caso elija Tamaño en lugar de Ancho de pantalla más pequeño. Seleccione Grande . El nombre del directorio se generará automáticamente.
Haga clic con el botón derecho en el directorio como antes para crear el archivo bools.xml .
Me gustaría que las tabletas se puedan visualizar en vertical y horizontal (sw600dp o superior), pero que los teléfonos se restrinjan a solo retrato. No puedo encontrar ninguna forma de elegir condicionalmente una orientación. ¿Alguna sugerencia?
Así es como lo hice (inspirado en http://androidblogger.blogspot.com/2011/08/orientation-for-both-phones-and-tablets.html ):
En AndroidManifest.xml, para cada actividad, desea poder cambiar entre vertical y horizontal (asegúrese de agregar screenSize: ¡no solía necesitar esto!) Aquí no necesita establecer una orientación de pantalla. :
android:configChanges="keyboardHidden|orientation|screenSize"
Métodos para agregar en cada actividad:
public static boolean isXLargeScreen(Context context) {
return (context.getResources().getConfiguration().screenLayout
& Configuration.SCREENLAYOUT_SIZE_MASK)
>= Configuration.SCREENLAYOUT_SIZE_XLARGE;
}
y: (si no anula este método, la aplicación llamará aCreate () cuando cambie las orientaciones)
@Override
public void onConfigurationChanged (Configuration newConfig)
{
super.onConfigurationChanged(newConfig);
if (!isXLargeScreen(getApplicationContext()) ) {
return; //keep in portrait mode if a phone
}
//I set background images for landscape and portrait here
}
En onCreate () de cada actividad:
if (!isXLargeScreen(getApplicationContext())) { //set phones to portrait;
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
else {
//I set background images here depending on portrait or landscape orientation
}
Lo único que no logro entender es cómo lograr que la aplicación cambie los archivos de diseño al cambiar de paisaje a retrato o viceversa. Supongo que la respuesta es hacer algo similar a lo que hace el enlace de arriba, pero no pude hacer que funcione para mí, borró todos mis datos. Pero si tiene una aplicación lo suficientemente simple como para tener el mismo archivo de diseño para retrato y paisaje, esto debería funcionar.
Bueno, esto es un poco tarde, pero aquí hay una solución de XML, pero una solución de hack que no recrea una actividad, ya que setRequestedOrientation sí tiene que cambiar la orientación:
https://.com/a/27015879/1281930
Desafortunadamente, usar el método setRequestedOrientation(...) hará que la actividad se reinicie, por lo que incluso si llama esto en el método onCreate, pasará por el ciclo de vida de la actividad y luego volverá a crear la misma actividad en la orientación solicitada. Por lo tanto, en la respuesta de @Brian Christensen, debe tener en cuenta que el código de actividad puede ser llamado dos veces, esto podría tener efectos negativos (no solo visuales, sino también en solicitudes de red, análisis, etc.).
Además, establecer el atributo configChanges en el manifiesto es, en mi opinión, una gran desventaja, que podría tomar un costo masivo de refactorización. Los desarrolladores de Android no recomiendan cambiar ese atributo .
Finalmente, tratar de configurar la pantalla de orientación de alguna manera diferente (para evitar el problema de reinicio) es imposible, estáticamente imposible debido al manifiesto estático que no se puede cambiar, programáticamente solo es posible llamar a ese método en la actividad ya iniciada.
Resumen: En mi opinión, la sugerencia de @Brian Christensen es la mejor solución de compromiso, pero tenga en cuenta el problema de la actividad de reinicio.
Esta es una buena forma de usar resources y calificadores de tamaño .
Pon este recurso bool en res / values como bools.xml o lo que sea (los nombres de archivo no importan aquí):
<?xml version="1.0" encoding="utf-8"?>
<resources>
<bool name="portrait_only">true</bool>
</resources>
Pon este en res / values-sw600dp y res / values-xlarge:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<bool name="portrait_only">false</bool>
</resources>
Consulte esta respuesta complementaria para obtener ayuda al agregar estos directorios y archivos en Android Studio.
Luego, en el método onCreate de sus actividades, puede hacer esto:
if(getResources().getBoolean(R.bool.portrait_only)){
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
Los dispositivos que tienen más de 600 dp en la dirección de ancho más pequeño o x-large en los dispositivos anteriores a Android 3.2 (tabletas, básicamente) se comportarán de forma normal, en función del sensor y la rotación bloqueada por el usuario, etc. Todo lo demás (teléfonos, casi) será solo retrato.
Puede intentarlo de esta manera primero obtener el tamaño de pantalla del dispositivo
if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
Toast.makeText(this, "Large screen",Toast.LENGTH_LONG).show();
}
else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
Toast.makeText(this, "Normal sized screen" , Toast.LENGTH_LONG).show();
}
else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
Toast.makeText(this, "Small sized screen" , Toast.LENGTH_LONG).show();
}
else {
Toast.makeText(this, "Screen size is neither large, normal or small" , Toast.LENGTH_LONG).show();
}
y luego establecer la orientación de acuerdo con ese
setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
Siguiendo la respuesta de Ginny , creo que la forma más confiable de hacerlo es la siguiente:
Como se describe here , ponga un valor booleano en los recursos sw600dp. Debe tener el prefijo sw; de lo contrario, no funcionará correctamente:
en res / values-sw600dp / dimens.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<bool name="isTablet">true</bool>
</resources>
en res / values / dimens.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<bool name="isTablet">false</bool>
</resources>
Luego crea un método para recuperar ese booleano:
public class ViewUtils {
public static boolean isTablet(Context context){
return context.getResources().getBoolean(R.bool.isTablet);
}
}
Y una actividad base para extender desde las actividades en las que desea este comportamiento:
public abstract class BaseActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (!ViewUtils.isTablet(this)) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
}
}
Entonces cada actividad extendería BaseActivity:
public class LoginActivity extends BaseActivity //....
Importante : incluso si se extiende desde BaseActivity , debe agregar la línea android:configChanges="orientation|screenSize" a cada Activity en su AndroidManifest.xml:
<activity
android:name=".login.LoginActivity"
android:configChanges="orientation|screenSize">
</activity>
Vieja pregunta que sé Para ejecutar su aplicación siempre en modo vertical, incluso cuando la orientación puede cambiarse o cambiarse, etc. (por ejemplo, en tabletas) diseñé esta función que se usa para configurar el dispositivo en la orientación correcta sin la necesidad de saber cómo el retrato y el paisaje las funciones están organizadas 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!
AVISO: Cambie this.activity actividad por su actividad o agréguela a la actividad principal y elimine esta this.activity ;-)
Si quieres hacer lo contrario, debes cambiar el código a horizontal (pero creo que está claro cómo hacerlo).