Wie mache ich einen Begrüßungsbildschirm?

548

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?

Ephraim
quelle
58
Warum sieht eine Anwendung mit einem Begrüßungsbildschirm professioneller aus? Ich kenne keine "professionelle" Android-App, die eine hat.
Theomega
7
Einverstanden mit @theomega. Begrüßungsbildschirme sind einfach nur nervig.
Matt Ball
85
Sie sollten einen Begrüßungsbildschirm nur anzeigen, wenn Sie Hintergrundladevorgänge ausführen müssen. Andernfalls sieht Ihre App "professioneller" aus, wenn Sie dem Benutzer so schnell wie möglich das geben, was er von Ihrer App erwartet. Benutzer bemerken (und ärgern sich über) Verzögerungen von mehr als 100 ms, und Sie liegen eine Größenordnung über diesem Schwellenwert, indem Sie einen Begrüßungsbildschirm hinzufügen.
CodeFusionMobile
74
Kindle App, Aldiko (Leser), Delphin .. Umm das Betriebssystem :) Sie alle haben einen Schuss bekommen. Opera Mobile, Mantan Reader, Karten. Ich könnte weitermachen Wenn es eine Last verbirgt, teilt es dem Benutzer zumindest mit, dass Ihre App gestartet wurde. Eine Verzögerung von einigen Sekunden wird viel besser ausgeblendet, wenn zumindest etwas von Ihnen auf dem Bildschirm angezeigt wird.
Baash05
9
Der Begrüßungsbildschirm bietet Ihnen eine hervorragende Möglichkeit, den Namen oder das Logo Ihres Spiels oder Ihrer App-Firma zu bewerben. Ich mag es, den Begrüßungsbildschirm anklickbar zu machen, damit der Benutzer die Möglichkeit hat, zum Spiel zu springen. Wenn der Benutzer bei jedem Öffnen Ihrer App immer nur eine halbe Sekunde lang das Logo Ihres Unternehmens sieht, wird er sich mit größerer Wahrscheinlichkeit daran erinnern, wer zum Teufel Sie sind. Stellen Sie einfach sicher, dass sie eine gute Erfahrung mit Ihrer App haben.
Chamatake-san

Antworten:

509

Weiterführende Literatur:

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

Upvote
quelle
3
@ user2606414 Bitte erstellen Sie eine Frage zu SO für Ihr Problem und fügen Sie Ihr gesamtes Fehlerprotokoll ein.
Upvote
39
Vergessen Sie nicht, Splash in Manifest
Jawad Zeb
8
@ Peter die Frage ist nicht, wie ein Begrüßungsbildschirm beim Laden von Daten angezeigt werden soll.
Upvote
18
Dies ist keine geeignete Lösung für einen Begrüßungsbildschirm. Der Benutzer muss warten, bis ein Begrüßungsbildschirm angezeigt wird. Der Zweck des Begrüßungsbildschirms ist jedoch umgekehrt. Es sollte ein Begrüßungsbildschirm angezeigt werden, während der Benutzer wartet. Bitte sehen Sie @ Abdullahs Lösung.
Efeyc
4
Anstatt die App für einige SPLASH_DISPLAY_LENGTHZeit anzuhalten . Sie sollten dies stattdessen tun: bignerdranch.com/blog/splash-screens-the-right-way
miguel.martin
595

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

Abdullah
quelle
3
Es scheint, dass das "Elternteil" nur in API 14 und höher unterstützt wird
user1832478
103
Dies ist der richtige Weg, um einen Begrüßungsbildschirm zu erstellen. Vielen Dank! Die Antwort mit mehr Stimmen mit Verzögerungen ist nur eine schlechte Praxis. Nichts sollte den Benutzer daran hindern, den ersten Funktionsbildschirm zu sehen.
Dineth
7
Ein Problem, das ich damit hatte, ist, dass <item name="android:background">das überschreiben würde windowBackground. Und ohne android:backgroundDefinition wäre mein Hintergrund in irgendwelchen Fragmenten transparent und würde die Aktivität hinter dem Vordergrundinhalt enthüllen.
William Grand
4
@Abdullah: Ich bin dem Weg gefolgt, den du gesagt hast. Es funktioniert einwandfrei, aber der Begrüßungsbildschirm wird bei Aktivitätsübergängen einige Millisekunden lang angezeigt.
nizam.sp
3
@Abdullah Danke! Das wäre eine mögliche Lösung, aber ich fand dies: plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd , um zu vermeiden, dass für jede Bildschirmgröße unterschiedliche Bilder erstellt werden, ist es auch möglich, ein XML zu erstellen, das das Bild enthält, damit es aussieht gut auf allen Bildschirmen.
Adelriosantiago
52
  • 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>
James
quelle
28
Dies ist nicht der Zweck des Begrüßungsbildschirms. Dies führt zu einer zusätzlichen Verzögerung von 1 Sekunde. Der Begrüßungsbildschirm sollte ein Bild sein, während der erste Bildschirm der Anwendung geladen wird. Dieser Link kann helfen. stackoverflow.com/a/7057332/869451
efeyc
2
@efeyc: du hast 100% recht .. doch es sieht ziemlich gut aus wenn die App startet .. findest du nicht?
McLan
1
@ Suda.nese definitiv nicht. Benutzer möchten sich kein Bild ansehen, Benutzer möchten die App verwenden und haben keine unnötige Verzögerung
Tim
1
@ TimCastelijns Es hängt von der in der Entwicklung befindlichen App ab und wie der Begrüßungsbildschirm aussieht. Natürlich soll es praktisch sein, aber wer sagt, dass es nicht anders verwendet werden kann !!
McLan
6
Agreed @ Suda.nese Wenn die App-Anforderungen einen Begrüßungsbildschirm enthalten, ist dies ein Begrüßungsbildschirm! Sicher, es mag für Benutzer nicht wünschenswert sein, aber wenn ein Client einen
Begrüßungsbildschirm
29

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!

zdd
quelle
10
Sie können hinzufügen , android:noHistory="true"in AndroidManifest.xmlvon dem Benutzer zu verhindern , dass der Splash - Screen mit der Zurück - Taste zurück.
Rachel
15

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.
Zeeshan Shabbir
quelle
1
Ich habe ein Tutorial YouTubedazu gesehen. Aber ich denke, die Bitmap-Größe wird das Problem sein, da Sie die Größe nicht mit ändern können layer-list.
RoCk RoCk
14
  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> 
Saba
quelle
13

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

rauben
quelle
12

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. Geben Sie hier die Bildbeschreibung ein

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

Maheshwar Ligade
quelle
7

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

vicky
quelle
4

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.

awsleiman
quelle
Wie würde ich eine XML-Datei anstelle vondrawable
Viper
Ich meine, Sie müssen bg_splash.xml im Drawable-Verzeichnis wie oben beschrieben erstellen.
Awsleiman
4

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>
Danny Yassine
quelle
4

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


}
Hitesh Sahu
quelle
4

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.

Abhi Soni
quelle
3
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();
}
Kamalasekar
quelle
2

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?

Sankar Ganesh
quelle
2

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

    }

}
kablu
quelle
2

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

    ...
}
tse
quelle
Es gibt einen Nutznießer für diesen Ansatz, dh Sie können die MainActivity direkt starten. Wenn Sie beispielsweise die Push-Benachrichtigung in Ihrer App verwenden und Ihre App durch Klicken auf die Benachrichtigung starten, können Sie die Benachrichtigungszwecke auf diese Weise besser verwalten.
Farnad Tohidkhah
2

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();
}
ugur
quelle
2
     - 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>
Ashish Kumar
quelle
Könnten Sie bitte auch eine Erklärung hinzufügen?
Robert
Ja sicher ... welche Erklärung du willst, lass es mich bitte wissen.
Ashish Kumar
2

Wirklich einfacher & gr8 Ansatz:

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!

jony89
quelle
1

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();
    }
  }
}
Joel Teply
quelle
1

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

Phan Van Linh
quelle
1

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

ColdFusion
quelle
1

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!

w3bshark
quelle
1

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.

Klasse a
quelle
1

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);
    }
Agilanbu
quelle
1

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

Ankit Singh
quelle
1

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

Rahul Kushwaha
quelle
0

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);
Agilanbu
quelle
0
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();
  }
}
Rishabh Dixit
quelle
Dies ist ein schlechtes Beispiel - was passiert, wenn Sie die SplashActivity durch Zurückdrücken verlassen? Der Thread wird weiterhin ausgeführt.
Mark Keen