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?
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?
Réponses:
Lectures complémentaires:
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.xml
fichier
<?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 ;)
SPLASH_DISPLAY_LENGTH
temps. Vous devriez le faire à la place: bignerdranch.com/blog/splash-screens-the-right-way
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.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);
}
MISE À JOUR Consultez ce post .
Merci à @ mat1h et @adelriosantiago
<item name="android:background">
cela l'emporterait sur windowBackground
. Et sans android:background
définition, mon arrière-plan dans tous les fragments serait transparent révélant l'activité derrière le contenu de premier plan.
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.class
de 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.
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>
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!
android:noHistory="true"
à AndroidManifest.xml
empêcher l'utilisateur de revenir à l'écran d'accueil à l' aide du bouton de retour.
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.
YouTube
ce sujet. Mais je pense que la taille du bitmap sera le problème car vous ne pouvez pas le redimensionner en utilisant layer-list
.
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();
}
}
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) referenced
provient 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 OutOfMemory
erreur.
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.xml
fichier 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é.
drawable
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:windowBackground
sur 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 SplashActivity
et quitte immédiatement, mais l'application continue de fonctionner MainActivity
après SPLASH_SCREEN_DISPLAY_LENGTH
.
Pour l'empêcher: SplashActivity
vous devez vérifier la SplashActivity
fin 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:windowBackground
dé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 drawable
n'est pas dans le drawable
dossier 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 ImageView
s'affiche et la barre d'état est supprimée en définissant les indicateurs de fenêtre en plein écran. Ensuite , j'ai utilisé Handler
pour 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 ...
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 ........
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();
}
}