Comment créer un écran de démarrage?
Je voulais donner à mon application une apparence plus professionnelle. J'ai donc décidé de créer un écran de démarrage.
Comment pourrais-je le créer et ensuite le mettre en œuvre?
Lectures complémentaires:
- Heure de lancement de l'application et écrans de lancement par thème (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 un laps de temps fixe au démarrage de votre application, par exemple. raisons de marque. Par exemple. vous pouvez choisir d'afficher l'écran de démarrage pendant 3 secondes. Toutefois, 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 devez vérifier la réponse/Abdullah https://stackoverflow.com/a/15832037/401025 . Toutefois, 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 fichier layout.xml
<?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 obtenez par défaut un écran noir avec le titre et l'icône de l'application en haut, vous pouvez le modifier en utilisant un style/thème.
Commencez par créer un dossier style.xml dans le dossier de 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.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.
<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);
}
UPDATE Découvrez ce message https://plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd Merci à @ mat1h et @adelriosantiago
- Créer une activité: Splash
- Créez un fichier XML de présentation: splash.xml
- Placez les composants de l'interface utilisateur dans la présentation splash.xml afin qu'elle soit comme vous le souhaitez
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); } }remplacez
ActivityB.classpar l’activité que vous souhaitez démarrer après l’écran de démarragevé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>
La réponse de @ Abdullah est correcte, mais Google a publié une explication détaillée sur la manière de la mettre en œuvre correctement sans modifier le thème de votre activité:
https://plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd
Des applications telles que Google Maps et YouTube ont commencé à utiliser la même méthode.
Les réponses ci-dessus sont très bonnes, mais je voudrais ajouter autre chose. Je suis nouveau sur Android, j'ai rencontré ce problème au cours de mon développement. J'espère que cela peut aider quelqu'un comme moi.
L'écran de démarrage est le point d'entrée de mon application. Ajoutez donc 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>L'écran de démarrage ne doit apparaître 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'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(); } } }
bonne codage!
Créer un
ActivitySplashScreen.Javapublic 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(); } }splashscreen.xmlsera 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 donne pas automatiquement à votre application un aspect plus professionnel. Un écran de démarrage conçu par un professionnel a la possibilité de donner à votre application un aspect plus professionnel, mais si vous ne savez pas comment en écrire un, le degré de professionnalisme du reste de votre application sera-t-il professionnel?.
La seule raison (excuse) d'avoir un écran de démarrage est que vous effectuez beaucoup de calculs ou que vous attendez le démarrage du GPS/WiFi, car votre application en dépend avant son démarrage. Sans le résultat de ces calculs ou de l'accès au GPS/WiFi (etc.), votre application est immergée. Vous avez donc besoin d'un écran de démarrage et vous DEVEZ bloquer l'affichage de l'écran pour tous les autres programmes en cours d'exécution (y compris le programme en arrière-plan). ).
Un tel écran de démarrage doit ressembler à votre application plein écran pour donner l’impression qu’il a déjà été initialisé. Ensuite, une fois les calculs longs terminés, les détails définitifs peuvent être complétés (l’image peaufinée). La chance selon laquelle c'est le cas ou la seule façon dont le programme peut être conçu est extrêmement petite.
Il serait préférable de permettre à l'utilisateur (et au reste du système d'exploitation) de faire autre chose pendant qu'ils attendent plutôt que de concevoir votre programme pour qu'il soit dépendant de quelque chose qui prendra un certain temps (lorsque la durée de l'attente est incertaine).
Votre téléphone contient déjà des icônes indiquant que le GPS/WiFi démarre. Le temps ou l’espace occupé par l’écran de démarrage peut être passé à charger des pré-calculs ou à 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 est préférable de laisser simplement l'application démarrer et d'afficher une fenêtre contextuelle indiquant qu'il est nécessaire d'attendre les calculs (un message TEXTUEL «Initialisation» convient parfaitement). L'attente pour 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.
N'oubliez pas que lorsque l'écran de démarrage démarre votre programme IS en cours d'exécution, vous ne faites que retarder l'utilisation de votre programme et monopoliser le processeur/le processeur graphique pour qu'il fasse quelque chose que la plupart des utilisateurs ne jugent pas nécessaire.
Nous ferions mieux d'attendre et de voir votre écran de démarrage chaque fois que nous démarrons votre programme, sinon WE n'aura pas l'impression qu'il est rédigé de manière très professionnelle. Rendre l’écran COMPLET d’écran de démarrage et une copie de l’écran du programme actuel (nous pensons donc qu’il est initialisé alors que ce n’est pas le cas) POURRAIT atteindre votre objectif (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 a réellement un aspect plus professionnel ou vous avez vaincu la seule raison pour laquelle vous avez expliqué cela.
C'est comme une chaîne YouTube qui commence chaque vidéo avec une longue introduction graphique (ou Outro) ou ressent le besoin de raconter une blague ou d'expliquer ce qui s'est passé la semaine dernière (lorsqu'il ne s'agit pas d'une chaîne Comedy ou LifeStyles). Il suffit de montrer le spectacle! (Il suffit de lancer le programme).
Surtout, les réponses sont vraiment très bonnes. Mais il existe un problème de fuite de mémoire . Ce problème est souvent connu dans la communauté Android sous le nom de "Leaking an Activity". 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 le recrée. Normalement, le ramasse-miettes efface la mémoire allouée de l'ancienne instance d'Activity et tout va bien.
"Fuite d'une activité" fait référence à la situation dans laquelle le récupérateur de place ne peut pas effacer la mémoire allouée de l'ancienne instance d'activité puisqu'il s'agit de being (strong) referenced d'un objet ayant vécu l'instance d'activité. Chaque application Android possède une quantité spécifique de mémoire allouée. Lorsque Garbage Collector ne peut pas libérer de la mémoire inutilisée, les performances de l'application diminuent progressivement et finissent par planter avec l'erreur OutOfMemory.
Comment déterminer si l'application perd de la mémoire ou pas? 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 risquez une fuite de mémoire.
1.Fuite de mémoire lorsque l'utilisateur modifie l'orientation . 
Vous devez d’abord définir l’écran de démarrage dans votre fichier splashscreen.xml de ressource de présentation
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, merci de passer par ce link
La réponse d'Abdullah est excellente. Mais je veux ajouter quelques détails supplémentaires avec ma réponse.
Implémentation d'un écran de démarrage
L'implémentation correcte d'un écran de démarrage 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 que vous puissiez gonfler un fichier de présentation dans votre activité de démarrage.
Donc, vous n'utiliserez pas de fichier de mise en page. Spécifiez plutôt 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 fichier XML pouvant être dessiné 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 couches avec un logo avec la couleur de fond du centre.
Maintenant, ouvrez 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 être actionbar et avec le fond que nous venons de créer ci-dessus.
Et dans manifest, vous devez définir SplashTheme sur l'activité que vous souhaitez utiliser en tant que 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, dans votre code d'activité, naviguez l'utilisateur vers l'écran spécifique après le splash à l'aide de 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.
- https://material.google.com/patterns/launch-screens.html
- https://www.bignerdranch.com/blog/splash-screens-the-right-way/ Merci à ces gars-là 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 les écrans de démarrage.
C'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 ceci 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éer 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é.
Après Android Marshmallow , autre utilisation productive de l’écran de démarrage auquel je viens de penser, c’est demandant le Android Permissionsnécessaire dans l’écran de démarrage de votre application.
il semble que la plupart des applications traitent les demandes d'autorisation de cette façon.
Les dialogues sont de mauvais UIX et ils interrompent le flux principal et vous incitent à choisir le runtime. En réalité, la plupart des utilisateurs ne se soucient peut-être même pas de savoir si votre application souhaite é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 à la fois génère moins de "if else" avant chaque opération et donne à votre code une apparence sans encombrement.
Voici un exemple de la façon dont vous pouvez demander des autorisations dans votre activité Splash pour un appareil sous Android OS 23+.
Si toutes les autorisations sont accordées OR déjà accordées OR l'application est en cours d'exécution sur Pre Marshmallow THEN, allez simplement et affichez le contenu principal avec un délai très court d'une demi seconde pour que l'utilisateur puisse apprécier les efforts que nous avons déployés 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);
}
}
Les écrans de démarrage ne doivent pas être chargés à partir d'un fichier de présentation, il peut encore 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:
<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>
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. Spécifiez plutôt 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 fichier XML pouvant être dessiné 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 défini une couleur d’arrière-plan et une image.
Vous allez ensuite définir cela 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é 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>
Dans votre nouveau SplashTheme, définissez l’attribut d’arrière-plan de la fenêtre sur votre dessin XML. Configurez-le en tant que thème de votre activité splash dans votre fichier 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 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();
}
}
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é Splash dans le thème, celle-ci est disponible immédiatement.
Si vous aviez un fichier de présentation pour votre activité Splash, ce fichier ne serait visible par l'utilisateur qu'une fois que votre application a été complètement initialisée, ce qui est trop tard. Vous souhaitez que le splash ne soit affiché que peu de temps avant l'initialisation de l'application.
Le fait de s'arrêter inutilement sur l'écran de démarrage pour 4 à 5 n'a pas beaucoup de sens . C'est Ok si vous chargez quelque chose en arrière-plan, suivez cette approche pour implémenter l'écran de démarrage: - un écran de démarrage dans le bon sens est un peu différent de ce que vous pouvez imaginer. La vue de démarrage que vous voyez doit être prête immédiatement, avant même que vous puissiez gonfler un fichier de présentation dans votre activité de démarrage.
Donc, vous n'utiliserez pas de fichier de mise en page. Spécifiez plutôt 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 fichier XML pouvant être dessiné 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 défini une couleur d’arrière-plan et une image.
Vous allez ensuite définir cela 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é 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>
Dans votre nouveau SplashTheme, définissez l’attribut d’arrière-plan de la fenêtre sur votre dessin XML. Configurez-le en tant que thème de votre activité splash dans votre fichier 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, lisez ceci: 1. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ 2. http: //blog.goodbarber .com/3 conseils pour créer un grand écran de démarrage pour votre portable app_a287.html
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 du démarrage de l'activité principale. Il y a deux raisons pour l'utiliser: la publicité et les opérations de réseau.
L'implémentation en tant que 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();
}
...
}
Créez une activité, laissez-nous une activité nommée 'A', puis créez un fichier xml appelé myscreen.xml, définissez-y une image d'écran de démarrage en tant qu'arrière-plan, puis utilisez un compte à rebours pour naviguer entre les différentes activités. Pour savoir comment utiliser le compte à rebours, voir ma réponse à cette question TimerTask in 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);
}
}
- 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>
Parfois, l'utilisateur ouvre la SplashActivity et se ferme immédiatement, mais l'application passe toujours à MainActivity après SPLASH_SCREEN_DISPLAY_LENGTH.
Pour éviter cela: dans SplashActivity, vous devriez vérifier que la SplashActivity est terminée ou pas 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) Créez d’abord une Theme pour l’écran de démarrage: vous avez un thème appelé splashscreenTheme, votre thème de lanceur serait:
<style name="splashscreenTheme">
<item name="Android:windowBackground">@drawable/launch_screen</item>
</style>
Remarque:
Android:windowBackground définit déjà votre image splashscreen no
besoin de le faire dans l'interface utilisateur à nouveau.
vous pouvez également utiliser la couleur ici au lieu d'un dessinable.
2) Définissez le thème sur manifeste de 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 drawable ne se trouve pas dans le dossier drawable si votre image n’est pas petite.
Il en résultera un démarrage plus rapide de l'écran de lancement et une sauvegarde de l'écran noir
Cela évite aussi un surplus de tirage
C'est le meilleur billet 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: Tirer parti de l’arrière-plan de la fenêtre pour s’animer sur votre écran initial et afficher l’interface utilisateur fictive (choix populaire utilisé actuellement par Google pour la plupart des applications).
Je me réfère à ce message chaque fois que je dois prendre en compte le temps de démarrage à froid et éviter le décrochage de l'utilisateur en raison des temps de démarrage longs.
J'espère que cela t'aides!
Qu'en est-il d'un écran de lancement super flexible qui peut utiliser le même code et qui 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 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, SpashActivity lui-même recherche les méta-données de "launch_class" pour créer l’intention proprement dite. 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();
}
}
}
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();
}
Vous pouvez ajouter ceci 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 ...
Code simple, ça marche :) Simple splash
int secondsDelayed = 1;
new Handler().postDelayed(new Runnable() {
public void run() {
startActivity(new Intent(LoginSuccessFull.this, LoginActivity.class));
finish();
}
}, secondsDelayed * 1500);
Dans mon cas, je ne voulais pas créer une nouvelle activité uniquement pour afficher une image pendant 2 secondes. Lors du démarrage de ma MainAvtivity, les images sont chargées dans les supports à l’aide de picasso. Je sais que cela prend environ une seconde à charger; j’ai donc décidé de procéder comme suit dans ma 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 passe est que la ImageView est affichée et que la barre de statut est supprimée en définissant les indicateurs de la fenêtre en plein écran. Ensuite, j'ai utilisé une Handler pour s'exécuter pendant 2 secondes. Après les 2 secondes, j'ai effacé les indicateurs en plein écran et réglé la visibilité de ImageView à GONE. Facile, simple, efficace.
C'est vraiment simple sous 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, placez n'importe quelle image à l'aide de 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);
}
En 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 ........
Approche vraiment facile et gr8:
Commencez par créer votre écran avec le site Web suivant:
https://www.norio.be/Android-feature-graphic-generator/
Choisissez votre logo et votre slogan, choisissez votre beau fond. redimensionnez-le à 4096x4096.
Maintenant, téléchargez cette image et mettez-la à niveau:
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. cet article était destiné à aider les autres avec la première étape de la création de l'écran de démarrage!
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();
}
}
J'ai utilisé des threads pour créer l'écran Flash sous 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();
}
}