Wie mache ich einen Begrüßungsbildschirm?

Ich wollte, dass meine App professioneller aussieht, und entschied mich daher, einen Begrüßungsbildschirm zu erstellen.

Wie würde ich es erstellen und dann implementieren?

Weiterführende Literatur:

• Startzeit der App und thematische Startbildschirme (Android Performance Patterns Season 6 Ep. 4)
• Begrüßungsbildschirm in Android: Der richtige Weg

Alte Antwort:

WIE MAN : Einfacher Begrüßungsbildschirm

Diese Antwort zeigt Ihnen, wie Sie einen Begrüßungsbildschirm für einen festgelegten Zeitraum anzeigen, wenn Ihre App beispielsweise aus Branding-Gründen gestartet wird. Sie können beispielsweise den Begrüßungsbildschirm 3 Sekunden lang anzeigen. Wenn Sie jedoch den Begrüßungsbildschirm für eine variable Zeitspanne (z. B. Startzeit der App) anzeigen möchten, sollten Sie die Antwort von Abdullah unter https://stackoverflow.com/a/15832037/401025 lesen . Beachten Sie jedoch, dass der App-Start auf neuen Geräten möglicherweise sehr schnell erfolgt, sodass der Benutzer nur einen Flash sieht, der unter UX fehlerhaft ist.

Zuerst müssen Sie den Begrüßungsbildschirm in Ihrer layout.xmlDatei definieren

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

Und deine Tätigkeit:

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

Das ist alles ;)

Beachten Sie, dass der Benutzer bei dieser Lösung nicht länger warten muss: Die Verzögerung des Begrüßungsbildschirms hängt von der Startzeit der Anwendung ab.

Wenn Sie eine Android-App öffnen, wird standardmäßig ein schwarzer Bildschirm mit dem Titel und dem Symbol der App angezeigt. Sie können dies mithilfe eines Stils / Themas ändern.

Erstellen Sie zunächst eine style.xml im Werteordner und fügen Sie einen Stil hinzu.

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

Anstatt zu verwenden @android:style/Theme.DeviceDefault.Light.NoActionBar, können Sie jedes andere Thema als übergeordnetes Thema verwenden.

Zweitens fügen android:theme="@style/splashScreenTheme"Sie in Ihrer App Manifest.xml Ihrer Hauptaktivität hinzu.

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

Drittens aktualisieren Sie Ihr Thema in Ihrer onCreate () -Startaktivität.

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

UPDATE Schauen Sie sich diesen Beitrag an .

Vielen Dank an @ mat1h und @adelriosantiago

• Erstellen Sie eine Aktivität: Splash
• Erstellen Sie eine Layout-XML-Datei: splash.xml
• Fügen Sie UI-Komponenten in das splash.xml-Layout ein, damit es so aussieht, wie Sie es möchten

• Ihre Splash.java könnte folgendermaßen aussehen:

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

• Wechseln Sie ActivityB.classzu der Aktivität, die Sie nach dem Begrüßungsbildschirm starten möchten

• Überprüfen Sie Ihre Manifestdatei und es sollte so aussehen

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

Die obigen Antworten sind sehr gut, aber ich möchte noch etwas hinzufügen. Ich bin neu in Android, ich habe dieses Problem während meiner Entwicklung getroffen. hoffe, das kann jemandem wie mir helfen.

1. Der Begrüßungsbildschirm ist der Einstiegspunkt meiner App. Fügen Sie daher die folgenden Zeilen in AndroidManifest.xml hinzu.

       <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. Der Begrüßungsbildschirm sollte nur einmal im App-Lebenszyklus angezeigt werden. Ich verwende eine boolesche Variable, um den Status des Begrüßungsbildschirms aufzuzeichnen, und zeige ihn nur beim ersten Mal an.

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

Viel Spaß beim Codieren!

Abdullahs Antwort ist großartig. Aber ich möchte mit meiner Antwort noch einige Details hinzufügen.

Implementieren eines Begrüßungsbildschirms

Die richtige Implementierung eines Begrüßungsbildschirms ist etwas anders, als Sie sich vorstellen können. Die angezeigte Begrüßungsansicht muss sofort bereit sein, noch bevor Sie eine Layoutdatei in Ihrer Begrüßungsaktivität aufblasen können.

Sie werden also keine Layoutdatei verwenden. Geben Sie stattdessen den Hintergrund Ihres Begrüßungsbildschirms als Themenhintergrund der Aktivität an. Erstellen Sie dazu zunächst ein XML-Zeichen in res / drawable.

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

Es ist nur eine Ebenenliste mit Logo in der mittleren Hintergrundfarbe.

Öffnen Sie nun styles.xml und fügen Sie diesen Stil hinzu

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

Dieses Thema muss eine Aktionsleiste und einen Hintergrund haben, den wir gerade oben erstellt haben.

Und im Manifest müssen Sie SplashTheme auf Aktivität setzen, die Sie als Splash verwenden möchten.

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

Navigieren Sie dann in Ihrem Aktivitätscode zum Benutzer nach dem Spritzen mit Absicht zu dem bestimmten Bildschirm.

public class SplashActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Intent intent = new Intent(this, MainActivity.class);
        startActivity(intent);
        finish();
    }
}

Das ist der richtige Weg. Ich habe diese Referenzen als Antwort verwendet.

1. https://material.google.com/patterns/launch-screens.html
2. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ Vielen Dank an diese Leute, die mich in die richtige Richtung gebracht haben. Ich möchte anderen helfen, da eine akzeptierte Antwort nicht empfohlen wird, um einen Begrüßungsbildschirm zu erstellen.

1. Erstelle ein Activity SplashScreen.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.xml wird so sein

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

Ein Splash Screnn lässt Ihre Anwendung standardmäßig nicht automatisch professioneller aussehen. Ein professionell gestalteter Begrüßungsbildschirm bietet die Möglichkeit, Ihre Anwendung professioneller aussehen zu lassen. Wenn Sie jedoch nicht wissen, wie Sie eine schreiben sollen, wie professionell der Rest Ihrer Anwendung tatsächlich sein wird.

Der einzige Grund (Entschuldigung) für einen Begrüßungsbildschirm besteht darin, dass Sie eine große Anzahl von Berechnungen durchführen oder auf den Start von GPS / WiFi warten, da Ihre Anwendung vor dem Start darauf angewiesen ist. Ohne das Ergebnis dieser Berechnungen oder den Zugriff auf GPS / WiFi (usw.) ist Ihre Anwendung tot im Wasser, sodass Sie das Gefühl haben, einen Begrüßungsbildschirm zu benötigen, und MÜSSEN die Ansicht des Bildschirms für andere laufende Programme (einschließlich des Hintergrunds) blockieren ).

Ein solcher Begrüßungsbildschirm sollte wie Ihre Vollbildanwendung aussehen, um den Eindruck zu erwecken, dass er bereits initialisiert wurde. Nach Abschluss der langwierigen Berechnungen können die endgültigen Details ausgefüllt werden (das Bild wurde optimiert). Die Wahrscheinlichkeit, dass dies der Fall ist oder dass das Programm nur so gestaltet werden kann, ist sehr gering .

Es ist besser, dem Benutzer (und dem Rest des Betriebssystems) zu erlauben, etwas anderes zu tun, während er wartet, als Ihr Programm so zu gestalten, dass es von etwas abhängig ist, das eine Weile dauert (wenn die Dauer des Wartens ungewiss ist).

Auf Ihrem Telefon befinden sich bereits Symbole, die darauf hinweisen, dass GPS / WiFi gestartet wird. Die Zeit oder der Platz, die der Begrüßungsbildschirm einnimmt, kann zum Laden von Vorberechnungen oder zum tatsächlichen Ausführen der Berechnungen verwendet werden. Unter dem ersten Link unten finden Sie Informationen zu den von Ihnen verursachten Problemen und zu den zu berücksichtigenden Problemen.

Wenn Sie unbedingt auf diese Berechnungen oder GPS / WiFi warten müssen, lassen Sie die Anwendung am besten einfach starten und es erscheint ein Popup, in dem angegeben wird, dass auf die Berechnungen gewartet werden muss (eine TEXTUAL "Initializing" -Nachricht ist in Ordnung). Das Warten auf GPS / WiFi wird erwartet (wenn sie nicht bereits in einem anderen Programm aktiviert waren), sodass die Ankündigung ihrer Wartezeiten nicht erforderlich ist.

Denken Sie daran, dass Sie, wenn der Begrüßungsbildschirm startet, Ihr Programm bereits ausgeführt wird, lediglich die Verwendung Ihres Programms verzögern und die CPU / GPU dazu zwingen, etwas zu tun, das die meisten nicht für notwendig halten.

Wir sollten besser jedes Mal, wenn wir Ihr Programm starten, wirklich abwarten und Ihren Begrüßungsbildschirm sehen, sonst werden wir nicht das Gefühl haben, dass er sehr professionell geschrieben ist. Wenn Sie den Begrüßungsbildschirm zum VOLLSTÄNDIGEN Bildschirm und ein Duplikat des eigentlichen Programmbildschirms machen (wir glauben also, dass er initialisiert wird, obwohl dies nicht der Fall ist), KÖNNTE Ihr Ziel (Ihr Programm professioneller aussehen zu lassen) erreicht werden, aber ich würde nicht viel darauf wetten.

Warum nicht ? Http://cyrilmottier.com/2012/05/03/splash-screens-are-evil-dont-use-them/

Vorgehensweise: https://encrypted.google.com/search?q=Android+splash+screen+source

Es gibt also einen guten Grund, dies nicht zu tun, aber wenn Sie sicher sind, dass Ihre Situation irgendwie außerhalb dieser Beispiele liegt, sind die Mittel dafür oben angegeben. Stellen Sie sicher, dass Ihre Anwendung dadurch wirklich professioneller aussieht, oder Sie haben den einzigen Grund, den Sie dafür angegeben haben, besiegt.

Es ist wie bei einem YouTube-Kanal, der jedes Video mit einem langen grafischen Intro (und Outro) startet oder das Bedürfnis hat, einen Witz zu erzählen oder zu erklären, was in der letzten Woche passiert ist (wenn es sich nicht um einen Comedy- oder LifeStyles-Kanal handelt). Zeigen Sie einfach die Show! (Führen Sie einfach das Programm aus).

Vor allem die Antworten sind wirklich sehr gut. Es gibt jedoch Probleme mit Speicherverlusten. Dieses Problem wird in der Android-Community häufig als "Leckage einer Aktivität" bezeichnet. . Was genau bedeutet das nun?

Wenn Konfigurationsänderungen auftreten, z. B. Orientierungsänderungen, zerstört Android die Aktivität und erstellt sie neu. Normalerweise löscht der Garbage Collector nur den zugewiesenen Speicher der alten Activity-Instanz, und wir sind alle gut.

"Auslaufen einer Aktivität" bezieht sich auf die Situation, in der der Garbage Collector den zugewiesenen Speicher der alten Aktivitätsinstanz nicht löschen kann, da dies der Fall istbeing (strong) referenced von einem Objekt stammt, das die Aktivitätsinstanz überlebt hat. Jeder Android-App ist eine bestimmte Speichermenge zugewiesen. Wenn Garbage Collector nicht verwendeten Speicherplatz nicht freigeben kann, nimmt die Leistung der App allmählich ab und stürzt schließlich abOutOfMemory Fehler ab.

Wie kann man feststellen, ob die App Speicher verliert oder nicht? Am schnellsten öffnen Sie die Registerkarte Speicher in Android Studio und achten beim Ändern der Ausrichtung auf den zugewiesenen Speicher. Wenn der zugewiesene Speicher weiter zunimmt und nie abnimmt, liegt ein Speicherverlust vor.

1. Speicherleck, wenn Benutzer die Ausrichtung ändern.

Zuerst müssen Sie den Splash - Screen in Ihrer Layout - Ressource definieren splashscreen.xmlDatei

Beispielcode für die Aktivität des Begrüßungsbildschirms.

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

Für weitere Informationen gehen Sie bitte über diesen Link

Das Anhalten auf dem Begrüßungsbildschirm für 4's 5's macht unnötig wenig Sinn. Es ist in Ordnung, wenn Sie etwas im Hintergrund laden. Befolgen Sie diesen Ansatz, um den Begrüßungsbildschirm zu implementieren: - Die richtige Implementierung eines Begrüßungsbildschirms unterscheidet sich ein wenig, als Sie sich vorstellen können. Die angezeigte Begrüßungsansicht muss sofort bereit sein, noch bevor Sie eine Layoutdatei in Ihrer Begrüßungsaktivität aufblasen können.

Sie werden also keine Layoutdatei verwenden. Geben Sie stattdessen den Hintergrund Ihres Begrüßungsbildschirms als Themenhintergrund der Aktivität an. Erstellen Sie dazu zunächst ein XML-Zeichen 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 habe ich eine Hintergrundfarbe und ein Bild eingerichtet.

Als Nächstes legen Sie dies als Hintergrund für Ihre Splash-Aktivität im Thema fest. Navigieren Sie zu Ihrer Datei styles.xml und fügen Sie ein neues Thema für Ihre Begrüßungsaktivität hinzu:

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

Legen Sie in Ihrem neuen SplashTheme das Fensterhintergrundattribut auf Ihr XML-Zeichenelement fest. Konfigurieren Sie dies als Thema Ihrer Splash-Aktivität in Ihrer 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>

Schließlich sollte die SplashActivity-Klasse Sie nur zu Ihrer Hauptaktivität weiterleiten:

     public class SplashActivity extends AppCompatActivity {

             @Override
             protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);

               Intent intent = new Intent(this, MainActivity.class);
               startActivity(intent);
               finish();
    }
}

Weitere Details finden Sie hier: 1. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ 2. http://blog.goodbarber.com/3-tips-to-create-a -großer Begrüßungsbildschirm für Ihre mobile App_a287.html

Dies ist der vollständige 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 Drawables erstellen Sie diese 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>

Erstellen Sie in styles.xml ein benutzerdefiniertes Thema

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

und schließlich in AndroidManifest.xml das Thema für Ihre Aktivität angeben

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

Prost.

Begrüßungsbildschirme sollten nicht aus einer Layoutdatei geladen werden. Beim Laden kann es dennoch zu Verzögerungen kommen.

Der beste Weg ist, ein Thema nur für Ihre the android:windowBackgroundSplashScreenActivity zu erstellen und auf eine zeichnbare Ressource zu setzen.

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

In einer Nussschale:

Deklarieren Sie Ihre SplashScreenActivity im 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 Ihrer SplashScreenActivity.java:

@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    Intent intent = new Intent(this, MainActivity_.class);
    startActivity(intent);
    finish();

}

Erstellen Sie als Nächstes die Ressource für das Hintergrundfenster Ihres Themas:

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

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

Nach Android Marshmallow ist eine andere produktive Verwendung des Splash-Bildschirms, an die ich denke , erforderlichAndroid Permissions Ihrer App .

Es scheint, als würden die meisten Apps Berechtigungsanfragen auf diese Weise verarbeiten.

• Dialoge machen UIX schlecht und sie unterbrechen den Hauptfluss und lassen Sie über die Laufzeit entscheiden. In Wahrheit ist es den meisten Benutzern möglicherweise egal, ob Ihre App etwas auf eine SD-Karte schreiben möchte. Einige von ihnen verstehen möglicherweise nicht einmal, was wir vermitteln wollen, bis wir es in einfaches Englisch übersetzen.

• Wenn Sie gleichzeitig Berechtigungen anfordern, wird vor jedem Vorgang weniger "if else" angezeigt, und Ihr Code sieht übersichtlich aus.

Dies ist ein Beispiel dafür, wie Sie in Ihrer Begrüßungsaktivität für Geräte mit Android OS 23+ nach Berechtigungen fragen können.

Wenn alle Berechtigungen erteilt wurden ODER bereits erteilt wurden ODER die App auf Pre Marshmallow ausgeführt wird, können Sie den Hauptinhalt mit einer kurzen Verzögerung von einer halben Sekunde anzeigen, damit der Benutzer die Anstrengungen schätzen kann, die wir unternommen haben, um diese Frage zu lesen und unser Bestes zu geben.

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


}

Sie werden keine Layoutdatei verwenden. Geben Sie stattdessen den Hintergrund Ihres Begrüßungsbildschirms als Themenhintergrund der Aktivität an. Erstellen Sie dazu zunächst ein XML-Zeichen in res / drawable.

Hinweis: Der gesamte unten stehende Code ist als GitHub Link verfügbar

<?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 habe ich eine Hintergrundfarbe und ein Bild eingerichtet.

Als Nächstes legen Sie dies als Hintergrund für Ihre Splash-Aktivität im Thema fest. Navigieren Sie zu Ihrer Datei styles.xml und fügen Sie ein neues Thema für Ihre Begrüßungsaktivität hinzu:

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

Legen Sie in Ihrem neuen SplashTheme das Fensterhintergrundattribut auf Ihr XML-Zeichenelement fest. Konfigurieren Sie dies als Thema Ihrer Splash-Aktivität in Ihrer 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>

Schließlich sollte Ihre SplashActivity-Klasse Sie nur zu Ihrer Hauptaktivität weiterleiten:

public class SplashActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Intent intent = new Intent(this, MainActivity.class);
        startActivity(intent);
        finish();
    }
}

Beachten Sie, dass Sie nicht einmal eine Ansicht für diese SplashActivity einrichten. Die Ansicht kommt vom Thema. Wenn Sie die Benutzeroberfläche für Ihre Begrüßungsaktivität im Thema einrichten, ist sie sofort verfügbar.

Wenn Sie eine Layoutdatei für Ihre Begrüßungsaktivität hätten, wäre diese Layoutdatei für den Benutzer erst sichtbar, nachdem Ihre App vollständig initialisiert wurde, was zu spät ist. Sie möchten, dass der Splash nur in der kurzen Zeit angezeigt wird, bevor die App initialisiert wird.

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

Erstellen Sie eine Aktivität, lassen Sie uns eine Aktivität mit dem Namen 'A' erstellen, erstellen Sie dann eine XML-Datei mit dem Namen myscreen.xml, in der das Begrüßungsbildschirmbild als Hintergrund festgelegt wird, und navigieren Sie dann mit dem Countdown-Timer von einer Aktivität zur nächsten. Um zu wissen, wie man den Countdown- Timer verwendet, siehe meine Antwort in dieser Frage TimerTask in Android?

Beispiel für einen Begrüßungsbildschirm:

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

    }

}

Der Begrüßungsbildschirm ist in Android ein wenig unbrauchbares Objekt: Er kann nicht so schnell wie möglich geladen werden, um die Verzögerung des Starts der Hauptaktivität zu verbergen. Es gibt zwei Gründe, es zu verwenden: Werbung und Netzwerkbetrieb.

Durch die Implementierung als Dialogfeld wird unverzüglich vom Begrüßungsbildschirm zur Hauptbenutzeroberfläche der Aktivität gesprungen.

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

    }
}

Layout:

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

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

    ...
}

Ein anderer Ansatz wird durch die Verwendung von CountDownTimer erreicht

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

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

Wirklich einfacher & gr8 Ansatz:

• Erstellen Sie zuerst Ihren Splash mit der folgenden Website:

  https://www.norio.be/android-feature-graphic-generator/

  Wählen Sie Ihr Logo und Ihren Slogan, wählen Sie Ihren schönen Hintergrund. Ändern Sie die Größe auf 4096 x 4096.

• Laden Sie nun das Bild herunter und aktualisieren Sie es auf:

  https://apetools.webprofusion.com/app/#/tools/imagegorilla

  Und generieren Sie alle benötigten Begrüßungsbildschirme, alle Geräte, alle Plattformen.

Genießen!

Hier gibt es genügend Antworten, die bei der Implementierung helfen. Dieser Beitrag sollte anderen beim ersten Schritt der Erstellung des Begrüßungsbildschirms helfen!

Wie wäre es mit einem superflexiblen Startbildschirm, der denselben Code verwenden kann und in der Datei AndroidManifest.xml definiert ist, sodass der Code niemals geändert werden muss. Ich entwickle im Allgemeinen Codebibliotheken und mag es nicht, Code anzupassen, weil er schlampig ist.

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

Dann sucht die SpashActivity selbst die Metadaten nach "launch_class", um dann die Absicht selbst zu erstellen. Die Metadaten "Dauer" definieren, wie lange der Begrüßungsbildschirm aktiv bleibt.

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

Irgendwann den Benutzer öffnen SplashActivityund sofort beenden , aber die App gehen noch MainActivitynach SPLASH_SCREEN_DISPLAY_LENGTH.

Um dies zu verhindern: In SplashActivitysollten Sie überprüfen, ob der SplashActivityVorgang abgeschlossen ist oder nicht, bevor Sie zu wechselnMainActivity

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

Ich hoffe das hilft

Obwohl es gute Antworten gibt, werde ich den von Google empfohlenen Weg zeigen:

1) Erstellen Sie zuerst einen ThemeBegrüßungsbildschirm: Sie haben ein Thema mit dem Namen " splashscreenThemeLauncher".

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

Hinweis:

android:windowBackground Setzt bereits Ihr Splashscreen-Bild Nr
erneut in der Benutzeroberfläche ausgeführt werden muss.

Sie können hier auch Farbe anstelle eines Zeichens verwenden.

2) Setzen Sie das Thema auf Manifest von 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) Stellen Sie sicher, dass sich launch_screen drawablenicht im drawableOrdner befindet, wenn Ihr Bild nicht klein ist.

Dies führt zu einem schnelleren Start des Startbildschirms und schützt Sie vor dem schwarzen Bildschirm

Es vermeidet auch zusätzliches Überziehen

Dies ist der beste Beitrag, den ich auf Begrüßungsbildschirmen gesehen habe: http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero bietet zwei verschiedene Optionen für Begrüßungsbildschirme: Nutzen Sie den Fensterhintergrund, um Ihren Startbildschirm zu animieren, und zeigen Sie die Platzhalter-Benutzeroberfläche an (eine beliebte Option, die Google heutzutage für die meisten seiner Apps verwendet).

Ich beziehe mich jedes Mal auf diesen Beitrag, wenn ich die Kaltstartzeit berücksichtigen und Benutzerabbrüche aufgrund langer Startzeiten vermeiden muss.

Hoffe das hilft!

In meinem Fall wollte ich keine neue Aktivität erstellen, um nur 2 Sekunden lang ein Bild anzuzeigen. Wenn ich meine MainAvtivityBilder mit Picasso in Halterungen lade, weiß ich, dass das Laden ungefähr 1 Sekunde dauert. Deshalb habe ich beschlossen, in meiner MainActivity Folgendes zu tun 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);

Beim Starten der Anwendung wird als Erstes die ImageViewangezeigt und die Statusleiste entfernt, indem die Fensterflags auf Vollbild gesetzt werden. Dann habe ich a verwendet Handler, um 2 Sekunden lang zu laufen. Nach 2 Sekunden lösche ich die Vollbild-Flags und stelle die Sichtbarkeit von ImageViewto ein GONE. Einfach, einfach, effektiv.

Es ist wirklich einfach in Android, wir verwenden nur das Handler-Konzept, um den Begrüßungsbildschirm zu implementieren

Fügen Sie diesen Code in Ihre Java-Datei SplashScreenActivity ein.

Fügen Sie in Ihre SplashScreenActivity-XML-Datei ein beliebiges Bild mit der Bildansicht ein.

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

Sie können dies in Ihre onCreate-Methode einfügen

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

Und initialisieren Sie Ihren Zeitwert in Millisekunden, wie Sie möchten ...

private  static int time=5000;

Für weitere Informationen laden Sie den vollständigen Code von diesem Link herunter ...

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

In Kotlin schreiben Sie diesen Code: -

 Handler().postDelayed({
            val mainIntent = Intent(this@SplashActivity, LoginActivity::class.java)
            startActivity(mainIntent)
            finish()
        }, 500)

Hoffe das wird dir helfen. Danke ........

Einfacher Code, es funktioniert :) Einfaches Spritzen

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

public class SplashActivity extends Activity {

  Context ctx;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      ctx = this;
      setContentView(R.layout.activity_splash);

      Thread thread = new Thread(){
          public void run(){
              try {
                  sleep(3000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }

              Intent in = new Intent(ctx,MainActivity.class);
              startActivity(in);
              finish();
          }
      };
      thread.start();
  }
}