Comment créer un écran de démarrage?

Je voulais rendre mon application plus professionnelle, j'ai donc décidé de créer un écran de démarrage.

Comment pourrais-je le créer puis le mettre en œuvre?

Lectures complémentaires:

• Heure de lancement de l'application et écrans de lancement thématiques (Android Performance Patterns Season 6 Ep. 4)
• Écran de démarrage dans Android: la bonne façon

Ancienne réponse:

COMMENT : Écran de démarrage simple

Cette réponse vous montre comment afficher un écran de démarrage pendant une durée fixe lorsque votre application démarre, par exemple pour des raisons de marque. Par exemple, vous pouvez choisir d'afficher l'écran de démarrage pendant 3 secondes. Cependant, si vous souhaitez afficher l'écran de démarrage pendant une durée variable (par exemple, le temps de démarrage de l'application), vous devriez vérifier la réponse d'Abdullah https://stackoverflow.com/a/15832037/401025 . Cependant, sachez que le démarrage de l'application peut être très rapide sur les nouveaux appareils, de sorte que l'utilisateur ne verra qu'un flash qui est une mauvaise UX.

Vous devez d'abord définir l'écran de démarrage dans votre layout.xmlfichier

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

Et votre activité:

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

C'est tout ;)

Notez que cette solution ne laissera pas l'utilisateur attendre plus: longtemps le délai de l'écran de démarrage dépend de l'heure de démarrage de l'application.

Lorsque vous ouvrez une application Android, vous obtiendrez par défaut un écran noir avec le titre et l'icône de l'application en haut, vous pouvez changer cela en utilisant un style / thème.

Tout d'abord, créez un style.xml dans le dossier des valeurs et ajoutez-y un style.

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

Au lieu d'utiliser, @android:style/Theme.DeviceDefault.Light.NoActionBarvous pouvez utiliser n'importe quel autre thème en tant que parent.

Deuxièmement, dans votre application Manifest.xml, ajoutez android:theme="@style/splashScreenTheme"à votre activité principale.

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

Troisièmement, mettez à jour votre thème dans votre activité de lancement onCreate ().

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

MISE À JOUR Consultez ce post .

Merci à @ mat1h et @adelriosantiago

• Créer une activité: Splash
• Créez un fichier XML de présentation: splash.xml
• Mettez les composants de l'interface utilisateur dans la disposition splash.xml pour qu'elle ressemble à ce que vous voulez

• votre Splash.java peut ressembler à ceci:

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

• changement ActivityB.classde l' activité selon que vous voulez démarrer après l'écran de démarrage

• vérifiez votre fichier manifeste et il devrait ressembler à

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

Les réponses ci-dessus sont très bonnes, mais je voudrais ajouter autre chose. Je suis nouveau sur Android, j'ai rencontré ces problèmes lors de mon développement. j'espère que cela peut aider quelqu'un comme moi.

1. L'écran Splash est le point d'entrée de mon application, alors ajoutez les lignes suivantes dans 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. L'écran de démarrage ne doit s'afficher qu'une seule fois dans le cycle de vie de l'application, j'utilise une variable booléenne pour enregistrer l'état de l'écran de démarrage et ne l'afficher que la première fois.

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

codage heureux!

La réponse d'Abdullah est excellente. Mais je veux y ajouter plus de détails avec ma réponse.

Implémentation d'un écran de démarrage

Implémenter un écran de démarrage de la bonne façon est un peu différent de ce que vous pourriez imaginer. La vue de démarrage que vous voyez doit être prête immédiatement, avant même de pouvoir gonfler un fichier de mise en page dans votre activité de démarrage.

Vous n'utiliserez donc pas de fichier de mise en page. À la place, spécifiez l'arrière-plan de votre écran de démarrage comme arrière-plan du thème de l'activité. Pour ce faire, créez d'abord un XML dessinable dans 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>

C'est juste une liste de calques avec un logo au centre de la couleur d'arrière-plan.

Ouvrez maintenant styles.xml et ajoutez ce style

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

Ce thème devra avoir une barre d'action et un fond que nous venons de créer ci-dessus.

Et dans le manifeste, vous devez définir SplashTheme sur l'activité que vous souhaitez utiliser comme 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>

Ensuite, à l'intérieur de votre code d'activité, naviguez l'utilisateur vers l'écran spécifique après le splash en utilisant l'intention.

public class SplashActivity extends AppCompatActivity {

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

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

C'est la bonne façon de procéder. J'ai utilisé ces références pour réponse.

1. https://material.google.com/patterns/launch-screens.html
2. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ Merci à ces gars de m'avoir poussé dans la bonne direction. Je veux aider les autres car la réponse acceptée n'est pas recommandée pour faire un écran de démarrage.

1. Créé 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 sera comme ça

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

Un Splash Screnn, par défaut, ne rend pas automatiquement votre application plus professionnelle. Un écran de démarrage conçu par des professionnels a la possibilité de donner à votre application un aspect plus professionnel, mais si vous ne savez pas comment en rédiger un, alors quel sera le professionnalisme du reste de votre application.

La seule raison (excuse) d'avoir un écran de démarrage est que vous effectuez une énorme quantité de calculs ou attendez le démarrage du GPS / WiFi parce que votre application s'appuie sur cela avant de démarrer. Sans le résultat de ces calculs ou l'accès au GPS / WiFi (etc.), votre application est morte dans l'eau, vous sentez donc que vous avez besoin d'un écran de démarrage et que vous DEVEZ bloquer la vue de l'écran pour tout autre programme en cours d'exécution (y compris l'arrière-plan ).

Un tel écran de démarrage devrait ressembler à votre application plein écran pour donner l'impression qu'il a déjà été initialisé, puis une fois les longs calculs terminés, les détails finaux pourraient être remplis (l'image modifiée). La probabilité que cela soit le cas ou que ce soit la seule façon de concevoir le programme est très faible .

Il serait préférable de permettre à l'utilisateur (et au reste du système d'exploitation) de faire autre chose pendant qu'il attend plutôt que de concevoir votre programme comme dépendant de quelque chose qui prendra un certain temps (lorsque la durée de l'attente est incertaine).

Il y a déjà des icônes sur votre téléphone qui indiquent que le GPS / WiFi démarre. Le temps ou l'espace occupé par l'écran de démarrage peut être consacré au chargement des pré-calculs ou à la réalisation des calculs. Voir le premier lien ci-dessous pour les problèmes que vous créez et ce qui doit être pris en compte.

Si vous devez absolument attendre ces calculs ou GPS / WiFi, il serait préférable de simplement laisser l'application démarrer et d'avoir une fenêtre contextuelle qui indique qu'il est nécessaire d'attendre les calculs (un message TEXTUEL "Initialisation" est très bien). L'attente du GPS / WiFi est attendue (s'ils n'étaient pas déjà activés dans un autre programme), il n'est donc pas nécessaire d'annoncer leurs temps d'attente.

Rappelez-vous que lorsque l'écran de démarrage démarre, votre programme est déjà en cours d'exécution, tout ce que vous faites est de retarder l'utilisation de votre programme et de monopoliser le CPU / GPU pour faire quelque chose que la plupart ne jugent pas nécessaire.

Nous ferions mieux de vraiment vouloir attendre et voir votre écran de démarrage à chaque fois que nous démarrons votre programme ou NOUS ne sentirons pas qu'il est écrit de manière très professionnelle. Rendre l'écran de démarrage plein écran et un double de l'écran du programme réel (nous pensons donc qu'il est initialisé alors qu'en fait il ne l'a pas fait) POURRAIT atteindre votre objectif (rendre votre programme plus professionnel), mais je ne parierais pas grand-chose à ce sujet.

Pourquoi ne pas le faire: http://cyrilmottier.com/2012/05/03/splash-screens-are-evil-dont-use-them/

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

Il y a donc une bonne raison de ne pas le faire, mais SI vous êtes certain que votre situation est en dehors de ces exemples, les moyens de le faire sont donnés ci-dessus. Assurez-vous que cela donne vraiment à votre application un aspect plus professionnel ou que vous avez vaincu la seule raison que vous avez donnée pour cela.

C'est comme une chaîne YouTube qui démarre chaque vidéo avec une longue introduction graphique (et outro) ou ressent le besoin de raconter une blague ou d'expliquer ce qui s'est passé au cours de la semaine dernière (quand ce n'est pas une chaîne comique ou LifeStyles). Montrez juste le spectacle! (Exécutez simplement le programme).

Surtout, les réponses sont vraiment très bonnes. Mais il y a un problème de fuite de mémoire. Ce problème est souvent connu dans la communauté Android sous le nom de «fuite d'une activité» . Maintenant, qu'est-ce que cela signifie exactement?

Lorsqu'un changement de configuration se produit, tel qu'un changement d'orientation, Android détruit l'activité et la recrée. Normalement, le garbage collector effacera simplement la mémoire allouée de l'ancienne instance d'activité et nous allons tous bien.

"Fuite d'une activité" fait référence à la situation où le garbage collector ne peut pas effacer la mémoire allouée de l'ancienne instance d'activité car elle being (strong) referencedprovient d'un objet qui a vécu l'instance d'activité. Chaque application Android dispose d'une quantité spécifique de mémoire allouée. Lorsque Garbage Collector ne peut pas libérer de mémoire inutilisée, les performances de l'application diminuent progressivement et finissent par se bloquer avec une OutOfMemoryerreur.

Comment déterminer si l'application perd de la mémoire ou non? Le moyen le plus rapide consiste à ouvrir l'onglet Mémoire dans Android Studio et à faire attention à la mémoire allouée lorsque vous modifiez l'orientation. Si la mémoire allouée continue d'augmenter et ne diminue jamais, vous avez une fuite de mémoire.

1. fuite de mémoire lorsque l'utilisateur change d'orientation.

Vous devez d'abord définir l'écran de démarrage dans votre splashscreen.xmlfichier de ressources de mise en page

Exemple de code pour l'activité de l'écran de démarrage.

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

Pour plus d'informations, veuillez consulter ce lien

L'arrêt sur l'écran Splash pendant 4's 5 n'a pas de sens. C'est OK si vous chargez quelque chose en arrière-plan, suivez cette approche pour implémenter un écran de démarrage: - L' implémentation d'un écran de démarrage de la bonne façon est un peu différente de ce que vous pourriez imaginer. La vue de démarrage que vous voyez doit être prête immédiatement, avant même de pouvoir gonfler un fichier de mise en page dans votre activité de démarrage.

Vous n'utiliserez donc pas de fichier de mise en page. À la place, spécifiez l'arrière-plan de votre écran de démarrage comme arrière-plan du thème de l'activité. Pour ce faire, commencez par créer un XML dessinable dans 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>

Ici, j'ai mis en place une couleur de fond et une image.

Ensuite, vous définirez cela comme arrière-plan de votre activité de démarrage dans le thème. Accédez à votre fichier styles.xml et ajoutez un nouveau thème pour votre activité de démarrage:

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

Dans votre nouveau SplashTheme, définissez l'attribut d'arrière-plan de la fenêtre sur votre dessin XML. Configurez-le comme thème de votre activité de démarrage dans votre 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>

Enfin, la classe SplashActivity devrait simplement vous transmettre votre activité 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();
    }
}

Plus de détails lisent ceci: 1. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ 2. http://blog.goodbarber.com/3-tips-to-create-a -grand-splash-screen-for-your-mobile-app_a287.html

Voici le code complet ici

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

Dans les drawables, créez ce 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>

Dans styles.xml, créez un thème personnalisé

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

et enfin dans AndroidManifest.xml spécifiez le thème de votre activité

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

À votre santé.

Les écrans de démarrage ne doivent pas être chargés à partir d'un fichier de mise en page, il peut toujours y avoir un certain retard lors du chargement.

La meilleure façon est de créer un thème juste pour votre SplashScreenActivity et de le définir the android:windowBackgroundsur une ressource dessinable.

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

En un mot:

Déclarez votre SplashScreenActivity dans le manifeste:

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

Dans votre SplashScreenActivity.java:

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

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

}

Créez ensuite la ressource pour la fenêtre d'arrière-plan de votre thème:

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

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

Après Android Marshmallow , une autre utilisation productive de l'écran de démarrage auquel je pense est la demande nécessaireAndroid Permissions dans l'écran de démarrage de votre application.

il semble que la plupart des applications gèrent la demande d'autorisation de cette façon.

• Les boîtes de dialogue font du mauvais UIX et elles cassent le flux principal et vous font décider du temps d'exécution et la vérité est que la plupart des utilisateurs ne se soucient même pas si votre application veut écrire quelque chose sur la carte SD. Certains d'entre eux pourraient même ne pas comprendre ce que nous essayons de transmettre jusqu'à ce que nous le traduisions en anglais simple.

• Demander des autorisations en même temps réduit le nombre de «sinon» avant chaque opération et rend votre code sans encombrement.

Ceci est un exemple de la façon dont vous pouvez demander des autorisations dans votre activité de démarrage pour un appareil exécutant Android OS 23+.

Si toutes les autorisations sont accordées OU déjà accordées, OU l'application est en cours d'exécution sur Pre Marshmallow ALORS, allez simplement afficher le contenu principal avec un petit délai d'une demi-seconde afin que l'utilisateur puisse apprécier les efforts que nous avons déployés pour lire cette question et essayer de faire de notre mieux.

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


}

vous n'utiliserez pas de fichier de mise en page. À la place, spécifiez l'arrière-plan de votre écran de démarrage comme arrière-plan du thème de l'activité. Pour ce faire, créez d'abord un XML dessinable dans res / drawable.

Remarque: tout le code ci-dessous est disponible 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>

Ici, j'ai mis en place une couleur de fond et une image.

Ensuite, vous définirez cela comme arrière-plan de votre activité de démarrage dans le thème. Accédez à votre fichier styles.xml et ajoutez un nouveau thème pour votre activité de démarrage:

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

Dans votre nouveau SplashTheme, définissez l'attribut d'arrière-plan de la fenêtre sur votre dessin XML. Configurez-le comme thème de votre activité de démarrage dans votre 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>

Enfin, votre classe SplashActivity devrait simplement vous faire suivre votre activité 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();
    }
}

Notez que vous n'avez même pas configuré de vue pour cette SplashActivity. La vue vient du thème. Lorsque vous configurez l'interface utilisateur pour votre activité de démarrage dans le thème, elle est disponible immédiatement.

Si vous disposiez d'un fichier de mise en page pour votre activité de démarrage, ce fichier de mise en page ne serait visible pour l'utilisateur qu'après l'initialisation complète de votre application, ce qui est trop tard. Vous souhaitez que le splash ne s'affiche que dans ce court laps de temps avant l'initialisation de l'application.

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

Créez une activité, laissez-nous une activité nommée `` A '', puis créez un fichier xml appelé myscreen.xml, dans lequel définissez l'image de l'écran de démarrage comme arrière-plan, puis utilisez le compte à rebours pour naviguer d'une activité à l'autre. Pour savoir comment utiliser le compte à rebours, voir ma réponse dans cette question TimerTask dans Android?

Exemple d'écran de démarrage:

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

    }

}

L'écran de démarrage est un petit objet inutilisable sous Android: il ne peut pas être chargé le plus tôt possible pour masquer le retard de démarrage de l'activité principale. Il y a deux raisons de l'utiliser: la publicité et les opérations de réseau.

La mise en œuvre sous forme de dialogue permet de passer sans délai de l'écran de démarrage à l'interface utilisateur principale de l'activité.

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

    }
}

Disposition:

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

Et commencez:

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

    ...
}

Une autre approche est obtenue en utilisant 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>

Approche vraiment facile et gr8:

• Créez d'abord votre splash avec le site Web suivant:

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

  Choisissez votre logo et slogan, choisissez votre beau fond. redimensionnez-le à 4096x4096.

• Téléchargez maintenant cette image et mettez-la à jour:

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

  Et générez tous les écrans de démarrage nécessaires, tous les appareils, toutes les plateformes.

Prendre plaisir!

Il y a suffisamment de réponses ici qui aideront à la mise en œuvre. ce message était destiné à aider les autres dans la première étape de la création de l'écran de démarrage!

Que diriez-vous d'un écran de lancement super flexible qui peut utiliser le même code et est défini dans AndroidManifest.xml, de sorte que le code n'aura jamais besoin de changer. Je développe généralement des bibliothèques de code et je n'aime pas personnaliser le code car il est bâclé.

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

Ensuite, la SpashActivity elle-même recherche les métadonnées de "launch_class" pour ensuite définir l'intention elle-même. La "durée" des métadonnées définit la durée pendant laquelle l'écran de démarrage reste affiché.

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

Parfois, l'utilisateur ouvre SplashActivityet quitte immédiatement, mais l'application continue de fonctionner MainActivityaprès SPLASH_SCREEN_DISPLAY_LENGTH.

Pour l'empêcher: SplashActivityvous devez vérifier la SplashActivityfin ou non avant de passer àMainActivity

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

J'espère que cette aide

Bien qu'il existe de bonnes réponses, je vais montrer la méthode recommandée par Google:

1) Créez d'abord un Themeécran de démarrage: vous avez un thème appelé splashscreenTheme, votre thème de lancement serait:

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

Remarque:

android:windowBackgrounddéfinit déjà votre image d'écran de démarrage pas
besoin de le faire à nouveau dans l'interface utilisateur.

vous pouvez également utiliser la couleur ici au lieu d'un dessinable.

2) Définissez le thème pour qu'il se manifeste sur 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) assurez-vous que launch_screen drawablen'est pas dans le drawabledossier si votre image n'est pas petite.

Cela entraînera un démarrage de l'écran de lancement plus rapide et vous sauvera de l'écran noir

Il évite également un surplus supplémentaire

C'est le meilleur article que j'ai vu sur les écrans de démarrage: http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero propose deux options différentes pour les écrans de démarrage: profiter de l'arrière-plan de la fenêtre pour s'animer dans votre écran initial et afficher l'interface utilisateur d'espace réservé (qui est un choix populaire que Google utilise pour la plupart de leurs applications de nos jours).

Je me réfère à ce post chaque fois que je dois prendre en compte l'heure de démarrage à froid et éviter le décrochage de l'utilisateur en raison des longs délais de démarrage.

J'espère que cela t'aides!

Dans mon cas, je ne voulais pas créer une nouvelle activité uniquement pour afficher une image pendant 2 secondes. Au démarrage de mon MainAvtivity, les images sont chargées dans les supports à l'aide de picasso, je sais que cela prend environ 1 seconde à charger, j'ai donc décidé de faire ce qui suit dans mon 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);

Lors du démarrage de l'application, la première chose qui se produit est le ImageViews'affiche et la barre d'état est supprimée en définissant les indicateurs de fenêtre en plein écran. Ensuite , j'ai utilisé Handlerpour exécuter pendant 2 secondes, après les 2 secondes j'effacer les drapeaux en plein écran et définir la visibilité du ImageViewà GONE. Facile, simple, efficace.

C'est vraiment simple dans Android, nous utilisons simplement le concept de gestionnaire pour implémenter l'écran de démarrage

Dans votre fichier java SplashScreenActivity, collez ce code.

Dans votre fichier xml SplashScreenActivity, mettez n'importe quelle image en utilisant 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);
    }

Vous pouvez l'ajouter dans votre méthode 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);

Et initialisez votre valeur de temps en millisecondes comme vous le souhaitez ...

private  static int time=5000;

pour plus de détails, téléchargez le code complet à partir de ce lien ...

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

Dans Kotlin, écrivez ce code: -

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

J'espère que cela vous aidera.Merci ........

Code simple, ça marche :) Splash simple

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