Activité plein écran sous Android?
Comment créer une activité en plein écran? Je veux dire sans la barre de notification. Des idées?
Vous pouvez le faire par programme:
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 vous pouvez le faire via votre fichier AndroidManifest.xml:
<activity Android:name=".ActivityName"
Android:label="@string/app_name"
Android:theme="@Android:style/Theme.NoTitleBar.Fullscreen"/>
Modifier:
Si vous utilisez AppCompatActivity, vous devez ajouter un nouveau thème.
<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>
et ensuite l'utiliser.
<activity Android:name=".ActivityName"
Android:label="@string/app_name"
Android:theme="@style/Theme.AppCompat.Light.NoActionBar.Fullscreen"/>
Il existe une technique appelée Mode plein écran immersif disponible dans KitKat .
Si vous ne souhaitez pas utiliser le thème @Android:style/Theme.NoTitleBar.Fullscreen parce que vous utilisez déjà un thème de votre choix, vous pouvez utiliser Android:windowFullscreen.
Dans AndroidManifest.xml:
<activity
Android:name=".ui.activity.MyActivity"
Android:theme="@style/MyTheme">
</activity>
Dans styles.xml:
<style name="MyTheme" parent="your parent theme">
<item name="Android:windowNoTitle">true</item>
<item name="Android:windowFullscreen">true</item>
</style>
Dans AndroidManifest.xml fichier:
<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 en Java code:
protected void onCreate(Bundle savedInstanceState){
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
}
Attention à
requestWindowFeature(Window.FEATURE_NO_TITLE);
Si vous utilisez une méthode pour définir la barre d’action comme suit:
getSupportActionBar().setHomeButtonEnabled(true);
Cela provoquera une exception de pointeur nul.
Essayez ceci avec appcompat de style.xml. Il peut supporter avec toutes les plateformes.
<!-- 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" />
Utiliser Android Studio (la version actuelle est la 2.2.2 pour le moment) est très facile d’ajouter une activité en plein écran.
Voir les étapes:
- Faites un clic droit sur votre package principal Java> Sélectionnez "Nouveau"> Sélectionnez "Activité"> Cliquez ensuite sur "Activité plein écran".
- Personnalisez l'activité («Nom de l'activité», «Nom de la mise en page», etc.) et cliquez sur «Terminer».
Terminé!
Maintenant, vous avez facilement une activité plein écran (voir la classe Java et la présentation de l'activité pour savoir comment ça marche)!
Pour ceux qui utilisent AppCompact ... Style.xml
<style name="Xlogo" parent="Theme.AppCompat.DayNight.NoActionBar">
<item name="Android:windowNoTitle">true</item>
<item name="Android:windowFullscreen">true</item>
Ensuite, mettez le nom dans votre manifeste ...
merci pour la réponse @Cristian je devenais erreur
Android.util.AndroidRuntimeException: requestFeature () doit être appelé avant d'ajouter du contenu
j'ai résolu cela en utilisant
@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);
-----
-----
}
Tout d'abord, vous devez définir votre thème d'application avec "NoActionBar" comme ci-dessous
<!-- Application theme. -->
<style name="AppTheme" parent="@style/Theme.AppCompat.Light.NoActionBar" />
Ajoutez ensuite ces lignes à votre activité en plein écran.
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);
}
}
Cela cachera la barre d’action/barre d’outils ainsi que la barre d’état dans votre activité plein écran
AndroidManifest.xml
<activity ...
Android:theme="@style/FullScreenTheme"
>
</activity>
I. Le thème principal de votre application est Theme.AppCompat.Light.DarkActionBar} _
Pour masquer ActionBar/StatusBar
style.xml
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
...
</style>
<style name="FullScreenTheme" parent="AppTheme">
<!--this property will help hide 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>
Pour masquer la barre de navigation du système
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. Le thème principal de votre application est Theme.AppCompat.Light.NoActionBar} _.
Pour masquer 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>
Pour masquer la barre de navigation du système
Similaire comme Theme.AppCompat.Light.DarkActionBar.
Démo
J'espère que ça vous aidera
Je voulais utiliser mon propre thème au lieu d'utiliser @Android: style/Theme.NoTitleBar.Fullscreen. Mais cela ne fonctionnait pas comme certains postes l'ont mentionné, alors j'ai fait quelques ajustements pour le comprendre.
Dans AndroidManifest.xml:
<activity
Android:name=".ui.activity.MyActivity"
Android:theme="@style/MyTheme">
</activity>
Dans 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>
Remarque: dans mon cas, je devais utiliser name="windowActionBar" au lieu de name="Android:windowActionBar" avant que cela fonctionne correctement. Donc, je viens d'utiliser les deux pour m'assurer que dans le cas où je devrais porter une version ultérieure d'Android.
CONSEIL: Utiliser getWindow (). SetLayout () peut gâcher votre affichage plein écran! Notez que la documentation de cette méthode indique:
Définissez les paramètres de disposition de largeur et de hauteur de la fenêtre ... vous pouvez les remplacer par ... une valeur absolue pour créer une fenêtre qui n'est pas en plein écran.
http://developer.Android.com/reference/Android/view/Window.html#setLayout%28int,%20int%29
Pour mes besoins, j'ai constaté que je devais utiliser setLayout avec des paramètres absolus pour redimensionner correctement la fenêtre plein écran. La plupart du temps, cela a bien fonctionné. Il a été appelé par un événement onConfigurationChanged (). Il y a eu un hoquet, cependant. Si l'utilisateur quittait l'application, changeait d'orientation et rentrait, cela entraînerait le déclenchement de mon code contenant setLayout (). Pendant cette fenêtre temporelle de ré-entrée, ma barre d'état (masquée par le manifeste) serait réapparue, mais à tout autre moment, setLayout () ne le causerait pas! La solution consistait à ajouter un appel supplémentaire à setLayout () après celui avec les valeurs dures, comme ceci:
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 taille de la fenêtre a ensuite été redimensionnée correctement et la barre d’état n’a pas réapparu, quel que soit l’événement qui l’a déclenchée.
Voici un exemple de code. Vous pouvez activer/désactiver les drapeaux pour masquer/afficher des pièces spécifiques.
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);
}
Ensuite, vous réinitialisez à l'état default:
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);
}
Vous pouvez appeler les fonctions ci-dessus à partir de votre onCreate:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.course_activity);
UiUtils.hideSystemUI(this);
}
@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);
}
}
À l'intérieur 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>
Cela a fonctionné pour moi. J'espère que ça vous aidera.
C'est ce que j'ai fait avec kotlin:
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
}
}
Mode immersif
Le mode immersif est destiné aux applications dans lesquelles l'utilisateur interagira fortement avec l'écran. Les exemples sont les jeux, l'affichage d'images dans une galerie ou la lecture de contenu paginé, comme un livre ou des diapositives d'une présentation. Pour cela, ajoutez simplement ces lignes:
View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
Immersif collant
En mode immersif normal, chaque fois qu'un utilisateur balaie un Edge, le système se charge de révéler les barres système. Votre application ne saura même pas que le geste s'est produit. Par conséquent, si l'utilisateur peut réellement avoir besoin de glisser du bord de l'écran dans le cadre de l'expérience principale de l'application, comme lors de la lecture d'un jeu nécessitant beaucoup de balayage ou l'utilisation d'une application de dessin, vous devez activer le mode immersif .
View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
Pour plus d'informations: Activer le mode plein écran
Si vous utilisez le clavier, il arrive parfois que StatusBar indique quand le clavier apparaît. Dans ce cas, j'ajoute généralement ceci à mon style xml
styles.xml
<style name="FullScreen" parent="AppTheme">
<item name="Android:windowFullscreen">true</item>
</style>
Et aussi cette ligne à mon manifeste
<activity
Android:name=".ui.login.LoginActivity"
Android:label="@string/title_activity_login"
Android:theme="@style/FullScreen">
montrer Full Immersive:
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);
}
sortir du mode immersif complet:
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);
}
Créez une activité vide et ajoutez deux lignes dans 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);
}
...
}
KOTLIN
Suite à la doc Google, il existe un moyen simple:
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) }
https://developer.Android.com/training/system-ui/immersive.html
Activité:
@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>
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();
}
Cela a fonctionné pour moi.
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);
}
Il suffit de coller ce code dans la méthode onCreate()
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
Utilisez cette méthode après setContentView dans onCreate () et transmettez l'objet Window par 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
);
}
Ce code fonctionnera également pour l'écran Notch. Pour cocher l’encoche plein écran, vous avez besoin d’Android P, mais si vous possédez un téléphone à encoche, accédez à réglage -> réglage de l’affichage -> rapport d'affichage de l'application ---> sélectionnez votre application --- sera deux options sûres sont l'affichage et plein écran, s'il vous plaît sélectionner le plein écran et exécutez l'application, vous pouvez voir le plein écran dans l'encoche aussi sans avoir Android Pie
Après beaucoup de temps sans succès, je suis arrivé avec ma propre solution, qui est similaire à celle d'un autre développeur. Mon problème était que la barre de navigation du système ne se cachait pas après un appel. De plus, dans mon cas, j'avais besoin d'un paysage, donc juste au cas où, commentez cette ligne et tout ça. Tout d'abord créer du style
<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>
Ceci est mon fichier manifeste
<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>
Ceci est mon activité de 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);
}
}
Et ceci est mon activité principale en plein écran. onSystemUiVisibilityChange thi cette méthode est importante, sinon la barre de navigation principale d'Android après l'appel restera et ne disparaîtra plus. Problème vraiment irritant, mais cette fonction résout ce problème.
la classe publique MainActivity étend 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);
}
}
});
}
}
Voici la disposition de mon écran de démarrage:
<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>
J'espère que cela t'aidera