Activiteit op volledig scherm in Android?

Hoe maak ik een activiteit schermvullend? Ik bedoel zonder de notificatiebalk. Enig idee?

---

Antwoord 1, autoriteit 100%

Je kunt het programmatisch doen:

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

Of je kunt het doen via je AndroidManifest.xml-bestand:

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

Bewerken:

Als je AppCompatActivity gebruikt, moet je een nieuw thema toevoegen

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

en gebruik het dan.

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

Met dank aan https://stackoverflow.com/a/25365193/1646479

---

Antwoord 2, autoriteit 11%

Er is een techniek genaamd Meeslepende modus voor volledig schermbeschikbaar in KitKat.

Voorbeeld

---

Antwoord 3, autoriteit 7%

Als je het thema @android:style/Theme.NoTitleBar.Fullscreenniet wilt gebruiken omdat je al een eigen thema gebruikt, kun je android:windowFullscreen.

In AndroidManifest.xml:

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

In stijlen.xml:

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

---

Antwoord 4, autoriteit 5%

In AndroidManifest.xmlbestand:

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

of in java code:

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

---

Antwoord 5, Autoriteit 3%

Als u AppCompat en ActionBarActivity gebruikt, gebruik dan dit

getSupportActionBar().hide();

---

Antwoord 6, Autoriteit 2%

Wees voorzichtig met

requestWindowFeature(Window.FEATURE_NO_TITLE);

Als u een methode gebruikt om de actiebalk in te stellen als volgt:

getSupportActionBar().setHomeButtonEnabled(true);

Er zal een uitzondering van een null-aanwijzer veroorzaken.

---

Antwoord 7, Autoriteit 2%

Probeer dit met AppCompat van style.xml. Het biedt ondersteuning voor alle platforms.

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

---

Antwoord 8

Android-studio gebruiken (huidige versie is 2.2.2 op het moment) is zeer eenvoudig om een ​​volloopactiviteit toe te voegen.

Zie de stappen:

1. Klik met de rechtermuisknop op uw Java-hoofdpakket en GT; Selecteer “Nieuw” & GT; Selecteer “Activiteit” & GT; Klik vervolgens op “Fullscreen-activiteit”.

2. Pas de activiteit aan (“Activiteitsnaam”, “Lay-outnaam” enzovoort) en klik op “Voltooien”.

Klaar!

Je kunt nu gemakkelijk een activiteit op volledig scherm maken (bekijk de java-klasse en de activiteitslay-out om te zien hoe de dingen werken)!

---

Antwoord 9

Eerst moet je je app-thema instellen met “NoActionBar” zoals hieronder

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

Voeg deze regels vervolgens toe aan uw activiteit op volledig scherm.

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

Het verbergt de actiebalk/werkbalk en ook de statusbalk in uw activiteit op volledig scherm

---

Antwoord 10

Voor degenen die AppCompact gebruiken…
style.xml

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

Vermeld dan de naam in je manifest…

---

Antwoord 11

AndroidManifest.xml

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

i. Uw hoofdapp Het thema is Theme.appcompat.Light.DarkactionBar

voor Wisselbar / 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>

om de System Navigation Bar

te verbergen

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. Uw belangrijkste app-thema is thema.appcompat.light.noactionbar

voor Wisselbar / 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>

De systeemnavigatiebalk verbergen

Vergelijkbaarzoals Theme.AppCompat.Light.DarkActionBar.

Demo

---

Antwoord 12

bedankt voor het antwoord @Cristian ik kreeg een foutmelding

android.util.AndroidRuntimeException: requestFeature() moet worden aangeroepen
voordat u inhoud toevoegt

ik heb dit opgelost met

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

---

Antwoord 13

Voor Androidx

1. Transparante statusbalk

window?.decorView?.systemUiVisibility = (View.SYSTEM_UI_FLAG_LAYOUT_STABLE
        or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN)
window.statusBarColor = Color.TRANSPARENT

2. Transparante StatusBar & AMP; BUTOMNAV-STAD

   window.setFlags(
        WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS,
        WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
    );

3. Statusbar verbergen

   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
        window.insetsController?.hide(WindowInsets.Type.statusBars())
    }
    else {
        @Suppress("DEPRECATION")
        window.setFlags(
            WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN
        )
    }

4. Verberg Statubar & AMP; BUTOMNAV-STAD

val actionBar: ActionBar? = supportActionBar
          if (actionBar != null) actionBar.hide()
         window.decorView.systemUiVisibility = (View.SYSTEM_UI_FLAG_LOW_PROFILE
            or View.SYSTEM_UI_FLAG_FULLSCREEN
            or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
            or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
            or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
            or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION)

Waar te plaatsen van deze code?

  override fun onCreate(savedInstanceState: Bundle?) {
        /*  Put above code here ..... */
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_slider)
   }

Opmerking

• Ik heb deze code gecontroleerd in de Pixel 3A-emulator
• Misschien aanpassen Android OS niet ondersteund
• set styel <style name="Theme.FullScreen" parent="Theme.MaterialComponents.DayNight.NoActionBar">

---

Antwoord 14

toon volledig meeslepend:

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

uit de volledig meeslepende modus gaan:

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

---

Antwoord 15

Ik wilde mijn eigen thema gebruiken in plaats van @android:style/Theme.NoTitleBar.Fullscreen. Maar het werkte niet zoals een bericht hier had vermeld, dus ik heb wat aangepast om erachter te komen.

In AndroidManifest.xml:

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

in stijlen.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>

Opmerking: in mijn geval moest ik name="windowActionBar"in plaats van name="android:windowActionBar"voordat het goed werkte. Dus ik heb net het beide gebruikt om ervoor te zorgen dat ik later naar een nieuwe Android-versie moeten poort.

---

Antwoord 16

Hier is een voorbeeldcode. U kunt vlaggen aan / uitzetten om specifieke onderdelen te verbergen / weergeven.

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

Vervolgens reset u naar de Standaard Status:

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

U kunt de bovenstaande functies van uw onCreate:

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

---

Antwoord 17

kotlin

Volgens de Google Doc is er een eenvoudige manier:

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

---

Antwoord 18

Voeg dit toe in styles.xml

<item name="android:windowFullscreen">true</item>

Voorbeeld –

<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
    <!-- Customize your theme here. -->
    <item name="windowActionBar">false</item>
    <item name="windowNoTitle">true</item>
    <item name="colorPrimary">@color/colorPrimary</item>
    <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
    <item name="android:windowFullscreen">true</item>
    <item name="colorAccent">@color/colorAccent</item>
</style>

En verander het AndroidManifest-bestand met de onderstaande code

android:theme="@style/AppTheme"

Voorbeeld –

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:theme="@style/AppTheme"
    android:supportsRtl="true">

---

Antwoord 19

TIP: Het gebruik van getWindow().setLayout() kan uw volledige schermweergave verpesten! Let op de documentatie voor deze methode zegt:

Stel de lay-outparameters voor breedte en hoogte van het venster in…
je kunt ze veranderen in … een absolute waarde om een venster te maken dat niet volledig scherm is.

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

Voor mijn doeleinden ontdekte ik dat ik setLayout met absolute parameters moest gebruiken om het formaat van mijn venster op volledig scherm correct te wijzigen. Meestal werkte dit prima. Het werd aangeroepen door een onConfigurationChanged() -gebeurtenis. Er was echter een hapering. Als de gebruiker de app zou verlaten, de oriëntatie zou veranderen en opnieuw zou invoeren, zou dit leiden tot het afvuren van mijn code die setLayout() bevatte. Tijdens dit tijdvenster voor herinvoer zou mijn statusbalk (die verborgen was door het manifest) opnieuw verschijnen, maar op een ander moment zou setLayout() dit niet veroorzaken! De oplossing was om een extra setLayout()-aanroep toe te voegen na degene met de harde waarden, zoals:

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

Het venster vervolgens correct opnieuw formaat, en de statusbalk verschijnt niet, ongeacht het evenement dat dit heeft geactiveerd.

---

Antwoord 20

het werkte voor mij.

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

---

Antwoord 21

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

---

Antwoord 22

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

Dit werkte voor mij. Ik hoop dat het je zal helpen.

---

Antwoord 23

Met Kotlin is dit de manier waarop ik deed:

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

Immersive-modus

De immersive-modus is bedoeld voor apps waarin de gebruiker sterk in interactie zal zijn met het scherm. Voorbeelden zijn games, het bekijken van afbeeldingen in een galerij of het lezen van gepagineerde inhoud, zoals een boek of dia’s in een presentatie. Voeg hiervoor deze regels toe:

View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION

kleverig immersive

In de normale meeslepende modus zorgt het systeem ervoor dat elke keer dat een gebruiker vanaf een rand veegt, de systeembalken worden weergegeven. Uw app merkt niet eens dat de beweging heeft plaatsgevonden. Dus als de gebruiker misschien echt vanaf de rand van het scherm moet vegen als onderdeel van de primaire app-ervaring, zoals bij het spelen van een game waarbij veel moet worden geveegd of bij het gebruik van een teken-app, moet je in plaats daarvan de “sticky” meeslepende modus inschakelen .

View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY

Voor meer informatie: Volledig scherm inschakelen

Als u het toetsenbord gebruikt, gebeurt het soms dat de Statusbalk wordt weergegeven wanneer het toetsenbord verschijnt. In dat geval voeg ik dit meestal toe aan mijn stijl xml

styles.xml

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

En ook deze regel naar mijn manifest

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

---

Antwoord 24

Plak deze code gewoon in de onCreate()-methode

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

---

Antwoord 25

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

---

Antwoord 26

Na veel tijd zonder succes kwam ik met mijn eigen oplossing die op elkaar is gestopt met een andere ontwikkelaar. Dus als iemand haar nodig heeft, is het is. Mijn probleem was dat systeemnavigatiebalk niet verstopte na het bellen. Ook in mijn geval had ik het landschap nodig, dus voor het geval dat die lijn en dat allemaal.
Allereerst stijl

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

Dit is mijn manifestbestand

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

Dit is mijn spalsh-activiteit

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

}

En dit is mijn belangrijkste activiteit op volledig scherm. onSystemUiVisibilityVerander deze methode is belangrijk, anders blijft de Android-hoofdnavigatiebalk na het bellen behouden en verdwijnt niet meer. Echt irritant probleem, maar deze functie lost dat probleem op.

openbare klasse MainActivity breidt AppCompatActivity uit
{

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

}

Dit is mijn Splash-schermlay-out:

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

Ik hoop dat dit zal je helpen

---

Antwoord 27

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

Activiteit:

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

---

Antwoord 28

Maak een lege activiteit en voeg twee regels in 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);
    }
    ...
}

---

Antwoord 29

Gebruik deze methode na SetContentview in Oncreate () en geef het -venster Object door 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
    );
}

Deze code werkt ook voor het inkepingscherm. Om de inkeping op volledig scherm te controleren, heeft u Android P nodig, maar als u een inkepingstelefoon hebt, ga dan naar Instelling – & GT; Display-instelling – & GT; App Display-ratio — & GT; Selecteer uw app – & GT; Er zijn twee opties Safe zijn weergave en volledig scherm, selecteer het volledige scherm en voert u de app uit, u kunt het volledig scherm zien in Notch zonder Android Pie

---

ANTWOORD 30

Om uw activiteit volledig scherm te maken, doe dit:

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

Dit zal de werkbalk en statusbalk te verbergen.

Maar in sommige gevallen kunt u de statusbalk met een transparante achtergrond, in dat geval, doe je dit:

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

Enkele andere alternatieve verstoppertje werkbalk in plaats van
. getSupportActionBar().hide()

1. Werkbalk verwijderen door het veranderen van de moedermaatschappij van de app thema’s:

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

2. Als u wilt de werkbalk van slechts één activiteit te verwijderen ga dan naar manifest, onder activiteit tag toe te voegen volgt uit: android:theme="@style/Theme.AppCompat.Light.NoActionBar"

Voor Kotlin lovers , waarom niet gebruik extensie functies:

Voor de eerste geval:

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

En roept dit al eerder setContentView

makeItFullScreenStatusBarVisible()

Voor Second One:

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

En noem het vóór setContentView:

makeItFullScreenStatusBarHidden()