Actividad de pantalla completa en Android?


Respuestas:


1052

Puedes hacerlo programáticamente:

public class ActivityName extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // remove title
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.main);
    }
}

O puede hacerlo a través de su AndroidManifest.xmlarchivo:

<activity android:name=".ActivityName"
    android:label="@string/app_name"
    android:theme="@android:style/Theme.NoTitleBar.Fullscreen"/>

Editar:

Si está utilizando AppCompatActivity, entonces necesita agregar un nuevo tema

<style name="Theme.AppCompat.Light.NoActionBar.FullScreen" parent="@style/Theme.AppCompat.Light.NoActionBar">
    <item name="android:windowNoTitle">true</item>
    <item name="android:windowActionBar">false</item>
    <item name="android:windowFullscreen">true</item>
    <item name="android:windowContentOverlay">@null</item>
</style>

y luego úsalo.

<activity android:name=".ActivityName"
    android:label="@string/app_name"
    android:theme="@style/Theme.AppCompat.Light.NoActionBar.FullScreen"/>

Gracias a https://stackoverflow.com/a/25365193/1646479


65
solo el atributo android: theme = "@ android: style / Theme.NoTitleBar.Fullscreen" en su actividad en el manifiesto es suficiente. Gracias :)
Praveen

19
Si su aplicación usa cualquier otro tema, use el nombre del tema correspondiente, por ejemplo, para el tema blanco @android:style/Theme.Holo.Light.NoActionBar.Fullscreen
ankitjaininfo

55
Establecer el tema en manifiesto provoca una pantalla negra en el inicio, es mejor hacerlo en código.
aurelien_lepage

44
si está utilizando ActionBar y simplemente no quiere TitleBar, elimine la línea `requestWindowFeature () 'ya que de lo contrario esto causará un NullPointer
X.X_Mass_Developer

3
Si está utilizando AppCompatActivity, debe poner requestWindowFeatureantes super.onCreate. De lo contrario, obtendrá:android.util.AndroidRuntimeException: requestFeature() must be called before adding content
Slav

128

Hay una técnica llamada Modo inmersivo de pantalla completa disponible en KitKat . Demostración inmersiva en modo de pantalla completa

Ejemplo


55
Solo tenga en cuenta que se mostrará una "burbuja de recordatorio" la primera vez que su aplicación entre en modo inmersivo. Esto está bien para algunas actividades, pero no si está haciendo una pantalla de bienvenida, por ejemplo.
LarsH

se rompe cuando se utiliza hiladores
ViVekH

desea ocultar solo la barra de navegación inferior, no la barra de estado. Es posible de hacer?
PvDev

76

Si no desea usar el tema @android:style/Theme.NoTitleBar.Fullscreenporque ya está usando un tema propio, puede usarlo android:windowFullscreen.

En AndroidManifest.xml:

<activity
  android:name=".ui.activity.MyActivity"
  android:theme="@style/MyTheme">
</activity>

En styles.xml:

<style name="MyTheme"  parent="your parent theme">
  <item name="android:windowNoTitle">true</item>
  <item name="android:windowFullscreen">true</item> 
</style>

agregar padre como tema principal
Saurabh Bhandari

también debe colocar <item name = "windowActionBar"> false </item>
htafoya

52

En el archivo AndroidManifest.xml :

<activity
    android:name=".Launch"
    android:label="@string/app_name"
    android:theme="@android:style/Theme.NoTitleBar.Fullscreen" > <!-- This line is important -->

    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>  

O en código Java :

protected void onCreate(Bundle savedInstanceState){
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
}

2
debes agregar un código para hacer eso programáticamente en JAVA
Dr. anDRO

2
requestWindowFeature (Window.FEATURE_NO_TITLE); getWindow (). setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
iNFInite PosSibiLitiEs

desea ocultar solo la barra de navegación inferior, no la barra de estado. Es posible de hacer?
PvDev

32

Si estás usando AppCompat y ActionBarActivity, entonces usa esto

getSupportActionBar().hide();


Esto no eliminará la barra de estado en la parte superior
Manohar Reddy

24

Ten cuidado con

requestWindowFeature(Window.FEATURE_NO_TITLE);

Si está utilizando algún método para establecer la barra de acción de la siguiente manera:

getSupportActionBar().setHomeButtonEnabled(true);

Causará una excepción de puntero nulo.


¡La razón es porque estás ajustando la barra de acción, que el código de cambio de tamaño está tratando de ocultar!
Andy

22

Prueba esto con appcompat de style.xml. Proporciona soporte para todas las plataformas.

<!-- Application theme. -->
<style name="AppTheme.FullScreen" parent="AppTheme">
    <item name="android:windowFullscreen">true</item>
</style>


<!-- Application theme. -->
<style name="AppTheme" parent="@style/Theme.AppCompat.Light.NoActionBar" />

Solución agradable y fácil. Para los novatos, agregue este tema en la etiqueta Actividad o Aplicación en AndroidManifest.xml: android: theme = "@ style / AppTheme.FullScreen"
Leos Literak

1
desea ocultar solo la barra de navegación inferior, no la barra de estado. Es posible de hacer?
PvDev

13

Usar Android Studio (la versión actual es 2.2.2 en este momento) es muy fácil de agregar una actividad de pantalla completa.

Mira los pasos:

  1. Haga clic derecho en su paquete principal de Java> Seleccione "Nuevo"> Seleccione "Actividad"> Luego, haga clic en "Actividad de pantalla completa".

Paso uno

  1. Personalice la actividad (“Nombre de la actividad”, “Nombre del diseño”, etc.) y haga clic en “finalizar”.

Segundo paso

¡Hecho!

¡Ahora tiene una actividad de pantalla completa hecha fácilmente (vea la clase de Java y el diseño de la actividad para saber cómo funcionan las cosas)!


8

Para aquellos que usan AppCompact ... style.xml

 <style name="Xlogo" parent="Theme.AppCompat.DayNight.NoActionBar">
    <item name="android:windowNoTitle">true</item>
    <item name="android:windowFullscreen">true</item>
</style>

Luego pon el nombre en tu manifiesto ...


7

Primero debes configurar el tema de tu aplicación con "NoActionBar" como a continuación

<!-- Application theme. -->
<style name="AppTheme" parent="@style/Theme.AppCompat.Light.NoActionBar" />

Luego agregue estas líneas en su actividad de pantalla completa.

public class MainActiviy extends AppCompatActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                                  WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.main);
    }
}

Ocultará la barra de acción / barra de herramientas y también la barra de estado en su actividad de pantalla completa


7

AndroidManifest.xml

<activity ...
          android:theme="@style/FullScreenTheme"
    >
</activity>

I. Su aplicación principal, el tema es Theme.AppCompat.Light.DarkActionBar

Para ocultar ActionBar / StatusBar
style.xml

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    ...
</style>

<style name="FullScreenTheme" parent="AppTheme">
    <!--this property will help hide the ActionBar-->
    <item name="windowNoTitle">true</item>
    <!--currently, I don't know why we need this property since use windowNoTitle only already help hide actionbar. I use it because it is used inside Theme.AppCompat.Light.NoActionBar (you can check Theme.AppCompat.Light.NoActionBar code). I think there are some missing case that I don't know-->
    <item name="windowActionBar">false</item>
    <!--this property is used for hiding StatusBar-->
    <item name="android:windowFullscreen">true</item>
</style>

Para ocultar la barra de navegación del sistema

public class MainActivity extends AppCompatActivity {

    protected void onCreate(Bundle savedInstanceState) {
        getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
        setContentView(R.layout.activity_main)
        ...
    }
 }

II El tema principal de su aplicación es Theme.AppCompat.Light.NoActionBar

Para ocultar ActionBar / StatusBar
style.xml

<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
    ...
</style>

<style name="FullScreenTheme" parent="AppTheme">
    <!--don't need any config for hide ActionBar because our apptheme is NoActionBar-->
    <!--this property is use for hide StatusBar-->
    <item name="android:windowFullscreen">true</item> // 
</style>

Para ocultar la barra de navegación del sistema

Similar como Theme.AppCompat.Light.DarkActionBar.

Manifestación


Gracias. Probado en Android 5.0.1.
CoolMind

@CoolMind nos vemos de nuevo. Gracias por su edición
Phan Van Linh

6

gracias por responder @Cristian recibí un error

android.util.AndroidRuntimeException: se debe llamar a requestFeature () antes de agregar contenido

resolví esto usando

@Override
protected void onCreate(Bundle savedInstanceState) {

    requestWindowFeature(Window.FEATURE_NO_TITLE);

    super.onCreate(savedInstanceState);

    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

    setContentView(R.layout.activity_login);

    -----
    -----
}

¿Deberíamos establecer requestWindowFeature(Window.FEATURE_NO_TITLE);antes super.onCreate(savedInstanceState);?
CoolMind

4

mostrar inmersivo completo:

private void askForFullScreen()
    {
        getActivity().getWindow().getDecorView().setSystemUiVisibility(
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                        | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION // hide nav bar
                        | View.SYSTEM_UI_FLAG_FULLSCREEN // hide status bar
                        | View.SYSTEM_UI_FLAG_IMMERSIVE);
    }

salir del modo inmersivo completo:

 private void moveOutOfFullScreen() {
        getActivity().getWindow().getDecorView().setSystemUiVisibility(
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                        | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
    }

3

Quería usar mi propio tema en lugar de usar @android: style / Theme.NoTitleBar.Fullscreen. Pero no estaba funcionando como lo había mencionado alguna publicación aquí, así que hice algunos ajustes para resolverlo.

En AndroidManifest.xml:

<activity
    android:name=".ui.activity.MyActivity"
    android:theme="@style/MyTheme">
</activity>

En styles.xml:

<style name="MyTheme">
    <item name="android:windowNoTitle">true</item>
    <item name="android:windowActionBar">false</item>
    <item name="windowNoTitle">true</item>
    <item name="windowActionBar">false</item>
    <item name="android:windowFullscreen">true</item>
</style>

Nota: en mi caso tuve que usar en name="windowActionBar"lugar de name="android:windowActionBar"antes de que funcionara correctamente. Así que solo utilicé ambos para asegurarme en caso de que necesite portar a una nueva versión de Android más tarde.


3

Aquí hay un código de ejemplo. Puede encender / apagar banderas para ocultar / mostrar partes específicas.

ingrese la descripción de la imagen aquí

public static void hideSystemUI(Activity activity) {
    View decorView = activity.getWindow().getDecorView();
    decorView.setSystemUiVisibility(
            View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                    | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                    //| View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                    //| View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                    | View.SYSTEM_UI_FLAG_FULLSCREEN // hide status bar
                    | View.SYSTEM_UI_FLAG_IMMERSIVE);
}

Luego, restablece el estado predeterminado :

ingrese la descripción de la imagen aquí

public static void showSystemUI(Activity activity) {
    View decorView = activity.getWindow().getDecorView();
    decorView.setSystemUiVisibility(
            View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                    | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                    | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
}

Puede llamar a las funciones anteriores desde su onCreate:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.course_activity);
    UiUtils.hideSystemUI(this);
}

3

KOTLIN

Siguiendo el documento de google, hay una manera fácil:

override fun onWindowFocusChanged(hasFocus: Boolean) {
super.onWindowFocusChanged(hasFocus)
if (hasFocus) hideSystemUI() }


private fun hideSystemUI() {
// Enables regular immersive mode.
// For "lean back" mode, remove SYSTEM_UI_FLAG_IMMERSIVE.
// Or for "sticky immersive," replace it with SYSTEM_UI_FLAG_IMMERSIVE_STICKY
window.decorView.systemUiVisibility = (View.SYSTEM_UI_FLAG_IMMERSIVE
        // Set the content to appear under the system bars so that the
        // content doesn't resize when the system bars hide and show.
        or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
        or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
        or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
        // Hide the nav bar and status bar
        or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
        or View.SYSTEM_UI_FLAG_FULLSCREEN)      }


// Shows the system bars by removing all the flags
// except for the ones that make the content appear under the system bars.
private fun showSystemUI() {
window.decorView.systemUiVisibility = 
(View.SYSTEM_UI_FLAG_LAYOUT_STABLE
        or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
        or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN)       }

Google docs


2

CONSEJO: ¡El uso de getWindow (). SetLayout () puede arruinar su visualización de pantalla completa! Tenga en cuenta que la documentación para este método dice:

Establezca los parámetros de diseño de ancho y alto de la ventana ... puede cambiarlos a ... un valor absoluto para crear una ventana que no sea de pantalla completa.

http://developer.android.com/reference/android/view/Window.html#setLayout%28int,%20int%29

Para mis propósitos, descubrí que tenía que usar setLayout con parámetros absolutos para cambiar el tamaño de mi ventana de pantalla completa correctamente. La mayoría de las veces, esto funcionó bien. Fue invocado por un evento onConfigurationChanged (). Hubo un hipo, sin embargo. Si el usuario salió de la aplicación, cambió la orientación y volvió a ingresar, esto conduciría a desactivar mi código que incluía setLayout (). Durante esta ventana de tiempo de reingreso, mi barra de estado (que estaba oculta por el manifiesto) volvería a aparecer, ¡pero en cualquier otro momento setLayout () no causaría esto! La solución fue agregar una llamada setLayout () adicional después de la que tiene los valores rígidos de la siguiente manera:

       public static void setSize( final int width, final int height ){
//DO SOME OTHER STUFF...
            instance_.getWindow().setLayout( width, height );
            // Prevent status bar re-appearance
            Handler delay = new Handler();
            delay.postDelayed( new Runnable(){ public void run() {
                instance_.getWindow().setLayout(
                    WindowManager.LayoutParams.FILL_PARENT,
                    WindowManager.LayoutParams.FILL_PARENT );
            }}, FILL_PARENT_ON_RESIZE_DELAY_MILLIS );
        }

La ventana se redimensionó correctamente y la barra de estado no volvió a aparecer independientemente del evento que desencadenó esto.


2
 @Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    adjustFullScreen(newConfig);
}

@Override
public void onWindowFocusChanged(boolean hasFocus) {
    super.onWindowFocusChanged(hasFocus);
    if (hasFocus) {
        adjustFullScreen(getResources().getConfiguration());
    }
}
private void adjustFullScreen(Configuration config) {
    final View decorView = getWindow().getDecorView();
    if (config.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        decorView.setSystemUiVisibility(
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                        | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
    } else {
        decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
    }
}

2

Inside styles.xml ...

<!-- No action bar -->
<style name="NoActonBar" parent="Theme.AppCompat.Light.NoActionBar">
    <!-- Theme customization. -->
    <item name="colorPrimary">#000</item>
    <item name="colorPrimaryDark">#444</item>
    <item name="colorAccent">#999</item>
    <item name="android:windowFullscreen">true</item>
</style>

Esto funcionó para mí. Espero que te ayude.


2

Con Kotlin, así es como lo hice:

class LoginActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_login)
        window.decorView.systemUiVisibility =
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
                View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or
                View.SYSTEM_UI_FLAG_FULLSCREEN

    }
}

Modo inmersivo

El modo inmersivo está destinado a aplicaciones en las que el usuario interactuará fuertemente con la pantalla. Ejemplos son juegos, ver imágenes en una galería o leer contenido paginado, como un libro o diapositivas en una presentación. Para esto, solo agregue estas líneas:

View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION

Inmersivo pegajoso

En el modo inmersivo normal, cada vez que un usuario se desliza desde un borde, el sistema se encarga de revelar las barras del sistema; su aplicación ni siquiera se dará cuenta de que ocurrió el gesto. Por lo tanto, si el usuario realmente necesita deslizarse desde el borde de la pantalla como parte de la experiencia de la aplicación principal, como cuando juega un juego que requiere mucho deslizamiento o usa una aplicación de dibujo, debe habilitar el modo inmersivo "adhesivo" .

View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY

Para más información: habilitar el modo de pantalla completa

En caso de que esté usando el teclado, a veces sucede que StatusBar aparece cuando aparece el teclado. En ese caso, generalmente agrego esto a mi estilo xml

styles.xml

<style name="FullScreen" parent="AppTheme">
    <item name="android:windowFullscreen">true</item>
</style>

Y también esta línea a mi manifiesto

<activity
        android:name=".ui.login.LoginActivity"
        android:label="@string/title_activity_login"
        android:theme="@style/FullScreen">

Gracias. Requiere API 16 y 19.
CoolMind

2

Solo pega este código en el onCreate()método

requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);

1

Funcionó para mi.

if (Build.VERSION.SDK_INT < 16) {
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
    } else {
        View decorView = getWindow().getDecorView();
        int uiOptions = View.SYSTEM_UI_FLAG_FULLSCREEN;
        decorView.setSystemUiVisibility(uiOptions);
    }

1
En el caso contrario, sería mejor usar lo siguiente: getWindow (). GetDecorView (). SetSystemUiVisibility (View.SYSTEM_UI_FLAG_FULLSCREEN);
Protonflux

1
 protected void onCreate(Bundle savedInstanceState) {
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    super.onCreate(savedInstanceState);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
    setContentView(R.layout.activity_splash_screen);
    getSupportActionBar().hide();

}

1

Después de mucho tiempo sin éxito, llegué con mi propia solución, que es bastante similar a la de otro desarrollador. Entonces, si alguien la necesita, mi problema era que la barra de navegación del sistema no se ocultaba después de llamar. También en mi caso necesitaba paisaje, así que por si acaso comentar esa línea y todo eso. Antes que nada crear estilo

    <style name="FullscreenTheme" parent="AppTheme">
    <item name="android:actionBarStyle">@style/FullscreenActionBarStyle</item>
    <item name="android:windowActionBarOverlay">true</item>
    <item name="android:windowBackground">@null</item>
    <item name="metaButtonBarStyle">?android:attr/buttonBarStyle</item>
    <item name="metaButtonBarButtonStyle">?android:attr/buttonBarButtonStyle</item>
</style>

Este es mi archivo de manifiesto

<activity
        android:name=".Splash"
        android:screenOrientation="landscape"
        android:configChanges="orientation|keyboard|keyboardHidden|screenLayout|screenSize"
        android:label="@string/app_name"
        android:theme="@style/SplashTheme">

        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

    <activity
        android:name=".MainActivity"
        android:configChanges="orientation|keyboard|keyboardHidden|screenLayout|screenSize"
        android:screenOrientation="landscape"
        android:label="@string/app_name"
        android:theme="@style/FullscreenTheme">
    </activity>

Esta es mi actividad spalsh

public class Splash extends Activity {
/** Duration of wait **/
private final int SPLASH_DISPLAY_LENGTH = 2000;

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
    super.onCreate(icicle);
    setContentView(R.layout.splash_creen);

    /* New Handler to start the Menu-Activity
     * and close this Splash-Screen after some seconds.*/
    new Handler().postDelayed(new Runnable(){
        @Override
        public void run() {
            /* Create an Intent that will start the Menu-Activity. */
            Intent mainIntent = new Intent(Splash.this,MainActivity.class);
            Splash.this.startActivity(mainIntent);
            Splash.this.finish();
        }
    }, SPLASH_DISPLAY_LENGTH);
}

}

Y esta es mi actividad principal a pantalla completa. onSystemUiVisibilityChange este método es muy importante; de ​​lo contrario, la barra de navegación principal de Android después de llamar permanecerá y no desaparecerá más. Problema realmente irritante, pero esta función resuelve ese problema.

clase pública MainActivity extiende AppCompatActivity {

private View mContentView;
@Override
public void onResume(){
    super.onResume();

    mContentView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LOW_PROFILE
            | View.SYSTEM_UI_FLAG_FULLSCREEN
            | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
            | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
            | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
            | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);

}
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.fullscreen2);
    ActionBar actionBar = getSupportActionBar();
    if (actionBar != null)
    {
        actionBar.hide();
    }
    mContentView = findViewById(R.id.fullscreen_content_text);
    mContentView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LOW_PROFILE
            | View.SYSTEM_UI_FLAG_FULLSCREEN
            | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
            | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
            | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
            | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);



    View decorView = getWindow().getDecorView();
    decorView.setOnSystemUiVisibilityChangeListener
            (new View.OnSystemUiVisibilityChangeListener()
            {
                @Override
                public void onSystemUiVisibilityChange(int visibility)
                {
                    System.out.println("print");

                    if ((visibility & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0)
                    {
                        mContentView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LOW_PROFILE
                                | View.SYSTEM_UI_FLAG_FULLSCREEN
                                | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                                | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
                                | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                                | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
                    }
                    else
                    {

                        mContentView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LOW_PROFILE
                                    | View.SYSTEM_UI_FLAG_FULLSCREEN
                                    | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                                    | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
                                    | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                                    | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);

                        }
                }
            });

}

}

Este es mi diseño de pantalla de bienvenida:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <ImageView android:id="@+id/splashscreen" android:layout_width="wrap_content"
        android:layout_height="fill_parent"
        android:background="@android:color/white"
        android:src="@drawable/splash"
        android:layout_gravity="center"/>
    <TextView android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Hello World, splash"/>
</LinearLayout>

This is my fullscreen layout
    <?xml version="1.0" encoding="utf-8"?>
    <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#0099cc"
        >
        <TextView
            android:id="@+id/fullscreen_content_text"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:gravity="center"
            android:keepScreenOn="true"
            android:text="@string/dummy_content2"
            android:textColor="#33b5e5"
            android:textSize="50sp"
            android:textStyle="bold" />

    </FrameLayout>

Espero que esto ayude


1

https://developer.android.com/training/system-ui/immersive.html

Actividad :

@Override
public void onWindowFocusChanged(boolean hasFocus) {
        super.onWindowFocusChanged(hasFocus);
    if (hasFocus) {
        decorView.setSystemUiVisibility(
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                | View.SYSTEM_UI_FLAG_FULLSCREEN
                | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
    }
}

Manifiestos de Android:

 <activity android:name=".LoginActivity"
            android:configChanges="orientation|keyboardHidden|screenSize"
            android:label="@string/title_activity_login"
            android:theme="@style/FullscreenTheme"
            ></activity>

1

Crea una actividad vacía y agrega dos líneas onCreate.

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // full screen activity
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        getSupportActionBar().hide();

        setContentView(R.layout.activity_main);
    }
    ...
}

1

Use este método después de setContentView en onCreate () y pase el objeto Window por getWindow () .

    public void makeActivityFullScreen(Window window){
    View decorView = window.getDecorView();
    //        int uiOptions = View.SYSTEM_UI_FLAG_FULLSCREEN;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
       window.getAttributes().layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;
    }
    decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LOW_PROFILE
            | View.SYSTEM_UI_FLAG_FULLSCREEN
            | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
            | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
            | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
            | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
    );
}

Este código también funcionará para la pantalla de muesca. Para verificar la pantalla completa de la muesca, necesita Android P, pero si tiene un teléfono con pantalla de muesca, vaya a configuración -> Configuración de pantalla -> relación de visualización de la aplicación ---> seleccione su aplicación ---> habrá dos opciones seguras pantalla y pantalla completa, seleccione la pantalla completa y ejecute la aplicación, puede ver la pantalla completa en la muesca también sin tener Android Pie


1

Para hacer su actividad a pantalla completa, haga esto:

    // add following lines before setContentView
    // to hide toolbar
                if(getSupportActionBar()!=null)
                    getSupportActionBar().hide();
    //to hide status bar
                getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                    WindowManager.LayoutParams.FLAG_FULLSCREEN);

Esto ocultará la barra de herramientas y la barra de estado.

Pero en algunos casos, es posible que desee mostrar la barra de estado con un fondo transparente, en ese caso, haga lo siguiente:

// add following lines before setContentView
// to hide toolbar
if(getSupportActionBar()!=null)
   getSupportActionBar().hide();
// to make status bar transparent
getWindow().setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);

Algunas otras alternativas para ocultar la barra de herramientas en lugar de getSupportActionBar().hide():

  1. Elimine la barra de herramientas cambiando el tema principal de la aplicación:

<style name="AppTheme" parent="Theme.AppCompat.NoActionBar">

  1. Si desea eliminar la barra de herramientas de una sola actividad, vaya a manifiesto, en la etiqueta de actividad agregue esto: android:theme="@style/Theme.AppCompat.Light.NoActionBar"

Para los amantes de kotlin , ¿por qué no utilizar las funciones de extensión?

Para el primer caso:

fun AppCompatActivity.makeItFullScreenStatusBarVisible(){
    supportActionBar?.hide()
    window.setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS)
}

Y llame a esto antes setContentView:

makeItFullScreenStatusBarVisible()

Para el segundo:

fun AppCompatActivity.makeItFullScreenStatusBarHidden(){
    supportActionBar?.hide()
    window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN)
}

Y llámalo antes setContentView:

makeItFullScreenStatusBarHidden()

0

En Android 10, ninguno funcionó para mí.

Pero eso funcionó perfectamente bien (primera línea en oncreate):

    View decorView = getWindow().getDecorView();
    int uiOptions = View.SYSTEM_UI_FLAG_IMMERSIVE;
    decorView.setSystemUiVisibility(uiOptions);

    setContentView(....);

    if (getSupportActionBar() != null) {
        getSupportActionBar().hide();
    }

disfruta :)


0

Para mostrar contenido a través de la muesca o el área recortada. Esto puede ayudar de los documentos:

LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES: el contenido se muestra en el área recortada tanto en modo vertical como horizontal.

Lo clave para mí fue esta línea en el estilo de actividad:

// Important to draw through the cutouts
<item name="android:windowLayoutInDisplayCutoutMode">shortEdges</item> 

Para mí, quería mostrar una imagen en modo inmersivo. Cuando hago clic en él, quiero que aparezca la IU del sistema (barras de estado y navegación).

Aquí está mi solución:

1- En la Actividad, algunos métodos para mostrar / ocultar la IU del sistema (barras de estado / navegación)

private fun hideSystemUI() {
    sysUIHidden = true
    window.decorView.systemUiVisibility = (
            View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
            or View.SYSTEM_UI_FLAG_LAYOUT_STABLE 
            // Hide the nav bar and status bar
            or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION // Hide nav bar
            or View.SYSTEM_UI_FLAG_FULLSCREEN // Hide status bar
            )
}


private fun showSystemUI() {
    sysUIHidden = false
    window.decorView.systemUiVisibility = (
            View.SYSTEM_UI_FLAG_LAYOUT_STABLE
            // Set the content to appear under the system bars so that the
            // content doesn't resize when the system bars hide and show.
            or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION // layout Behind nav bar
            or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN // layout Behind status bar
            )
}

2- Asegúrese de esto en la vista raíz de su diseño xml

android:fitsSystemWindows="false"

3- El estilo para la actividad de pantalla completa le dará a las barras de estado / navegación un fondo semitransparente cuando aparezcan:

<style name="FullscreenTheme" parent="AppTheme">
    <item name="android:actionBarStyle">@style/FullscreenActionBarStyle</item>
    <item name="android:windowActionBarOverlay">true</item>
    <item name="android:windowBackground">@null</item>
    <item name="metaButtonBarStyle">?android:attr/buttonBarStyle</item>
    <item name="metaButtonBarButtonStyle">?android:attr/buttonBarButtonStyle</item>
    <item name="android:statusBarColor">#50000000</item>
    <item name="android:navigationBarColor">#50000000</item>
    // Important to draw behind cutouts
    <item name="android:windowLayoutInDisplayCutoutMode">shortEdges</item> 
</style>

<style name="FullscreenActionBarStyle" parent="Widget.AppCompat.ActionBar">
    <item name="android:background">@color/sysTransparent</item>
</style>
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.