Atividade em tela cheia no Android?

Respostas:

1052

Você pode fazer isso programaticamente:

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

Ou você pode fazer isso através do seu AndroidManifest.xmlarquivo:

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

Editar:

Se você estiver usando AppCompatActivity, precisará adicionar um novo 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>

e depois use.

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

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

Cristian
fonte
65
apenas o atributo android: theme = "@ android: style / Theme.NoTitleBar.Fullscreen" em sua atividade no manifesto é suficiente. Obrigado :)
Praveen
19
Se o seu aplicativo usa qualquer outro nome do tema uso tema correspondente tema por exemplo, para Branco @android:style/Theme.Holo.Light.NoActionBar.Fullscreen
ankitjaininfo
5
Definir o tema no manifesto causa uma tela preta ao iniciar, é melhor fazê-lo no código.
Aurelien_lepage 28/02
4
se você estiver usando ActionBar e apenas quero nenhum TitleBar remover a linha `requestWindowFeature ()', pois isso irá causar um NullPointer de outra forma
X.X_Mass_Developer
3
Se você estiver usando AppCompatActivity, você precisa colocar requestWindowFeatureantes super.onCreate. Caso contrário, você receberá:android.util.AndroidRuntimeException: requestFeature() must be called before adding content
Slav
128

Existe uma técnica chamada Modo Imersivo em Tela Cheia disponível no KitKat . Demonstração imersiva do modo de tela cheia

Exemplo

Dmide
fonte
5
Lembre-se de que um "balão de lembrete" será exibido na primeira vez em que seu aplicativo entrar no modo imersivo. Isso é bom para algumas atividades, mas não se você estiver fazendo uma tela inicial, por exemplo.
LarsH 12/08/2015
quebras ao usar spinners
ViVekH
deseja ocultar apenas a barra de navegação inferior e não a barra de status. É possível fazer?
PvDev
76

Se você não quiser usar o tema @android:style/Theme.NoTitleBar.Fullscreenporque já está usando um tema de sua preferência, poderá usá-lo android:windowFullscreen.

No AndroidManifest.xml:

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

Em styles.xml:

<style name="MyTheme"  parent="your parent theme">
  <item name="android:windowNoTitle">true</item>
  <item name="android:windowFullscreen">true</item> 
</style>
Ariel Cabib
fonte
adicionar pai como tema principal
Saurabh Bhandari 29/17
você precisa colocar <item name = "windowActionBar"> false </item> também
htafoya
52

No arquivo 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>  

Ou no código Java :

protected void onCreate(Bundle savedInstanceState){
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
}
possibilidades infinitas
fonte
2
você deve adicionar um código para fazer essa coisa de programação em JAVA
Dr. Andro
2
requestWindowFeature (Window.FEATURE_NO_TITLE); getWindow (). setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
infinitas possibilidades
deseja ocultar apenas a barra de navegação inferior e não a barra de status. É possível fazer?
PvDev
32

Se você estiver usando AppCompat e ActionBarActivity, use este

getSupportActionBar().hide();

Bala Vishnu
fonte
Isto não irá remover barra de status no topo
Manohar Reddy
24

Seja cuidadoso com

requestWindowFeature(Window.FEATURE_NO_TITLE);

Se você estiver usando algum método para definir a barra de ação da seguinte maneira:

getSupportActionBar().setHomeButtonEnabled(true);

Isso causará uma exceção de ponteiro nulo.

jiahao
fonte
O motivo é porque você está ajustando a barra de ação, que o código de redimensionamento está tentando ocultar!
Andy
22

Tente isso com appcompat de style.xml. Ele fornece suporte para todas as 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" />
Rohit Suthar
fonte
solução agradável e fácil. Para iniciantes, adicione este tema na atividade ou tag Aplicação em AndroidManifest.xml: android: theme = "@ estilo / AppTheme.FullScreen"
Leos Literak
1
deseja ocultar apenas a barra de navegação inferior e não a barra de status. É possível fazer?
PvDev
13

O uso do Android Studio (a versão atual é 2.2.2 no momento) é muito fácil de adicionar uma atividade em tela cheia.

Veja os passos:

  1. Clique com o botão direito do mouse no pacote principal do java> Selecione "Novo"> Selecione "Atividade"> Em seguida, clique em "Atividade em tela cheia".

Passo um

  1. Personalize a atividade ("Nome da atividade", "Nome do layout" e assim por diante) e clique em "Concluir".

Passo dois

Feito!

Agora você tem uma atividade em tela cheia feita com facilidade (consulte a classe java e o layout da atividade para saber como as coisas funcionam)!

Filipe Brito
fonte
8

Para aqueles que usam AppCompact ... style.xml

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

Em seguida, coloque o nome no seu manifesto ...

X-preto ...
fonte
7

Primeiro, você deve definir o tema do seu aplicativo com "NoActionBar", como abaixo

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

Em seguida, adicione essas linhas na sua atividade de tela cheia.

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

Ele ocultará a barra de ação / barra de ferramentas e também a barra de status em sua atividade de tela cheia

Rajesh Peram
fonte
7

AndroidManifest.xml

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

I. Seu aplicativo principal, o tema é 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 a barra de navegação do 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 O tema principal do seu aplicativo é 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 a barra de navegação do sistema

Semelhante como Theme.AppCompat.Light.DarkActionBar.

Demo

Phan Van Linh
fonte
Obrigado. Testado no Android 5.0.1.
CoolMind 24/09
@CoolMind encontro você novamente. Obrigado por seu edittion
Phan Van Linh
6

obrigado pela resposta @Cristian eu estava recebendo erro

android.util.AndroidRuntimeException: requestFeature () deve ser chamado antes de adicionar conteúdo

eu resolvi isso 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);

    -----
    -----
}
Bikesh M
fonte
Devemos definir requestWindowFeature(Window.FEATURE_NO_TITLE);antes super.onCreate(savedInstanceState);?
CoolMind
4

show Imersivo total:

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

saia do modo imersivo 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);
    }
Gal Rom
fonte
3

Eu queria usar meu próprio tema em vez de usar @android: style / Theme.NoTitleBar.Fullscreen. Mas não estava funcionando como algum post aqui mencionou, então fiz alguns ajustes para descobrir isso.

No AndroidManifest.xml:

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

Em 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: no meu caso, eu tive que usar em name="windowActionBar"vez de name="android:windowActionBar"antes que funcionasse corretamente. Então, usei os dois para garantir que, no caso, precise portar para uma nova versão do Android mais tarde.

Chef Faraó
fonte
3

Aqui está um código de exemplo. Você pode ativar / desativar sinalizadores para ocultar / mostrar partes específicas.

insira a descrição da imagem aqui

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

Em seguida, você redefine para o estado padrão :

insira a descrição da imagem aqui

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

Você pode chamar as funções acima em onCreate:

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

KOTLIN

Após o documento do google, existe uma maneira 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)       }

Documentos Google

Álvaro Agüero
fonte
2

DICA: O uso de getWindow (). SetLayout () pode danificar sua exibição em tela cheia! Observe que a documentação deste método diz:

Defina os parâmetros de layout de largura e altura da janela ... você pode alterá-los para ... um valor absoluto para criar uma janela que não seja de tela cheia.

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

Para meus propósitos, descobri que precisava usar setLayout com parâmetros absolutos para redimensionar minha janela de tela cheia corretamente. Na maioria das vezes, isso funcionava bem. Foi chamado por um evento onConfigurationChanged (). Houve um soluço, no entanto. Se o usuário saísse do aplicativo, alterasse a orientação e entrasse novamente, isso levaria ao disparo do meu código, que incluía setLayout (). Durante essa janela de tempo de reinserção, minha barra de status (que estava oculta pelo manifesto) seria exibida novamente, mas em qualquer outro momento setLayout () não causaria isso! A solução foi adicionar uma chamada setLayout () adicional após a chamada com os valores físicos assim:

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

A janela foi redimensionada corretamente e a barra de status não reapareceu, independentemente do evento que provocou isso.

BuvinJ
fonte
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);
    }
}
Tarun konda
fonte
2

Por dentro 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>

Isso funcionou para mim. Espero que ajude você.

Anuj Sain
fonte
2

Com o kotlin, é assim que eu faço:

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 imersivo

O modo imersivo é destinado a aplicativos nos quais o usuário estará interagindo fortemente com a tela. Exemplos são jogos, exibição de imagens em uma galeria ou leitura de conteúdo paginado, como um livro ou slides em uma apresentação. Para isso, basta adicionar estas linhas:

View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION

Pegajoso imersivo

No modo imersivo regular, sempre que um usuário passa de uma borda, o sistema cuida de revelar as barras do sistema - seu aplicativo nem perceberá que o gesto ocorreu. Portanto, se o usuário precisar deslizar a partir da borda da tela como parte da experiência principal do aplicativo - como jogar um jogo que exige muita troca ou uso de um aplicativo de desenho - você deve ativar o modo imersivo "aderente" .

View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY

Para mais informações: Ative o modo de tela cheia

No caso de você usar o teclado, às vezes acontece que a StatusBar é exibida quando o teclado é exibido. Nesse caso, eu costumo adicionar isso ao meu estilo xml

styles.xml

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

E também esta linha para o meu manifesto

<activity
        android:name=".ui.login.LoginActivity"
        android:label="@string/title_activity_login"
        android:theme="@style/FullScreen">
Jorge Casariego
fonte
Obrigado. Requer API 16 e 19.
CoolMind 16/07/2018
2

Basta colar esse código no onCreate()método

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

Funcionou para mim.

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);
    }
Singh
fonte
1
No resto, seria melhor usar o seguinte: 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();

}
Sai Gopi N
fonte
1

Depois de muito tempo sem sucesso, eu vim com minha própria solução, que é semelhante a outro desenvolvedor. O problema é que a barra de navegação do sistema não estava escondida depois de ligar. Também no meu caso, eu precisava de paisagem, por isso, comente essa linha e tudo isso. Antes de tudo, crie 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 é o meu arquivo de manifesto

<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 é a minha atividade 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);
}

}

E esta é minha principal atividade em tela cheia. onSystemUiVisibilityChange Este método é importante, caso contrário, a barra de navegação principal do Android após a chamada permanecerá e não desaparecerá mais. Problema realmente irritante, mas essa função resolve esse problema.

classe pública MainActivity estende 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 é o meu layout de tela inicial:

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

Eu espero que isso te ajude

Jevgenij Kononov
fonte
1

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

Atividade:

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

AndroidManifests:

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

Crie uma atividade vazia e adicione duas linhas 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);
    }
    ...
}
wannik
fonte
1

Use este método após setContentView em onCreate () e passe o 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 também funcionará para a tela de entalhe. Para verificar a tela cheia do entalhe, é necessário o Android P, mas se você tiver um telefone com tela de entalhe, vá para configuração -> Configuração de exibição -> proporção de exibição do aplicativo ---> selecione seu aplicativo ---> haverá duas opções seguras exibição e tela cheia, selecione a tela cheia e execute o aplicativo, você pode ver a tela cheia também sem ter o Android Pie

Minion
fonte
1

Para tornar sua atividade em tela cheia, faça o seguinte:

    // 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);

Isso ocultará a barra de ferramentas e a barra de status.

Mas, em alguns casos, convém mostrar a barra de status com um plano de fundo transparente; nesse caso, faça o seguinte:

// 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);

Outra alternativa é ocultar a barra de ferramentas em vez de getSupportActionBar().hide():

  1. Remova a barra de ferramentas alterando o pai do tema do aplicativo:

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

  1. Se você deseja remover a barra de ferramentas de apenas uma atividade, vá para o manifesto, em tag de atividade, adicione isto: android:theme="@style/Theme.AppCompat.Light.NoActionBar"

Para os amantes do kotlin , por que não usar as funções de extensão:

Para o primeiro caso:

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

E chame isso antes setContentView:

makeItFullScreenStatusBarVisible()

Para o segundo:

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

E chame antes setContentView:

makeItFullScreenStatusBarHidden()
Suraj Vaishnav
fonte
0

No Android 10, nenhum funcionou para mim.

Mas eu que funcionei perfeitamente bem (1ª linha no oncreate):

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

    setContentView(....);

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

aproveitar :)

Arnaud
fonte
0

Para exibir o conteúdo através do entalhe ou da área de recorte. Isso pode ajudar nos documentos:

LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES - O conteúdo é renderizado na área de recorte nos modos retrato e paisagem.

O principal para mim foi essa linha no estilo de atividade:

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

Para mim, eu queria mostrar uma imagem no modo imersivo. Quando clico nele, quero que a interface do usuário do sistema (barras de status e navegação) seja exibida.

Aqui está a minha solução:

1- Na Atividade, alguns métodos para mostrar / ocultar a interface do usuário do sistema (barras de status / navegação)

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- Verifique se isso na visualização raiz do seu layout xml

android:fitsSystemWindows="false"

3- Estilo para a tela cheia A atividade dará às barras de status / navegação um fundo semi-transparente quando elas aparecerem:

<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>
Badr
fonte