Come faccio a creare una schermata iniziale?

Volevo rendere la mia app più professionale, quindi ho deciso di creare una schermata iniziale.

Come lo creerei e poi lo implementerei?

Ulteriori letture:

• Tempo di lancio dell'app e schermate di lancio a tema (Android Performance Patterns Stagione 6 Ep. 4)
• Schermata iniziale in Android: la strada giusta

Vecchia risposta:

COME : Schermata iniziale semplice

Questa risposta mostra come visualizzare una schermata iniziale per un periodo di tempo fisso all'avvio dell'app, ad esempio per motivi di branding. Ad esempio, potresti scegliere di mostrare la schermata iniziale per 3 secondi. Tuttavia, se desideri mostrare la schermata di spash per un periodo di tempo variabile (ad es. Tempo di avvio dell'app), dai un'occhiata alla risposta di Abdullah https://stackoverflow.com/a/15832037/401025 . Tuttavia, tieni presente che l'avvio delle app potrebbe essere molto veloce su nuovi dispositivi, quindi l'utente vedrà solo un flash che è un UX negativo.

Per prima cosa devi definire la schermata di spash nel tuo layout.xmlfile

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

E la tua attività:

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

È tutto ;)

Nota che questa soluzione non permetterà all'utente di attendere di più: il ritardo della schermata iniziale dipende dal tempo di avvio dell'applicazione.

Quando apri qualsiasi app Android otterrai di default una schermata nera con il titolo e l'icona dell'app in alto, puoi cambiarla usando uno stile / tema.

Innanzitutto, crea uno style.xml nella cartella dei valori e aggiungi uno stile.

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

Invece di usare @android:style/Theme.DeviceDefault.Light.NoActionBarpuoi usare qualsiasi altro tema come genitore.

In secondo luogo, nella tua app Manifest.xml aggiungi android:theme="@style/splashScreenTheme"alla tua attività principale.

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

Terzo, aggiorna il tuo tema nella tua attività di lancio onCreate ().

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

AGGIORNA Dai un'occhiata a questo post .

Grazie a @ mat1h e @adelriosantiago

• Crea un'attività: Splash
• Creare un file XML di layout: splash.xml
• Inserisci i componenti dell'interfaccia utente nel layout splash.xml in modo che appaia come desideri

• il tuo Splash.java potrebbe assomigliare a questo:

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

• cambiamento ActivityB.classa qualsiasi attività che si desidera avviare dopo la schermata iniziale

• controlla il tuo file manifest e dovrebbe apparire come

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

Le risposte sopra sono molto buone, ma vorrei aggiungere qualcos'altro. Sono nuovo su Android, ho riscontrato questi problemi durante il mio sviluppo. spero che questo possa aiutare qualcuno come me.

1. La schermata iniziale è il punto di ingresso della mia app, quindi aggiungi le seguenti righe in AndroidManifest.xml.

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

2. La schermata iniziale dovrebbe essere visualizzata solo una volta nel ciclo di vita dell'app, utilizzo una variabile booleana per registrare lo stato della schermata iniziale e mostrarla solo la prima volta.

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

buona programmazione!

La risposta di Abdullah è ottima. Ma voglio aggiungere qualche dettaglio in più con la mia risposta.

Implementazione di una schermata iniziale

L'implementazione di una schermata iniziale nel modo giusto è leggermente diversa da come si possa immaginare. La vista splash che vedi deve essere pronta immediatamente, anche prima di poter gonfiare un file di layout nella tua attività splash.

Quindi non userai un file di layout. Invece, specifica lo sfondo della tua schermata iniziale come sfondo del tema dell'attività. Per fare ciò, creare prima un oggetto XML drawable 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>

È solo un layerlist con logo in colore di sfondo centrale con esso.

Ora apri styles.xml e aggiungi questo stile

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

Questo tema dovrà essere sulla barra delle azioni e con lo sfondo che abbiamo appena creato sopra.

E in manifest è necessario impostare SplashTheme sull'attività che si desidera utilizzare come splash.

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

Quindi, all'interno del codice attività, passa l'utente alla schermata specifica dopo lo splash usando l'intento.

public class SplashActivity extends AppCompatActivity {

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

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

Questo è il modo giusto di fare. Ho usato questi riferimenti per la risposta.

1. https://material.google.com/patterns/launch-screens.html
2. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ Grazie a questi ragazzi per avermi spinto nella giusta direzione. Voglio aiutare gli altri perché la risposta accettata non è consigliata per la schermata iniziale.

1. Creare un 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 sarà così

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

Uno Splash Screnn, per impostazione predefinita, non rende automaticamente l'applicazione più professionale. Uno schermo Splash progettato in modo professionale ha la possibilità di rendere la tua applicazione più professionale, ma se non sai come scriverne una, allora quanto sarà professionale il resto della tua applicazione.

L'unico motivo (scusa) per avere una schermata iniziale è perché stai eseguendo una grande quantità di calcoli o stai aspettando l'avvio del GPS / WiFi perché l'applicazione si basa su quello prima dell'avvio. Senza il risultato di questi calcoli o l'accesso a GPS / WiFi (ecc.) L'applicazione è morta nell'acqua, quindi senti di aver bisogno di una schermata di avvio e DEVI bloccare la visualizzazione dello schermo per qualsiasi altro programma in esecuzione (incluso lo sfondo ).

Una tale schermata iniziale dovrebbe apparire come la tua applicazione a schermo intero per dare l'impressione che sia già stata inizializzata, quindi dopo aver completato i lunghi calcoli i dettagli finali potrebbero essere compilati (l'immagine ottimizzata). La possibilità che ciò avvenga o che sia l'unico modo in cui il Programma potrebbe essere progettato è estremamente ridotta .

Sarebbe meglio consentire all'utente (e al resto del sistema operativo) di fare qualcos'altro mentre aspettano piuttosto che progettare il programma in modo che dipenda da qualcosa che richiederà del tempo (quando la durata dell'attesa è incerta).

Sul telefono sono già presenti icone che indicano che il GPS / WiFi si sta avviando. Il tempo o lo spazio occupato da Splash Screen potrebbe essere speso caricando pre-calcoli o eseguendo effettivamente i calcoli. Vedi il primo link in basso per i problemi che crei e quali devono essere considerati.

Se devi assolutamente attendere questi calcoli o GPS / WiFi, sarebbe meglio semplicemente avviare l'applicazione e avere un pop-up che dice che è necessario attendere i calcoli (un messaggio di "Inizializzazione" TESTUALE va bene). È prevista l'attesa per GPS / WiFi (se non erano già abilitati in un altro programma), pertanto non è necessario annunciare i loro tempi di attesa.

Ricorda che quando la schermata iniziale avvia il tuo programma È già in esecuzione, tutto ciò che stai facendo è ritardare l'uso del programma e eseguire il hogging della CPU / GPU per fare qualcosa che la maggior parte non ritiene necessario.

È meglio che desideriamo davvero aspettare e vedere la tua schermata iniziale ogni volta che avvieremo il tuo programma o non sentiremo che è scritto in modo molto professionale. Rendere la schermata iniziale completa e un duplicato della schermata del programma reale (quindi pensiamo che sia inizializzata quando in realtà non l'ha fatto) POTREBBE raggiungere il tuo obiettivo (rendere il tuo programma più professionale) ma non ci scommetterei molto su questo.

Perché non farlo: http://cyrilmottier.com/2012/05/03/splash-screens-are-evil-dont-use-them/

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

Quindi c'è una buona ragione per non farlo, ma SE sei certo che in qualche modo la tua situazione non rientra in quegli esempi, allora i mezzi per farlo sono dati sopra. Assicurati che la tua applicazione appaia davvero più professionale o hai sconfitto l'unica ragione che hai dato per farlo.

È come un canale YouTube che avvia ogni video con una lunga intro grafica (e Outro) o sente la necessità di raccontare una barzelletta o spiegare cosa è successo durante la settimana passata (quando non è un canale Comedy o LifeStyles). Mostra solo lo spettacolo! (Basta eseguire il programma).

Soprattutto le risposte sono davvero molto buone. Ma ci sono problemi di perdita di memoria. Questo problema è spesso noto nella comunità Android come "Perdita di attività" . Cosa significa esattamente?

Quando si verifica una modifica della configurazione, come la modifica dell'orientamento, Android distrugge l'attività e la ricrea. Normalmente, Garbage Collector cancella semplicemente la memoria allocata della vecchia istanza Activity e siamo tutti a posto.

"Perdita di un'attività" si riferisce alla situazione in cui Garbage Collector non può cancellare la memoria allocata della vecchia istanza di attività poiché being (strong) referencedproviene da un oggetto che ha vissuto l'istanza di attività. Ogni app Android ha una quantità specifica di memoria allocata per essa. Quando Garbage Collector non è in grado di liberare memoria inutilizzata, le prestazioni dell'app diminuiranno gradualmente e alla fine si arresteranno in modo anomalo OutOfMemory.

Come determinare se l'app perde memoria o no? Il modo più veloce è aprire la scheda Memoria in Android Studio e prestare attenzione alla memoria allocata mentre si cambia l'orientamento. Se la memoria allocata continua ad aumentare e non diminuisce mai, si verifica una perdita di memoria.

1. Perdita di memoria quando l'utente cambia l'orientamento.

Innanzitutto è necessario definire la schermata iniziale nel splashscreen.xmlfile di risorse del layout

Codice di esempio per l'attività della schermata iniziale.

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

Per ulteriori informazioni, consultare questo link

L'arresto sulla schermata di Splash per 4 di 5 inutilmente non ha molto senso. Va bene se stai caricando qualcosa in background altrimenti segui questo approccio per implementare la schermata iniziale: - implementazione di una schermata iniziale nel modo giusto è un po 'diversa da come potresti immaginare. La vista splash che vedi deve essere pronta immediatamente, anche prima di poter gonfiare un file di layout nella tua attività splash.

Quindi non userai un file di layout. Invece, specifica lo sfondo della tua schermata iniziale come sfondo del tema dell'attività. Per fare questo, prima di tutto, crea un XML drawable 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>

Qui, ho impostato un colore di sfondo e un'immagine.

Successivamente, imposterai questo come sfondo della tua attività splash nel tema. Passare al file styles.xml e aggiungere un nuovo tema per l'attività splash:

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

Nel tuo nuovo SplashTheme, imposta l'attributo sullo sfondo della finestra sul tuo disegno XML. Configuralo come tema della tua attività splash nel tuo 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>

Infine, la classe SplashActivity dovrebbe semplicemente inoltrarti alla tua attività principale:

     public class SplashActivity extends AppCompatActivity {

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

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

Maggiori dettagli leggi questo: 1. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ 2. http://blog.goodbarber.com/3-tips-to-create-a -grande-schermata iniziale-per-il-tuo-mobile-app_a287.html

Questo è il codice completo qui

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

In styles.xml crea un tema personalizzato

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

e infine in AndroidManifest.xml specifica il tema della tua attività

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

Saluti.

Le schermate Splash non devono essere caricate da un file di layout, potrebbe esserci ancora qualche ritardo durante il caricamento.

Il modo migliore è creare un tema solo per SplashScreenActivity e impostarlo the android:windowBackgroundsu una risorsa disegnabile.

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

In breve:

Dichiara SplashScreenActivity nel 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>

Nel tuo SplashScreenActivity.java:

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

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

}

Quindi crea la risorsa per la finestra di sfondo del tuo tema:

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

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

Dopo Android Marshmallow , un altro uso produttivo della schermata iniziale che mi viene in mente è la richiesta necessariaAndroid Permissions nella schermata iniziale della tua app.

sembra che la maggior parte delle app gestisca la richiesta di autorizzazione in questo modo.

• Le finestre di dialogo rendono UIX errato e interrompono il flusso principale e ti fanno decidere sul runtime e la verità è che la maggior parte degli utenti potrebbe non interessarsi nemmeno se la tua app vuole scrivere qualcosa sulla scheda SD. Alcuni di loro potrebbero anche non capire cosa stiamo cercando di trasmettere finché non lo traduciamo in un inglese semplice.

• La richiesta di autorizzazioni in una sola volta rende meno il numero di "if else" prima di ogni operazione e rende il tuo codice privo di ingombri.

Questo è un esempio di come è possibile richiedere autorizzazioni nella propria attività splash per dispositivi con sistema operativo Android 23+.

Se tutte le autorizzazioni sono concesse O già concesse O l'app è in esecuzione su Pre Marshmallow ALLORA basta andare a visualizzare i contenuti principali con un piccolo ritardo di mezzo secondo in modo che l'utente possa apprezzare lo sforzo che abbiamo fatto nel leggere questa domanda e cercando di dare il massimo.

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


}

non utilizzerai un file di layout. Invece, specifica lo sfondo della tua schermata iniziale come sfondo del tema dell'attività. Per fare ciò, creare prima un oggetto XML drawable in res / drawable.

Nota: tutto il codice seguente è disponibile GitHub Link

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">

    <item
        android:drawable="@color/gray"/>

    <item>
        <bitmap
            android:gravity="center"
            android:src="@mipmap/ic_launcher"/>
    </item>

</layer-list>

Qui, ho impostato un colore di sfondo e un'immagine.

Successivamente, imposterai questo come sfondo della tua attività splash nel tema. Passare al file styles.xml e aggiungere un nuovo tema per l'attività splash:

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

Nel tuo nuovo SplashTheme, imposta l'attributo sullo sfondo della finestra sul tuo disegno XML. Configuralo come tema della tua attività splash nel tuo 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>

Infine, la tua classe SplashActivity dovrebbe semplicemente inviarti alla tua attività principale:

public class SplashActivity extends AppCompatActivity {

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

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

Nota che non hai nemmeno impostato una vista per questo SplashActivity. La vista viene dal tema. Quando si configura l'interfaccia utente per l'attività splash nel tema, è immediatamente disponibile.

Se avevi un file di layout per la tua attività splash, quel file di layout sarebbe visibile all'utente solo dopo che l'app è stata inizializzata completamente, che è troppo tardi. Vuoi che lo splash venga visualizzato solo in un breve lasso di tempo prima che l'app venga inizializzata.

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

Crea un'attività, lasciaci Attività denominata 'A', quindi crea un file xml chiamato myscreen.xml, in cui imposta l'immagine della schermata iniziale come sfondo, quindi usa il conto alla rovescia per spostarti da un'Attività all'altra. Per sapere come usare il conto alla rovescia, vedi la mia risposta in questa domanda TimerTask in Android?

Esempio di schermata iniziale:

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

    }

}

La schermata iniziale è un piccolo oggetto inutilizzabile in Android: non può essere caricata il più presto possibile per nascondere il ritardo dell'avvio dell'attività principale. Ci sono due motivi per usarlo: pubblicità e operazioni di rete.

L'implementazione come finestra di dialogo fa saltare senza indugio dalla schermata iniziale all'interfaccia utente principale dell'attività.

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

    }
}

Disposizione:

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

E inizia:

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

    ...
}

Un altro approccio si ottiene utilizzando CountDownTimer

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

Approccio davvero semplice e gr8:

• Innanzitutto crea il tuo splash con il seguente sito Web:

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

  Scegli il tuo logo e slogan, scegli il tuo bellissimo sfondo. ridimensionalo a 4096x4096.

• Ora scarica quella foto e spostala su:

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

  E genera tutte le schermate di avvio necessarie, tutti i dispositivi, tutte le piattaforme.

Godere!

Ci sono abbastanza risposte qui che aiuteranno con l'implementazione. questo post ha lo scopo di aiutare gli altri con il primo passo della creazione della schermata iniziale!

Che ne dite di una schermata di avvio super-flessibile che può utilizzare lo stesso codice ed è definito in AndroidManifest.xml, quindi il codice non dovrà mai cambiare. In genere sviluppo librerie di codice e non mi piace personalizzare il codice perché è sciatto.

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

Quindi SpashActivity cerca i metadati per "launch_class" per creare l'intento stesso. La "durata" dei metadati definisce la durata della schermata iniziale.

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

Qualche utente apre l' SplashActivitye uscire immediatamente, ma l'applicazione ancora andare a MainActivitydopo SPLASH_SCREEN_DISPLAY_LENGTH.

Per prevenirlo: In SplashActivityè necessario verificare la SplashActivityfine o meno prima di passare aMainActivity

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

Spero che questo aiuto

Sebbene ci siano buone risposte, mostrerò il modo consigliato da google:

1) Per prima cosa crea una Themeschermata iniziale: hai un tema chiamato splashscreenTheme, il tuo tema di avvio sarebbe:

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

Nota:

android:windowBackgroundimposta già l'immagine della schermata iniziale senza
dover ripetere l'operazione nell'interfaccia utente.

puoi anche usare il colore qui invece di un disegno.

2) Imposta il tema su manifest di 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) assicurati che launch_screen drawablenon sia nella drawablecartella se l'immagine non è piccola.

Ciò si tradurrà in un avvio più rapido della schermata di avvio e ti salverà dalla schermata nera

Evita anche un sovraccarico aggiuntivo

Questo è il miglior post che ho visto su splash screen: http://saulmm.github.io/avoding-android-cold- startts

Saúl Molinero offre due diverse opzioni per le schermate iniziali: sfruttare lo sfondo della finestra per animare la schermata iniziale e visualizzare l'interfaccia utente segnaposto (che è una scelta popolare che Google utilizza oggi per la maggior parte delle loro app).

Mi riferisco a questo post ogni volta che devo prendere in considerazione l'ora di avvio a freddo ed evitare l'abbandono dell'utente a causa dei lunghi tempi di avvio.

Spero che sia di aiuto!

Nel mio caso non volevo creare una nuova attività solo per mostrare un'immagine per 2 secondi. Quando inizio il mio MainAvtivity, le immagini vengono caricate nei supporti usando Picasso, so che ci vuole circa 1 secondo per caricare, quindi ho deciso di fare quanto segue in MainActivity OnCreate:

splashImage = (ImageView) findViewById(R.id.spllll);

    this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);

    int secondsDelayed = 1;
    new Handler().postDelayed(new Runnable() {
        public void run() {
            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
            splashImage.setVisibility(View.GONE);

        }
    }, secondsDelayed * 2000);

All'avvio dell'applicazione, la prima cosa che succede è che ImageViewviene visualizzato e la barra di stato viene rimossa impostando i flag della finestra a schermo intero. Quindi ho usato a Handlerper correre per 2 secondi, dopo i 2 secondi ho cancellato i flag a schermo intero e ho impostato la visibilità di ImageViewa GONE. Facile, semplice, efficace.

È davvero semplice in Android che usiamo solo il concetto di gestore per implementare la schermata iniziale

Nel tuo file java SplashScreenActivity incolla questo codice.

Nel tuo file xml SplashScreenActivity metti qualsiasi immagine usando imageview.

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

Puoi aggiungerlo nel tuo metodo onCreate

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

E inizializza il valore del tempo in millisecondi come desideri ...

private  static int time=5000;

per maggiori dettagli scarica il codice completo da questo link ...

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

In Kotlin scrivi questo codice: -

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

Spero che questo ti possa aiutare.Grazie ........

Simple Code, funziona :) Semplice splash

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