Hoe maak ik een opstartscherm?

Ik wil dat mijn app er professioneler uitziet, dus besloot ik een welkomstscherm toe te voegen.

Hoe moet ik de implementatie aanpakken?


Antwoord 1, autoriteit 100%

Meer lezen:

Oud antwoord:

HOE: Eenvoudig welkomstscherm

Dit antwoord laat je zien hoe je een welkomstscherm voor een vaste tijd weergeeft wanneer je app start voor b.v. branding redenen. bijv. u kunt ervoor kiezen om het opstartscherm gedurende 3 seconden weer te geven. Als u het spash-scherm echter voor een variabele tijd wilt weergeven (bijv. de opstarttijd van de app), moet u het antwoord van Abdullah bekijken https:/ /stackoverflow.com/a/15832037/401025. Houd er echter rekening mee dat het opstarten van de app op nieuwe apparaten erg snel kan zijn, zodat de gebruiker alleen een flits ziet, wat een slechte UX is.

Eerst moet u het spash-scherm definiëren in uw layout.xml-bestand

 <?xml version="1.0" encoding="utf-8"?>
  <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:src="@drawable/splash"
                  android:layout_gravity="center"/>
          <TextView android:layout_width="fill_parent"
                    android:layout_height="wrap_content"
                    android:text="Hello World, splash"/>
  </LinearLayout>

En uw activiteit:

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
public class Splash extends Activity {
    /** Duration of wait **/
    private final int SPLASH_DISPLAY_LENGTH = 1000;
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        setContentView(R.layout.splashscreen);
        /* 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,Menu.class);
                Splash.this.startActivity(mainIntent);
                Splash.this.finish();
            }
        }, SPLASH_DISPLAY_LENGTH);
    }
}

Dat is alles 😉


Antwoord 2, autoriteit 99%

Merk op dat deze oplossing de gebruiker niet langer laat wachten:de vertraging van het opstartscherm hangt af van de opstarttijd van de applicatie.

Wanneer je een Android-app opent, krijg je standaard een wat zwart scherm met de titel en het pictogram van de app bovenaan, je kunt dat veranderen door een stijl/thema te gebruiken.

Maak eerst een style.xml in de map Values en voeg er een stijl aan toe.

<style name="splashScreenTheme" parent="@android:style/Theme.DeviceDefault.Light.NoActionBar">
    <item name="android:windowBackground">@drawable/splash_screen</item>
</style>

In plaats van het gebruik van @android:style/Theme.DeviceDefault.Light.NoActionBarU kunt elk ander thema als ouder gebruiken.

Ten tweede, in uw app Manifest.xml Toevoegen android:theme="@style/splashScreenTheme"naar uw hoofdactiviteit.

<activity
        android:name="MainActivity"
        android:label="@string/app_name"
        android:theme="@style/splashScreenTheme" >

Derde, update uw thema in uw oncreate () Start Activity.

protected void onCreate(Bundle savedInstanceState) {
    // Make sure this is before calling super.onCreate
    setTheme(R.style.mainAppTheme);
    super.onCreate(savedInstanceState);
}

update
Uitchecken dit bericht .

Dank aan @ Mat1h en @Adelriosantiago


Antwoord 3, Autoriteit 11%

  • Maak een activiteit: Splash
  • Maak een lay-out XML-bestand: splash.xml
  • Zet UI-componenten in de lay-out van Splash.xml, zodat het eruit ziet hoe u wilt
  • Your Splash.java kan er zo uitzien:

    public class Splash extends Activity {
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.splash);
            int secondsDelayed = 1;
            new Handler().postDelayed(new Runnable() {
                    public void run() {
                            startActivity(new Intent(Splash.this, ActivityB.class));
                            finish();
                    }
            }, secondsDelayed * 1000);
        }
    }
    
  • wijzig ActivityB.classin de activiteit die u wilt starten na het opstartscherm

  • controleer uw manifestbestand en het zou er als volgt uit moeten zien

       <activity
            android:name=".HomeScreen"
            android:label="@string/app_name">     
        </activity>
        <activity
            android:name=".Splash"
            android:label="@string/title_activity_splash_screen">     
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

Antwoord 4, autoriteit 6%

De antwoorden hierboven zijn erg goed, maar ik wil nog iets toevoegen. Ik ben nieuw bij Android, ik ontmoette deze problemen tijdens mijn ontwikkeling. hoop dat dit iemand zoals ik kan helpen.

  1. Het Splash-scherm is het beginpunt van mijn app, dus voeg de volgende regels toe in AndroidManifest.xml.

       <activity
            android:name=".SplashActivity"
            android:theme="@android:style/Theme.DeviceDefault.Light.NoActionBar">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    
  2. Het SPLASH-scherm moet slechts één keer in de LIFE-cyclus van het app laten zien, ik gebruik een Booleaanse variabele om de status van het Splash-scherm op te nemen en laat het alleen op de eerste keer zien.

    public class SplashActivity extends Activity {
        private static boolean splashLoaded = false;
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            if (!splashLoaded) {
                setContentView(R.layout.activity_splash);
                int secondsDelayed = 1;
                new Handler().postDelayed(new Runnable() {
                    public void run() {
                        startActivity(new Intent(SplashActivity.this, MainActivity.class));
                        finish();
                    }
                }, secondsDelayed * 500);
                splashLoaded = true;
            }
            else {
                Intent goToMainActivity = new Intent(SplashActivity.this, MainActivity.class);
                goToMainActivity.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
                startActivity(goToMainActivity);
                finish();
            }
        }
    }
    

Happy Codering!


Antwoord 5, Autoriteit 4%

Het antwoord van Abdullah is geweldig. Maar ik wil er wat meer details aan toevoegen met mijn antwoord.

implementeren van een splash-scherm

Implementatie van een Splash-scherm De juiste manier is een beetje anders dan u zich zou kunnen voorstellen. De splash-weergave die u ziet, moet onmiddellijk gereed zijn, zelfs voordat u een lay-outbestand in uw plonsactiviteit kunt opblazen.

Dus u gebruikt geen lay-outbestand. Specificeer in plaats daarvan de achtergrond van uw spatscherm als de themaachtergrond van de activiteit. Maak dit eerst een XML-opleiding in Res / Onderwijsmateriaal.

Achtergrond_Splash.xml

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item
        android:drawable="@color/gray"/>
    <item>
        <bitmap
            android:gravity="center"
            android:src="@mipmap/ic_launcher"/>
    </item>
</layer-list>

Het is gewoon een lagenlijst met het logo in de achtergrondkleur in het midden.

Open nu styles.xml en voeg deze stijl toe

<style name="SplashTheme" parent="Theme.AppCompat.NoActionBar">
        <item name="android:windowBackground">@drawable/background_splash</item>
</style>

Dit thema heeft een actiebalk en een achtergrond die we zojuist hierboven hebben gemaakt.

En in manifest moet je SplashTheme instellen op activiteit die je als splash wilt gebruiken.

<activity
android:name=".SplashActivity"
android:theme="@style/SplashTheme">
<intent-filter>
    <action android:name="android.intent.action.MAIN" />
    <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>

Vervolgens navigeer je in je activiteitscode naar het specifieke scherm na het splashen met intentie.

public class SplashActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Intent intent = new Intent(this, MainActivity.class);
        startActivity(intent);
        finish();
    }
}

Dat is de juiste manier om te doen. Ik heb deze referenties gebruikt voor het antwoord.

  1. https://material.google.com/patterns/launch-screens.html
  2. https://www.bignerdranch.com/blog/splash -screens-the-right-way/
    Dank aan deze jongens om me in de goede richting te duwen. Ik wil anderen helpen omdat een geaccepteerd antwoord niet wordt aanbevolen om een startscherm te maken.

Antwoord 6, autoriteit 3%

  1. Maak een ActivitySplashScreen.java

    public class SplashScreen extends Activity {
    protected boolean _active = true;
    protected int _splashTime = 3000; // time to display the splash screen in ms
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.splashscreen);
        Thread splashTread = new Thread() {
            @Override
            public void run() {
                try {
                    int waited = 0;
                    while (_active && (waited < _splashTime)) {
                        sleep(100);
                        if (_active) {
                            waited += 100;
                        }
                    }
                } catch (Exception e) {
                } finally {
                    startActivity(new Intent(SplashScreen.this,
                            MainActivity.class));
                    finish();
                }
            };
                 };
        splashTread.start();
    }
     }
    
  2. splashscreen.xmlziet er zo uit

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="600px" android:layout_height="1024px"
      android:background="#FF0000">
    </RelativeLayout> 
    

Antwoord 7, autoriteit 2%

Een Splash-scherm zorgt er standaard niet automatisch voor dat uw toepassing er professioneler uitziet. Een professioneel ontworpen welkomstscherm heeft de mogelijkheid om uw toepassing er professioneler uit te laten zien, maar als u niet weet hoe u er een moet schrijven, hoe professioneel zal de rest van uw toepassing dan zijn.

De enige reden (excuus) om een welkomstscherm te hebben, is dat u een enorme hoeveelheid berekeningen uitvoert of wacht op het opstarten van GPS/WiFi, omdat uw toepassing daarvan afhankelijk is voordat deze wordt gestart. Zonder het resultaat van die berekeningen of toegang tot GPS/WiFi (enz.) is uw applicatie dood in het water, dus u denkt dat u een opstartscherm nodig heeft en MOET de weergave van het scherm blokkeren voor andere actieve programma’s (inclusief de achtergrond ).

Zo’n welkomstscherm zou eruit moeten zien als uw toepassing op volledig scherm om de indruk te wekken dat het al is geïnitialiseerd, en nadat de lange berekeningen zijn voltooid, kunnen de laatste details worden ingevuld (de afbeelding is aangepast). De kansdat dat het geval is of dat dit de enige manier is waarop het Programma kan worden ontworpen is enorm klein.

Het zou beter zijn om de gebruiker (en de rest van het besturingssysteem) iets anders te laten doen terwijl ze wachten in plaats van uw programma zo te ontwerpen dat het afhankelijk is van iets dat een tijdje zal duren (wanneer de duur van het wachten onzeker is) ).

Er zijn al pictogrammen op uw telefoon die aangeven dat GPS/WiFi wordt gestart. De tijd of ruimte die het opstartscherm in beslag neemt, kan worden besteed aan het laden van voorberekeningen of het daadwerkelijk uitvoeren van de berekeningen. Zie de eerste link hieronder voor de problemen die je maakt en waar je rekening mee moet houden.

Als u absoluut moet wachten op deze berekeningen of GPS/WiFi, is het het beste om de applicatie gewoon te laten starten en een pop-up te laten verschijnen die zegt dat u op de berekeningen moet wachten (een prima). Het wachten op GPS/WiFi wordt verwacht (als ze niet al in een ander programma waren ingeschakeld), dus het aankondigen van hun wachttijden is niet nodig.

Houd er rekening mee dat wanneer het welkomstscherm start, uw programma eigenlijk al actief is, u alleen maar het gebruik van uw programma uitstelt en de CPU/GPU overbelast om iets te doen waarvan de meesten denken dat het niet nodig is.

We kunnen maar beter wachten en je Splash-scherm zien elke keer dat we je programma starten, anders zullen WE niet het gevoel hebben dat het erg professioneel is geschreven. Het maken van het welkomstscherm VOLLEDIG scherm en een duplicaat van het eigenlijke programmascherm (we denken dus dat het geïnitialiseerd is terwijl dat in feite niet het geval is) KAN je doel bereiken (om je programma er professioneler uit te laten zien), maar daar zou ik niet veel op wedden.

Waarom zou je het niet doen: http://cyrilmottier. com/2012/05/03/splash-screens-are-evil-dont-use-them/

Hoe u dit doet: https://encrypted.google.com/search?q= Android+splash+scherm+bron

Dus er is een goede reden om het niet te doen, maar ALS je er zeker van bent dat je situatie op de een of andere manier buiten deze voorbeelden valt, worden de middelen om het te doen hierboven gegeven. Zorg ervoor dat uw toepassing er echt professioneler uitziet, anders heeft u de enige reden die u hiervoor hebt opgegeven, verworpen.

Het is als een YouTube-kanaal dat elke video begint met een lange grafische intro (en outro) of de behoefte voelt om een grap te vertellen of uit te leggen wat er de afgelopen week is gebeurd (als het geen comedy- of LifeStyles-kanaal is). Laat de show gewoon zien! (Voer het programma gewoon uit).


Antwoord 8, autoriteit 2%

Vooral de antwoorden zijn echt heel goed. Maar er zijn problemen met geheugenlekkage.
Dit probleem staat in de Android-community vaak bekend als ‘Een activiteit lekken’. Wat betekent dat nu precies?

Als er een configuratiewijziging plaatsvindt, zoals een wijziging van de oriëntatie, vernietigt Android de activiteit en maakt deze opnieuw. Normaal gesproken wist de Garbage Collector gewoon het toegewezen geheugen van de oude activiteitsinstantie en we zijn allemaal goed.

‘Een activiteit lekken’verwijst naar de situatie waarin de Garbage Collector het toegewezen geheugen van de oude activiteitsinstantie niet kan wissen omdat er being (strong) referencedvan een object die uit de Activiteit-instantie leefde. Aan elke Android-app is een bepaalde hoeveelheid geheugen toegewezen. Wanneer Garbage Collector geen ongebruikt geheugen kan vrijmaken, zullen de prestaties van de app geleidelijk afnemen en uiteindelijk crashen met een OutOfMemory-fout.

Hoe te bepalen of de app geheugen lekt of niet? De snelste manier is om het tabblad Geheugen in Android Studio te openen en aandacht te besteden aan het toegewezen geheugen terwijl u de oriëntatie wijzigt.
Als het toegewezen geheugen blijft toenemen en nooit afneemt, heb je een geheugenlek.

1.Geheugenlek wanneer gebruiker de richting verandert.

Eerst moet u het welkomstscherm definiëren in uw lay-outresource splashscreen.xml-bestand

Voorbeeldcode voor activiteit op het startscherm.

public class Splash extends Activity {
 // 1. Create a static nested class that extends Runnable to start the main Activity
    private static class StartMainActivityRunnable implements Runnable {
        // 2. Make sure we keep the source Activity as a WeakReference (more on that later)
        private WeakReference mActivity;
        private StartMainActivityRunnable(Activity activity) {
         mActivity = new WeakReference(activity);
        }
        @Override
        public void run() {
         // 3. Check that the reference is valid and execute the code
            if (mActivity.get() != null) {
             Activity activity = mActivity.get();
             Intent mainIntent = new Intent(activity, MainActivity.class);
             activity.startActivity(mainIntent);
             activity.finish();
            }
        }
    }
    /** Duration of wait **/
    private final int SPLASH_DISPLAY_LENGTH = 1000;
    // 4. Declare the Handler as a member variable
    private Handler mHandler = new Handler();
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(icicle);
        setContentView(R.layout.splashscreen);
        // 5. Pass a new instance of StartMainActivityRunnable with reference to 'this'.
        mHandler.postDelayed(new StartMainActivityRunnable(this), SPLASH_DISPLAY_LENGTH);
    }
    // 6. Override onDestroy()
    @Override
    public void onDestroy() {
     // 7. Remove any delayed Runnable(s) and prevent them from executing.
     mHandler.removeCallbacksAndMessages(null);
     // 8. Eagerly clear mHandler allocated memory
     mHandler = null;
    }
}

Ga voor meer informatie naar deze link


Antwoord 9, autoriteit 2%

Het stoppen op het Splash-scherm voor 4’s 5’s heeft onnodig veel zin.
Het is OK als u iets op de achtergrond laadt, anders volgt u deze aanpak om het welkomstscherm te implementeren:-

Het op de juiste manier implementeren van een opstartscherm is een beetje anders dan je zou denken. De splash-weergave die u ziet, moet onmiddellijk klaar zijn, zelfs voordat u een lay-outbestand kunt opblazen in uw splash-activiteit.

U zult dus geen lay-outbestand gebruiken. Geef in plaats daarvan de achtergrond van uw opstartscherm op als de thema-achtergrond van de activiteit. Om dit te doen, maakt u eerst een XML-tekenbaar in res/drawable.

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item
        android:drawable="@color/gray"/>
    <item>
        <bitmap
            android:gravity="center"
            android:src="@mipmap/ic_launcher"/>
    </item>
</layer-list>

Hier heb ik een achtergrondkleur en een afbeelding ingesteld.

Vervolgens stelt u dit in als de achtergrond van uw splash-activiteit in het thema. Navigeer naar uw bestand styles.xml en voeg een nieuw thema toe voor uw splash-activiteit:

<resources>
    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
    </style>
    <style name="SplashTheme" parent="Theme.AppCompat.NoActionBar">
        <item name="android:windowBackground">@drawable/background_splash</item>
    </style>
</resources>

Stel in uw nieuwe splashteme het venster Aanketen Attribuut in aan uw XML-opleiding. Configureer dit als het thema van uw Splash-activiteit in uw Androidmanifest.xml:

<activity
    android:name=".SplashActivity"
    android:theme="@style/SplashTheme">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

Ten slotte moet de klasse van Splashactivity u gewoon doorsturen naar uw hoofdactiviteit:

    public class SplashActivity extends AppCompatActivity {
             @Override
             protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
               Intent intent = new Intent(this, MainActivity.class);
               startActivity(intent);
               finish();
    }
}

Meer details Lees dit:
1. https://www.bignerranch.com/blog/splash- Screens-the-Right-way /
2. http : //blog.goodBarber.com/3-tips-to-create-a-great-splash-screen-for-your-mobile-app_a287.html


Antwoord 10

U gebruikt geen lay-outbestand. Specificeer in plaats daarvan de achtergrond van uw spatscherm als de themaachtergrond van de activiteit. Maak dit eerst een XML-opleiding in Res / Onderwijsmateriaal.

Opmerking: alle code hieronder is beschikbaar GitHub Link

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item
        android:drawable="@color/gray"/>
    <item>
        <bitmap
            android:gravity="center"
            android:src="@mipmap/ic_launcher"/>
    </item>
</layer-list>

Hier heb ik een achtergrondkleur en een afbeelding opgezet.

Vervolgens zul je dit instellen als de achtergrond van je spattenactiviteit in het thema. Navigeer naar het bestand Styles.xml en voeg een nieuw thema toe voor uw Splash-activiteit:

<resources>
    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
    </style>
    <style name="SplashTheme" parent="Theme.AppCompat.NoActionBar">
        <item name="android:windowBackground">@drawable/background_splash</item>
    </style>
</resources>

Stel in uw nieuwe splashteme het venster Aanketen Attribuut in aan uw XML-opleiding. Configureer dit als het thema van uw Splash-activiteit in uw Androidmanifest.xml:

<activity
    android:name=".SplashActivity"
    android:theme="@style/SplashTheme">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

Ten slotte moet uw Splashactivity-klasse u gewoon doorsturen naar uw hoofdactiviteit:

public class SplashActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Intent intent = new Intent(this, MainActivity.class);
        startActivity(intent);
        finish();
    }
}

Merk op dat u niet eens een beeld hebt opgericht voor deze splashactivity. Het uitzicht komt van het thema. Wanneer u de UI opzet voor uw spatactiviteit in het thema, is deze onmiddellijk beschikbaar.

Als u een lay-outbestand hebt voor uw spatactiviteit, zou dat lay-outbestand alleen zichtbaar zijn voor de gebruiker nadat uw app volledig is geïnitialiseerd, wat te laat is. U wilt dat de splash alleen in die kleine hoeveelheid tijd wordt weergegeven voordat de app is geïnitialiseerd.


Antwoord 11

Dit is de volledige code hier

splashactivity.java

public class SplashActivity extends AppCompatActivity {
private final int SPLASH_DISPLAY_DURATION = 1000;
@Override
public void onCreate(Bundle bundle) {
    super.onCreate(bundle);
    new Handler().postDelayed(new Runnable(){
        @Override
        public void run() {
            Intent mainIntent = new Intent(SplashActivity.this,MainActivity.class);
            SplashActivity.this.startActivity(mainIntent);
            SplashActivity.this.finish();
        }
    }, SPLASH_DISPLAY_DURATION);
}}

In twijfels Maak dit bg_splash.xml

<?xml version="1.0" encoding="utf-8"?><layer-list xmlns:android="http://schemas.android.com/apk/res/android">
<item
    android:drawable="@color/app_color"/>
<item>
    <bitmap
        android:gravity="center"
        android:src="@drawable/ic_in_app_logo_big"/>
</item></layer-list>

Maak in styles.xmleen aangepast thema

<style name="SplashTheme" parent="Theme.AppCompat.NoActionBar">
    <item name="android:windowBackground">@drawable/bg_splash</item>
</style>

en tot slot in AndroidManifest.xmlhet thema voor uw activiteit specificeren

<activity
        android:name=".activities.SplashActivity"
        android:label="@string/app_name"
        android:screenOrientation="portrait"
        android:theme="@style/SplashTheme">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

Proost.


Antwoord 12

Splash-schermen mogen niet worden geladen vanuit een lay-outbestand, er kan nog steeds enige vertraging optreden bij het laden ervan.

De beste manier is om een thema te maken speciaal voor uw SplashScreenActivity en the android:windowBackgroundin te stellen op een tekenbare bron.

https://www.bignerdranch.com/blog/splash -screens-the-right-way/

In een notendop:

Declareer uw SplashScreenActivity in het manifest:

<activity
        android:name=".activities.SplashScreenActivity"
        android:theme="@style/SplashTheme"
        android:screenOrientation="portrait">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

In uw SplashScreenActivity.java:

@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Intent intent = new Intent(this, MainActivity_.class);
    startActivity(intent);
    finish();
}

Maak vervolgens de bron voor het achtergrondvenster van uw thema:

<style name="SplashTheme" parent="Theme.Bumpfie.Base">
    <item name="android:windowBackground">@drawable/splash</item>
</style>

Tekenbaar bestand splash.xml:

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@android:color/white"/>
    <item>
        <bitmap
            android:gravity="center"
            android:src="@drawable/app_logo"/>
    </item>
</layer-list>

Antwoord 13

Na Android Marshmallowis een ander productief gebruik van het welkomstscherm waar ik aan denk, het het aanvragen van de benodigde Android Permissionsin het welkomstscherm van je app.

het lijkt erop dat de meeste apps toestemmingsverzoeken op deze manier behandelen.

  • Dialogen maken een slechte UIX en ze breken de hoofdstroom en laten je beslissen over runtime en de waarheid is dat de meeste gebruikers er misschien niet eens om geven of je app iets op een SD-kaart wil schrijven. Sommigen van hen begrijpen misschien niet eens wat we proberen over te brengen totdat we het in gewoon Engels vertalen.

  • Als u in één keer toestemming vraagt, hoeft u voor elke bewerking minder “als anders” te gebruiken en ziet uw code er overzichtelijk uit.

Dit is een voorbeeld van hoe u toestemming kunt vragen voor uw splash-activiteit voor apparaten met Android OS 23+ .

Als alle machtigingen zijn verleend OF al zijn verleend OF de app draait op Pre Marshmallow DAN ga je gewoon de hoofdinhoud weergeven met een kleine vertraging van een halve seconde, zodat de gebruiker de moeite kan waarderen die we hebben gestoken in het lezen van deze vraag en proberen ons best te doen .

import android.Manifest;
import android.annotation.TargetApi;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.widget.Toast;
import com.c2h5oh.beer.R;
import com.c2h5oh.beer.utils.Animatrix;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SplashActivity extends AppCompatActivity {
    final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.splash);
        //show animations 
        Animatrix.scale(findViewById(R.id.title_play), 100);
        Animatrix.scale(findViewById(R.id.title_edit), 100);
        Animatrix.scale(findViewById(R.id.title_record), 100);
        Animatrix.scale(findViewById(R.id.title_share), 100);
        if (Build.VERSION.SDK_INT >= 23) {
            // Marshmallow+ Permission APIs
            fuckMarshMallow();
        } else {
            // Pre-Marshmallow
            ///Display main contents
            displaySplashScreen();
        }
    }
    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        switch (requestCode) {
            case REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS: {
                Map<String, Integer> perms = new HashMap<String, Integer>();
                // Initial
                perms.put(Manifest.permission.READ_EXTERNAL_STORAGE, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.RECORD_AUDIO, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.MODIFY_AUDIO_SETTINGS, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.VIBRATE, PackageManager.PERMISSION_GRANTED);
                // Fill with results
                for (int i = 0; i < permissions.length; i++)
                    perms.put(permissions[i], grantResults[i]);
                // Check for ACCESS_FINE_LOCATION
                if (perms.get(Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
                        && perms.get(Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
                        && perms.get(Manifest.permission.MODIFY_AUDIO_SETTINGS) == PackageManager.PERMISSION_GRANTED
                        && perms.get(Manifest.permission.VIBRATE) == PackageManager.PERMISSION_GRANTED) {
                    // All Permissions Granted
                    // Permission Denied
                    Toast.makeText(SplashActivity.this, "All Permission GRANTED !! Thank You :)", Toast.LENGTH_SHORT)
                            .show();
                    displaySplashScreen();
                } else {
                    // Permission Denied
                    Toast.makeText(SplashActivity.this, "One or More Permissions are DENIED Exiting App :(", Toast.LENGTH_SHORT)
                            .show();
                    finish();
                }
            }
            break;
            default:
                super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
    }
    @TargetApi(Build.VERSION_CODES.M)
    private void fuckMarshMallow() {
        List<String> permissionsNeeded = new ArrayList<String>();
        final List<String> permissionsList = new ArrayList<String>();
        if (!addPermission(permissionsList, Manifest.permission.READ_EXTERNAL_STORAGE))
            permissionsNeeded.add("Read SD Card");
        if (!addPermission(permissionsList, Manifest.permission.RECORD_AUDIO))
            permissionsNeeded.add("Record Audio");
        if (!addPermission(permissionsList, Manifest.permission.MODIFY_AUDIO_SETTINGS))
            permissionsNeeded.add("Equilizer");
        if (!addPermission(permissionsList, Manifest.permission.VIBRATE))
            permissionsNeeded.add("Vibrate");
        if (permissionsList.size() > 0) {
            if (permissionsNeeded.size() > 0) {
                // Need Rationale
                String message = "App need access to " + permissionsNeeded.get(0);
                for (int i = 1; i < permissionsNeeded.size(); i++)
                    message = message + ", " + permissionsNeeded.get(i);
                showMessageOKCancel(message,
                        new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                                        REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
                            }
                        });
                return;
            }
            requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                    REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
            return;
        }
        Toast.makeText(SplashActivity.this, "No new Permission Required- Launching App .You are Awesome!!", Toast.LENGTH_SHORT)
                .show();
        displaySplashScreen();
    }
    private void showMessageOKCancel(String message, DialogInterface.OnClickListener okListener) {
        new AlertDialog.Builder(SplashActivity.this)
                .setMessage(message)
                .setPositiveButton("OK", okListener)
                .setNegativeButton("Cancel", null)
                .create()
                .show();
    }
    @TargetApi(Build.VERSION_CODES.M)
    private boolean addPermission(List<String> permissionsList, String permission) {
        if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
            permissionsList.add(permission);
            // Check for Rationale Option
            if (!shouldShowRequestPermissionRationale(permission))
                return false;
        }
        return true;
    }
    /**
     * Display main content with little delay just so that user can see
     * efforts I put to make this page
     */
    private void displaySplashScreen() {
        new Handler().postDelayed(new Runnable() {
        /*
         * Showing splash screen with a timer. This will be useful when you
         * want to show case your app logo / company
         */
            @Override
            public void run() {
                startActivity(new Intent(SplashActivity.this, AudioPlayerActivity.class));
                finish();
            }
        }, 500);
    }
}

Antwoord 14

public class MainActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Thread t=new Thread()
    {
        public void run()
        {   
            try {
                sleep(2000);
                finish();
                Intent cv=new Intent(MainActivity.this,HomeScreen.class/*otherclass*/);
                startActivity(cv);
            } 
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    t.start();
}

Antwoord 15

Maak een activiteit, laat ons Activiteit met de naam ‘A’, maak dan een xml-bestand met de naam myscreen.xml, stel daarin een afbeelding van het opstartscherm in als achtergrond en gebruik vervolgens de afteltimer om van de ene activiteit naar de andere te navigeren. Om te weten hoe je de afteltimer kunt gebruiken, zie mijn antwoord in deze vraag TimerTask in Android?


Antwoord 16

Voorbeeld van spatscherm:

public class MainActivity extends Activity {
    private ImageView splashImageView;
    boolean splashloading = false;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        splashImageView = new ImageView(this);
        splashImageView.setScaleType(ScaleType.FIT_XY);
        splashImageView.setImageResource(R.drawable.ic_launcher);
        setContentView(splashImageView);
        splashloading = true;
        Handler h = new Handler();
        h.postDelayed(new Runnable() {
            public void run() {
                splashloading = false;
                setContentView(R.layout.activity_main);
            }
        }, 3000);
    }
}

Antwoord 17

Splash-scherm is een klein onbruikbaar object in Android: het kan niet zo snel mogelijk worden geladen om de vertraging van het starten van de hoofdactiviteit te verbergen. Er zijn twee redenen om het te gebruiken: reclame en netwerkactiviteiten.

Implementatie als dialoog zorgt ervoor dat je zonder vertraging van het startscherm naar de hoofdgebruikersinterface van de activiteit springt.

public class SplashDialog extends Dialog {
    ImageView splashscreen;
    SplashLoader loader;
    int splashTime = 4000;
    public SplashDialog(Context context, int theme) {
        super(context, theme);
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_splash);
        setCancelable(false);
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                cancel();
            }
        }, splashTime);
    }
}

Indeling:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="@color/white">
    <ImageView
        android:id="@+id/splashscreen"
        android:layout_width="190dp"
        android:layout_height="190dp"
        android:background="@drawable/whistle"
        android:layout_centerInParent="true" />
</RelativeLayout>

en start:

public class MyActivity extends ActionBarActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (getIntent().getCategories() != null &&  getIntent().getCategories().contains("android.intent.category.LAUNCHER")) {
            showSplashScreen();
        }
    }
    protected Dialog splashDialog;
    protected void showSplashScreen() {
        splashDialog = new SplashDialog(this, R.style.SplashScreen);
        splashDialog.show();
    }
    ...
}

Antwoord 18

Een andere aanpak wordt bereikt door CountdownTimer

te gebruiken

@Override
public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.splashscreen);
 new CountDownTimer(5000, 1000) { //5 seconds
      public void onTick(long millisUntilFinished) {
          mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
      }
     public void onFinish() {
          startActivity(new Intent(SplashActivity.this, MainActivity.class));
          finish();
     }
  }.start();
}

Antwoord 19

Soms openen gebruiker de SplashActivityen stop onmiddellijk, maar de app gaat nog steeds naar MainActivityna SPLASH_SCREEN_DISPLAY_LENGTH.

Om het te voorkomen: in SplashActivitymoet u controleren of de SplashActivityis voltooid of niet voordat u naar MainActivity

gaat

public class SplashActivity extends Activity {
    private final int SPLASH_SCREEN_DISPLAY_LENGTH = 2000;
    @Override
    public void onCreate(Bundle icicle) {
        ...
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                if (!isFinishing()) {//isFinishing(): If the activity is finishing, returns true; else returns false.
                    startActivity(new Intent(SplashActivity.this, MainActivity.class));
                    finish();
                }
            }, SPLASH_SCREEN_DISPLAY_LENGTH);
        }                             
   }                                
}

Ik hoop dat dit helpt


Antwoord 20

    - Add in SplashActivity 
   public class SplashActivity extends Activity {
       private ProgressBar progressBar;
       int i=0;
       Context context;
       private GoogleApiClient googleApiClient;
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_splash);
           context = this;
           new Handler().postDelayed(new Runnable() {
               @Override
               public void run() {
                   startActivity(new Intent(Splash.this, LoginActivity.class));
                   finish();
               }
           }, 2000);
       }
   }
  - Add in activity_splash.xml
   <RelativeLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools"
       xmlns:custom="http://schemas.android.com/apk/res-auto"
       android:background="@color/colorAccent"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       tools:context=".Splash">
       <ImageView
           android:id="@+id/ivLogo"
           android:layout_width="match_parent"
           android:layout_height="match_parent"
           android:src="@mipmap/icon_splash"
           android:layout_centerHorizontal="true"
           android:layout_centerVertical="true"/>
       <ProgressBar
           android:id="@+id/circle_progress"
           style="?android:attr/progressBarStyleHorizontal"
           android:layout_width="fill_parent"
           android:layout_height="wrap_content"
           android:layout_alignParentBottom="true"
           android:layout_marginBottom="5dp"
           android:max="100"
           android:progressTint="@color/green"
           android:visibility="visible" />
   </RelativeLayout>
  - Add in AndroidManifest.xml
    <activity android:name="ex.com.SplashActivity">
               <intent-filter>
                   <action android:name="android.intent.action.MAIN" />
                   <category android:name="android.intent.category.LAUNCHER" />
               </intent-filter>
           </activity>

Antwoord 21

Heel gemakkelijk & gr8 benadering :

Veel plezier!

Er zijn hier genoeg antwoorden die helpen bij de implementatie. dit bericht was bedoeld om anderen te helpen bij de eerste stap van het maken van het opstartscherm!


Antwoord 22

Wat dacht je van een superflexibel startscherm dat dezelfde code kan gebruiken en is gedefinieerd in AndroidManifest.xml, zodat de code nooit hoeft te veranderen. Ik ontwikkel over het algemeen codebibliotheken en ik hou er niet van om code aan te passen omdat het slordig is.

<activity
        android:name=".SplashActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
        <meta-data android:name="launch_class" android:value="com.mypackage.MyFirstActivity" />
        <meta-data android:name="duration" android:value="5000" />
</activity>

Vervolgens zoekt de SpashActivity zelf de metagegevens op voor “launch_class” om vervolgens de Intent zelf te maken. De “duur” van de metagegevens bepaalt hoe lang het opstartscherm blijft staan.

public class SplashActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
    super.onCreate(icicle);
    setContentView(R.layout.activity_splash);
    ComponentName componentName = new ComponentName(this, this.getClass());
    try {
        Bundle bundle = null;
        bundle = getPackageManager().getActivityInfo(componentName, PackageManager.GET_META_DATA).metaData;
        String launch_class = bundle.getString("launch_class");
        //default of 2 seconds, otherwise defined in manifest
        int duration = bundle.getInt("duration", 2000);
        if(launch_class != null) {
            try {
                final Class<?> c = Class.forName(launch_class);
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        Intent intent = new Intent(SplashActivity.this, c);
                        startActivity(intent);
                        finish();
                    }
                }, duration);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
  }
}

Antwoord 23

Hoewel er goede antwoorden zijn, zal ik de door Google aanbevolen manier laten zien:

1)Maak eerst een Themevoor het opstartscherm:
je hebt een thema genaamd splashscreenTheme, je launcher-thema zou zijn:

<style name="splashscreenTheme">
  <item name="android:windowBackground">@drawable/launch_screen</item>
</style>

Opmerking:

android:windowBackgroundstelt uw splashscreen-afbeelding al in nee
moet dit opnieuw in de gebruikersinterface doen.

je kunt hier ook kleur gebruiken in plaats van een tekenbaar.

2)Stel het thema in op manifestatie van splashscreenActivity

  <activity
            android:name=".activity.splashscreenActivity"
            android:screenOrientation="portrait"
            android:theme="@style/splashscreenTheme">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

3)zorg ervoor dat je launch_screen drawableniet in de map drawablestaat als je afbeelding niet klein is.

Het zal resulteren in een snellere start van het startscherm en u redden van het zwarte scherm

Het voorkomt ook extra rood staan


Antwoord 24

Dit is het beste bericht dat ik op startschermen heb gezien: http://saulmm .github.io/avding-android-cold-starts

Saúl Molinero maakt gebruik van twee verschillende opties voor welkomstschermen: gebruikmaken van de achtergrond van het venster om te animeren in uw beginscherm en de gebruikersinterface voor tijdelijke aanduidingen weergeven (wat een populaire keuze is die Google tegenwoordig voor de meeste van hun apps gebruikt).

p>

Ik verwijs elke keer naar dit bericht als ik de koude starttijd moet overwegen en het wegvallen van gebruikers door lange opstarttijden moet vermijden.

Hopelijk helpt dit!


Antwoord 25

In mijn geval wilde ik geen nieuwe activiteit maken om een afbeelding gedurende 2 seconden te laten zien. Bij het starten van mijn MainAvtivityworden afbeeldingen in houders geladen met picasso. Ik weet dat dit ongeveer 1 seconde duurt om te laden, dus besloot ik het volgende te doen in mijn MainActivity OnCreate:

splashImage = (ImageView) findViewById(R.id.spllll);
    this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
    int secondsDelayed = 1;
    new Handler().postDelayed(new Runnable() {
        public void run() {
            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
            splashImage.setVisibility(View.GONE);
        }
    }, secondsDelayed * 2000);

Bij het starten van de applicatie is het eerste wat er gebeurt, dat de ImageViewwordt weergegeven en de statusbalk wordt verwijderd door de venstervlaggen op volledig scherm te zetten. Daarna gebruikte ik een Handlerom 2 seconden te rennen, na de 2 seconden wist ik de vlaggen op het volledige scherm en stelde ik de zichtbaarheid van de ImageViewin op GONE. Makkelijk, simpel, effectief.


Antwoord 26

Het is heel eenvoudig in Android, we gebruiken gewoon het handler-concept om het opstartscherm te implementeren

Plak deze code in je SplashScreenActivity java-bestand.

Plaats in je SplashScreenActivity xml-bestandeen afbeelding met behulp van imageview.

public void LoadScreen() {
        final Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {                 
                Intent i = new Intent(SplashScreenActivity.this, AgilanbuGameOptionsActivity.class);
                startActivity(i);
            }
        }, 2000);
    }

Antwoord 27

U kunt dit toevoegen aan uw onCreate-methode

new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    // going to next activity
                    Intent i=new Intent(SplashScreenActivity.this,MainActivity.class);
                    startActivity(i);
                    finish();
                }
            },time);

En initialiseer uw tijdswaarde in milliseconden zoals u wilt…

private  static int time=5000;

download voor meer details de volledige code via deze link…

https://github.com/Mr-Perfectt/Splash-Screen


Antwoord 28

Schrijf in Kotlin deze code:-

Handler().postDelayed({
            val mainIntent = Intent([email protected], LoginActivity::class.java)
            startActivity(mainIntent)
            finish()
        }, 500)

Ik hoop dat dit je zal helpen.Bedankt……..


Antwoord 29

Eén manier is door een FullScreenActivity/EmptyActivity (zeg SplashScreenActivity) te maken en deze in te stellen als de eerste activiteit die wordt weergegeven wanneer u uw app opent. Voeg het volgende toe aan uw activiteit in de AndroidManifest.xml

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

Je kunt dan een handler instellen om deze activiteit na een paar seconden af te wijzen.

new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                Intent i= new Intent(SplashScreenActivity.this,MainActivity.class);
                startActivity(i); //start new activity 
                finish();
            }
        }, 3000); //time in milliseconds

Ten tweede, als u geen afzonderlijke activiteit wilt maken, kunt u een lay-out opblazen over uw MainActivityen de zichtbaarheid van de lay-out instellen op GONEof blaas de hoofdlay-out na een paar milliseconden op over de bestaande lay-out van het opstartscherm.


Antwoord 30

Eenvoudige code, het werkt 🙂Eenvoudige plons

int secondsDelayed = 1;
    new Handler().postDelayed(new Runnable() {
        public void run() {
            startActivity(new Intent(LoginSuccessFull.this, LoginActivity.class));
            finish();
        }
    }, secondsDelayed * 1500);

Other episodes