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

Je voulais que mon application soit plus professionnelle, alors j’ai décidé de créer un écran de démarrage.

Comment pourrais-je le créer et l’implémenter ensuite?

Lectures complémentaires:

  • Heure de lancement de l’application et écrans de lancement à thème (Android Performance Patterns Saison 6 Ep. 4)
  • Écran de démarrage dans Android: la bonne façon

Vieille réponse:

COMMENT FAIRE : Simple écran de démarrage

Cette réponse vous montre comment afficher un écran de démarrage pendant une durée déterminée 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, l’heure de démarrage de l’application), vous devriez consulter 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 verra simplement un flash UX défectueux.

Vous devez d’abord définir l’écran de spash dans votre fichier layout.xml

       

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 permettra pas à l’utilisateur d’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 sur le dessus, vous pouvez changer cela en utilisant un style / thème.

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

  

Au lieu d’utiliser @android:style/Theme.DeviceDefault.Light.NoActionBar vous 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.

  

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 cet article https://plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd Merci à @ mat1h et @adelriosantiago

  • Créer une activité: Splash
  • Créer un fichier XML de mise en page: splash.xml
  • Placez les composants de l’interface utilisateur dans la mise en page splash.xml pour qu’elle ressemble
  • 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); } } 
  • changez ActivityB.class selon l’activité que vous voulez démarrer après l’écran de démarrage

  • vérifiez votre fichier manifeste et il devrait ressembler

          

La réponse de @Abdullah est correcte, mais Google a publié une explication détaillée sur la manière de l’implémenter correctement sans modifier le thème de votre activité:

https://plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd

Des applications comme Google Maps et YouTube ont commencé à utiliser la même méthode.

Les réponses ci-dessus sont très bonnes, mais j’aimerais append quelque 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 de démarrage est le point d’entrée de mon application, ajoutez donc les lignes suivantes dans AndroidManifest.xml.

            
  2. L’écran de démarrage ne doit apparaître qu’une 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’affiche 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!

  1. Créer une 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

        

Un Splash Screnn, par défaut, ne rend pas automatiquement votre application plus professionnelle. Un Splash Screen conçu par des professionnels a la possibilité de rendre votre application plus professionnelle, mais si vous ne savez pas comment en écrire une, quel sera le niveau professionnel de votre application.

La seule raison (excuse) d’avoir un écran de démarrage est que vous effectuez une quantité considérable de calculs ou que vous attendez le démarrage du GPS / WiFi, car votre application en dépend avant le démarrage. Sans le résultat de ces calculs ou l’access au GPS / WiFi (etc.), votre application est morte dans l’eau, vous avez donc besoin d’un écran de démarrage et DOIT bloquer la vue de l’écran pour tout autre programme en cours d’exécution (arrière-plan compris). ).

Un tel écran d’accueil doit ressembler à votre application plein écran pour donner l’impression qu’il a déjà été initialisé, puis après les longs calculs, les derniers détails peuvent être complétés (l’image modifiée). La probabilité que cela soit le cas ou que ce soit la seule façon de concevoir le programme est extrêmement faible .

Il serait préférable d’autoriser l’utilisateur (et le rest du système d’exploitation) à faire autre chose en attendant, plutôt que de concevoir que votre programme dépende de quelque chose qui prendra un certain temps (lorsque la durée de l’attente est incertaine).

Il y a déjà des icons 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 utilisé pour charger des pré-calculs ou pour effectuer les calculs. Voir le premier lien ci-dessous pour les problèmes que vous créez et ce qui doit être considéré.

Si vous devez absolument attendre ces calculs ou GPS / WiFi, il serait préférable de laisser l’application démarrer et d’avoir une fenêtre contextuelle indiquant qu’il est nécessaire d’attendre les calculs (un message TEXTUAL “Initializing” est correct). L’attente du GPS / WiFi est attendue (si elles n’étaient pas déjà activées dans un autre programme), il est donc inutile d’annoncer leurs temps d’attente.

Rappelez-vous que lorsque le Splash Screen 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 forcer le CPU / GPU à faire quelque chose que la plupart ne jugent pas nécessaire.

Nous ferions mieux d’attendre et de voir votre écran de démarrage chaque fois que nous lancerons votre programme ou nous n’aurons pas l’impression que ce sera écrit de manière très professionnelle. Rendre l’écran Splash FULL (écran) et une copie de l’écran du programme (nous pensons qu’il est initialisé alors que ce n’est pas le cas) POURRAIT atteindre votre objective (rendre votre programme plus professionnel) mais je ne parierais pas beaucoup là-dessus.

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

Comment le 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 ne correspond pas à ces exemples, les moyens de le faire sont indiqués ci-dessus. Assurez-vous que votre application semble vraiment plus professionnelle ou que vous avez battu la seule raison pour laquelle vous l’avez fait.

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é la semaine dernière (quand il ne s’agit pas d’une chaîne Comedy ou LifeStyles). Juste montrer le spectacle! (Il suffit de lancer le programme).

Surtout, les réponses sont vraiment très bonnes. Mais il existe des problèmes de fuite de mémoire. Ce problème est souvent appelé dans la communauté Android “Fuite d’une activité” . Maintenant, qu’est-ce que cela signifie exactement?

Lorsqu’une modification de configuration se produit, telle qu’un changement d’orientation, Android détruit l’activité et la recrée. Normalement, le ramasse-miettes efface simplement la mémoire allouée de l’ancienne instance Activity et nous sums tous bons.

“Fuite d’une activité” fait référence au cas où le récupérateur de place ne peut pas effacer la mémoire allouée de l’ancienne instance d’Activité car elle being (strong) referenced partir d’un object qui a vécu l’instance d’Activité. Chaque application Android dispose d’une quantité de mémoire spécifique. Lorsque Garbage Collector ne peut pas libérer de la mémoire inutilisée, les performances de l’application diminuent progressivement et finissent par OutOfMemory panne avec l’erreur OutOfMemory .

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 à augmenter et ne diminue jamais, vous avez une fuite de mémoire.

1. fuite de mémoire lorsque l’utilisateur modifie l’orientation. entrer la description de l'image ici

Vous devez d’abord définir l’écran de démarrage dans votre fichier splashscreen.xml ressource 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 s’il vous plaît passer par ce lien

La réponse d’Abdullah est géniale. Mais je veux append quelques détails avec ma réponse.

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

Implémenter un écran de démarrage de la bonne manière 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. Au lieu de cela, 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 fichier XML dessinable dans res / drawable.

background_splash.xml

        

Il ne s’agit que d’une liste de calques avec le logo au centre de la couleur d’arrière-plan.

Ouvrez maintenant styles.xml et ajoutez ce style

  

Ce thème devra agirbar et avec le 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.

      

Ensuite, à l’intérieur de votre code d’activité, dirigez l’utilisateur vers l’écran spécifique après l’éclaboussure 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 faire. J’ai utilisé ces références pour répondre.

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

Ceci est 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 drawables créez ce bg_splash.xml

      

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

  

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

       

À votre santé.

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

Le meilleur moyen est de créer un thème uniquement pour votre SplashScreenActivity et de définir the android:windowBackground sur une ressource pouvant être dessinée.

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

En un mot:

Déclarez votre SplashScreenActivity dans le manifeste:

       

Dans votre SplashScreenActivity.java:

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

Ensuite, créez la ressource pour la fenêtre d’arrière-plan de votre thème:

  

Fichier dessinable splash.xml:

        

Après Android Marshmallow , une autre utilisation productive de l’écran Splash auquel je pense est de demander Android Permissions nécessaires sur l’écran de démarrage de votre application.

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

  • Les dialogs font un mauvais usage d’UIX et ils brisent le stream principal et vous font décider de l’exécution et de la vérité. La plupart des utilisateurs pourraient même ne pas vouloir que votre application veuille é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.

  • Demander des permissions à un moment donné réduit le nombre de “sinon” avant chaque opération et rend votre code moins encombré.

Voici un exemple de la façon dont vous pouvez demander des permissions dans votre activité Splash pour un périphérique exécutant Android OS 23+.

Si toutes les permissions sont accordées OU si elles ont déjà été accordées OU si l’application est en cours sur Pre Marshmallow, ALORS, il suffit d’afficher le contenu principal avec un peu de retard d’une demi-seconde pour que l’utilisateur puisse lire la question et essayer de donner le meilleur.

 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.Animasortingx; 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 Animasortingx.scale(findViewById(R.id.title_play), 100); Animasortingx.scale(findViewById(R.id.title_edit), 100); Animasortingx.scale(findViewById(R.id.title_record), 100); Animasortingx.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, Ssortingng[] permissions, int[] grantResults) { switch (requestCode) { case REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS: { Map perms = new HashMap(); // 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 permissionsNeeded = new ArrayList(); final List permissionsList = new ArrayList(); 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 Ssortingng 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 permissionsList, Ssortingng 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); } } 
 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(); } 

vous n’utiliserez pas de fichier de mise en page. Au lieu de cela, 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 fichier XML dessinable dans res / drawable.

Note: tout le code ci-dessous est disponible GitHub Link

        

Ici, j’ai créé une couleur de fond et une image.

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

      

Dans votre nouveau SplashTheme, définissez l’atsortingbut d’arrière-plan de la fenêtre sur votre fichier XML. Configurez ceci comme thème de votre activité de démarrage dans votre fichier AndroidManifest.xml:

       

Enfin, votre classe SplashActivity devrait 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 aviez un fichier de disposition pour votre activité de démarrage, ce fichier de mise en page serait visible à l’utilisateur uniquement après l’initialisation complète de votre application, ce qui est trop tard. Vous souhaitez que le splash ne s’affiche que dans un laps de temps réduit avant l’initialisation de l’application.

Créez une activité, laissez-nous vous nommer Activité ‘A’, puis créez un fichier XML appelé myscreen.xml, dans lequel vous définissez l’image de démarrage comme arrière-plan, puis utilisez le compte à rebours pour naviguer d’une activité à une autre. Pour savoir comment utiliser Count Down timer, voir ma réponse dans cette question TimerTask dans Android?

Exemple d’écran Splash:

 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 object peu utilisable sous Android: il ne peut pas être chargé le plus rapidement possible pour cacher le retard de l’activité principale. Il y a deux raisons de l’utiliser: la publicité et les opérations réseau.

L’implémentation en tant que boîte de dialog 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:

     

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

L’arrêt sur l’écran du Splash pendant 4 à 5 secondes n’a pas beaucoup de sens. Si vous chargez quelque chose en arrière-plan, suivez cette approche pour implémenter l’écran de démarrage: – L’ implémentation d’un écran de démarrage de la bonne manière 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. Au lieu de cela, 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 dessin XML en res / drawable.

        

Ici, j’ai créé une couleur de fond et une image.

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

      

Dans votre nouveau SplashTheme, définissez l’atsortingbut d’arrière-plan de la fenêtre sur votre fichier XML. Configurez ceci comme thème de votre activité de démarrage dans votre fichier AndroidManifest.xml:

       

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

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

Que diriez-vous d’un écran de lancement super flexible qui peut utiliser le même code et est défini dans le fichier 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 n’aime pas la personnalisation du code car il est négligé.

         

Ensuite, SpashActivity lui-même consulte les métadonnées de la classe “launch_class” pour créer l’intention elle-même. La «durée» des métadonnées définit la durée pendant laquelle l’écran de démarrage rest en place.

 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; Ssortingng launch_class = bundle.getSsortingng("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(); } } } 

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

Parfois, l’utilisateur ouvre SplashActivity et quitte immédiatement, mais l’application continue à MainActivity après SPLASH_SCREEN_DISPLAY_LENGTH .

Pour éviter cela: Dans SplashActivity vous devez vérifier que SplashActivity est en SplashActivity se terminer 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 y ait de bonnes réponses, je montrerai la manière recommandée par Google:

1) Commencez par créer un Theme pour l’écran d’accueil: vous avez un thème appelé splashscreenTheme , le thème de votre lanceur serait:

  

Remarque:

android:windowBackground définit déjà votre image splashscreen no
besoin de le faire à nouveau dans l’interface utilisateur.

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

2) Définir le thème à manifester de splashscreenActivity

        

3)make sure you launch_screen drawable is not in drawable folder if your image is not small.

It will result in faster launch screen start and save you from the black screen

It also avoids extra overdraw

This is the best post I’ve seen on splash screens: http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero goes into two different options for splash screens: Taking advantage of the window background to animate into your initial screen and displaying placeholder UI (which is a popular choice that Google uses for most of their apps these days).

I refer to this post every time I need to consider cold start time and avoiding user dropoff due to long startup times.

J’espère que cela t’aides!

  - 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     - Add in AndroidManifest.xml       

Simple Code, it works:) Simple 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(); } } 

In my case I didn’t want to create a new Activity only to show a image for 2 seconds. When starting my MainAvtivity , images gets loaded into holders using picasso, I know that this takes about 1 second to load so I decided to do the following inside my 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); 

When starting the application the first thing that happens is the ImageView gets displayed and the statusBar is removed by setting the window flags to full screen. Then I used a Handler to run for 2 seconds, after the 2 seconds I clear the full screen flags and set the visibility of the ImageView to GONE . Easy, simple, effective.

I used threads to make the Flash Screen in android.

  import android.content.Intent; import android.os.Bundle; import android.support.annotation.Nullable; import android.support.v7.app.AppCompatActivity; public class HomeScreen extends AppCompatActivity{ @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.screen_home); Thread thread = new Thread(){ public void run(){ try { Thread.sleep(3 * 1000); Intent i = new Intent(HomeScreen.this, MainActivity.class); startActivity(i); } catch (InterruptedException e) { } } }; thread.start(); } } 

Its really simple in android we just use handler concept to implement the splash screen

In your SplashScreenActivity java file paste this code.

In your SplashScreenActivity xml file put any picture using 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); } 

Really easy & gr8 approach :

Prendre plaisir!

There are enough answers here that will help with the implementation. this post was meant to help others with the first step of creating the splash screen!