Vollbildaktivität in Android?

Wie mache ich eine Aktivität im Vollbildmodus? Ich meine ohne die Benachrichtigungsleiste. Irgendwelche Ideen?

Sie können es programmatisch tun:

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

Oder Sie können es über Ihre AndroidManifest.xmlDatei tun :

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

Bearbeiten:

Wenn Sie AppCompatActivity verwenden, müssen Sie ein neues Thema hinzufügen

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

und dann benutze es.

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

Vielen Dank an https://stackoverflow.com/a/25365193/1646479

In KitKat ist eine Technik namens Immersive Full-Screen Mode verfügbar .

Beispiel

Wenn Sie das Thema nicht verwenden möchten, @android:style/Theme.NoTitleBar.Fullscreenweil Sie bereits ein eigenes Thema verwenden, können Sie es verwenden android:windowFullscreen.

In AndroidManifest.xml:

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

In styles.xml:

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

In der Datei 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>  

Oder in Java- Code:

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

Wenn Sie AppCompat und ActionBarActivity verwenden, verwenden Sie diese Option

getSupportActionBar().hide();

Sei vorsichtig mit

requestWindowFeature(Window.FEATURE_NO_TITLE);

Wenn Sie eine Methode verwenden, um die Aktionsleiste wie folgt festzulegen:

getSupportActionBar().setHomeButtonEnabled(true);

Es wird eine Nullzeigerausnahme verursacht.

Versuchen Sie dies mit Appcompat von style.xml. Es bietet Unterstützung für alle Plattformen.

<!-- 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" />

Mit Android Studio (die aktuelle Version ist derzeit 2.2.2) können Sie ganz einfach eine Vollbildaktivität hinzufügen.

Siehe die Schritte:

1. Klicken Sie mit der rechten Maustaste auf Ihr Java-Hauptpaket> Wählen Sie "Neu"> Wählen Sie "Aktivität"> Klicken Sie dann auf "Vollbildaktivität".

2. Passen Sie die Aktivität an ("Aktivitätsname", "Layoutname" usw.) und klicken Sie auf "Fertig stellen".

Erledigt!

Jetzt können Sie ganz einfach eine Vollbildaktivität erstellen (siehe Java-Klasse und Aktivitätslayout, um zu erfahren, wie die Dinge funktionieren)!

Für Benutzer von AppCompact ... style.xml

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

Dann tragen Sie den Namen in Ihr Manifest ein ...

Zuerst müssen Sie Ihr App-Thema mit "NoActionBar" wie unten festlegen

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

Fügen Sie diese Zeilen dann in Ihre Vollbildaktivität ein.

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

Die Aktionsleiste / Symbolleiste und auch die Statusleiste in Ihrer Vollbildaktivität werden ausgeblendet

AndroidManifest.xml

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

I. Ihre Haupt-App ist Theme.AppCompat.Light.DarkActionBar

Zum Ausblenden von 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>

So blenden Sie die Systemnavigationsleiste aus

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. Ihr Haupt-App-Thema ist Theme.AppCompat.Light.NoActionBar

Zum Ausblenden von 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>

So blenden Sie die Systemnavigationsleiste aus

Ähnlich wie Theme.AppCompat.Light.DarkActionBar.

Demo

Danke für die Antwort @Cristian Ich habe einen Fehler bekommen

android.util.AndroidRuntimeException: requestFeature () muss aufgerufen werden, bevor Inhalte hinzugefügt werden

Ich habe das mit gelöst

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

    -----
    -----
}

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

Verlassen Sie den immersiven Modus:

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

Ich wollte mein eigenes Thema verwenden, anstatt @android: style / Theme.NoTitleBar.Fullscreen zu verwenden. Aber es funktionierte nicht, wie ein Beitrag hier erwähnt hatte, also habe ich einige Anpassungen vorgenommen, um es herauszufinden.

In AndroidManifest.xml:

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

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

Hinweis: In meinem Fall musste ich name="windowActionBar"statt verwenden, name="android:windowActionBar"bevor es richtig funktionierte. Also habe ich nur beide verwendet, um sicherzustellen, dass ich später auf eine neue Android-Version portieren muss.

Hier ist ein Beispielcode. Sie können Flags ein- und ausschalten, um bestimmte Teile auszublenden / anzuzeigen.

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

Anschließend setzen Sie den Standardstatus zurück :

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

Sie können die oben genannten Funktionen über Folgendes aufrufen onCreate:

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

KOTLIN

Nach dem Google Doc gibt es einen einfachen Weg:

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 Dokumente

TIPP: Mit getWindow (). SetLayout () kann Ihre Vollbildanzeige durcheinander bringen! Beachten Sie die Dokumentation für diese Methode:

Legen Sie die Layoutparameter für Breite und Höhe des Fensters fest. Sie können sie in einen absoluten Wert ändern, um ein Fenster zu erstellen, das nicht im Vollbildmodus angezeigt wird.

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

Für meine Zwecke stellte ich fest, dass ich setLayout mit absoluten Parametern verwenden musste, um die Größe meines Vollbildfensters korrekt zu ändern. Meistens funktionierte das gut. Es wurde von einem onConfigurationChanged () -Ereignis aufgerufen. Es gab jedoch einen Schluckauf. Wenn der Benutzer die App beendet, die Ausrichtung ändert und erneut eintritt, wird mein Code ausgelöst, der setLayout () enthält. Während dieses Zeitfensters für die erneute Eingabe wird meine Statusleiste (die vom Manifest ausgeblendet wurde) erneut angezeigt, aber zu keinem anderen Zeitpunkt würde setLayout () dies verursachen! Die Lösung bestand darin, nach dem Aufruf mit den folgenden harten Werten einen zusätzlichen setLayout () -Aufruf hinzuzufügen:

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

Das Fenster wurde dann korrekt angepasst, und die Statusleiste wurde unabhängig vom Ereignis, das dies ausgelöst hat, nicht erneut angezeigt.

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

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>

Das hat bei mir funktioniert. Hoffe es wird dir helfen.

Mit Kotlin habe ich das so gemacht:

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

    }
}

Immersiver Modus

Der immersive Modus ist für Apps gedacht, bei denen der Benutzer stark mit dem Bildschirm interagiert. Beispiele sind Spiele, das Anzeigen von Bildern in einer Galerie oder das Lesen von paginierten Inhalten wie einem Buch oder Folien in einer Präsentation. Fügen Sie dazu einfach die folgenden Zeilen hinzu:

View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION

Sticky immersive

Im regulären immersiven Modus sorgt das System jedes Mal, wenn ein Benutzer von einer Kante wischt, dafür, dass die Systemleisten angezeigt werden. Ihre App merkt nicht einmal, dass die Geste aufgetreten ist. Wenn der Benutzer im Rahmen der primären App-Erfahrung möglicherweise tatsächlich vom Bildschirmrand wischen muss, z. B. beim Spielen eines Spiels, das viel Wischen erfordert, oder beim Verwenden einer Zeichen-App, sollten Sie stattdessen den immersiven Modus "Sticky" aktivieren .

View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY

Weitere Informationen: Aktivieren Sie den Vollbildmodus

Wenn Sie die Tastatur verwenden, wird manchmal die Statusleiste angezeigt, wenn die Tastatur angezeigt wird. In diesem Fall füge ich dies normalerweise meiner Stil-XML hinzu

styles.xml

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

Und auch diese Zeile zu meinem Manifest

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

Fügen Sie diesen Code einfach in die onCreate()Methode ein

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

Es hat bei mir funktioniert.

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

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

}

Nach viel Zeit ohne Erfolg kam ich mit meiner eigenen Lösung, die bei einem anderen Entwickler ähnlich ist. Wenn jemand sie braucht, ist es das. Mein Problem war, dass sich die Systemnavigationsleiste nach dem Anruf nicht versteckte. Auch in meinem Fall brauchte ich Landschaft, also nur für den Fall, kommentiere diese Zeile und das alles. Erstellen Sie zunächst Stil

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

Dies ist meine Manifestdatei

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

Dies ist meine Spalsh-Aktivität

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

}}

Und das ist meine Hauptaktivität im Vollbildmodus. onSystemUiVisibilityChange Diese Methode ist sehr wichtig, da sonst die Hauptnavigationsleiste von Android nach dem Aufruf erhalten bleibt und nicht mehr verschwindet. Wirklich irritierendes Problem, aber diese Funktion löst dieses Problem.

öffentliche Klasse MainActivity erweitert 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);

                        }
                }
            });

}

}}

Dies ist mein Begrüßungsbildschirm-Layout:

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

ich hoffe, dies wird dir helfen

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

Aktivität:

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

Erstellen Sie eine leere Aktivität und fügen Sie zwei Zeilen hinzu 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);
    }
    ...
}

Verwenden Sie diese Methode nach setContentView in onCreate () und übergeben Sie das Window- Objekt an 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
    );
}

Dieser Code funktioniert auch für den Kerbbildschirm. Um den Notch-Vollbildmodus zu überprüfen, benötigen Sie Android P. Wenn Sie jedoch ein Notch-Display-Telefon haben, gehen Sie zu Einstellung -> Anzeigeeinstellung -> App-Anzeigeverhältnis ---> Wählen Sie Ihre App aus ---> Es gibt zwei sichere Optionen Anzeige und Vollbild, bitte wählen Sie den Vollbildmodus und führen Sie die App aus. Sie können den Vollbildmodus auch ohne Android Pie sehen

Gehen Sie folgendermaßen vor, um Ihre Aktivität im Vollbildmodus anzuzeigen:

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

Dadurch werden die Symbolleiste und die Statusleiste ausgeblendet.

In einigen Fällen möchten Sie möglicherweise die Statusleiste mit einem transparenten Hintergrund anzeigen. In diesem Fall gehen Sie folgendermaßen vor:

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

Eine andere Alternative zum Ausblenden der Symbolleiste anstelle von getSupportActionBar().hide():

1. Entfernen Sie die Symbolleiste, indem Sie das übergeordnete Element des App-Themas ändern:

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

2. Wenn Sie die Symbolleiste nur aus einer Aktivität entfernen möchten, gehen Sie zum Manifest und fügen Sie unter Aktivitäts-Tag Folgendes hinzu: android:theme="@style/Theme.AppCompat.Light.NoActionBar"

Verwenden Sie für Kotlin-Liebhaber die Erweiterungsfunktionen:

Für den ersten Fall:

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

Und nenne das vorher setContentView:

makeItFullScreenStatusBarVisible()

Für den zweiten:

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

Und nenne es vorher setContentView:

makeItFullScreenStatusBarHidden()

Auf Android 10 hat keiner für mich funktioniert.

Aber ich, das hat perfekt funktioniert (1. Zeile in oncreate):

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

    setContentView(....);

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

genießen :)

Anzeigen von Inhalten durch die Kerbe oder den Ausschnittbereich. Dies kann aus den Dokumenten helfen:

LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES - Der Inhalt wird sowohl im Hoch- als auch im Querformat in den Ausschnittbereich gerendert.

Das Wichtigste für mich war diese Zeile im Aktivitätsstil:

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

Für mich wollte ich ein Bild im immersiven Modus zeigen. Wenn ich darauf klicke, soll die System-Benutzeroberfläche (Status- und Navigationsleisten) angezeigt werden.

Hier ist meine Lösung:

1- In der Aktivität einige Methoden zum Ein- / Ausblenden der Systembenutzeroberfläche (Status- / Navigationsleisten)

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- Stellen Sie dies in der Stammansicht Ihres XML-Layouts sicher

android:fitsSystemWindows="false"

3- Stil für Vollbildaktivität gibt Status- / Navigationsleisten einen halbtransparenten Hintergrund, wenn sie angezeigt werden:

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