¿Cómo hago una pantalla de bienvenida?

Quería hacer que mi aplicación se viera más profesional, así que decidí que quería hacer una pantalla de bienvenida.

¿Cómo podría crearlo y luego implementarlo?

Otras lecturas:

  • Hora de lanzamiento de la aplicación y pantallas de lanzamiento temáticas (Android Performance Patterns Season 6 Ep. 4)
  • Pantalla de bienvenida en Android: la forma correcta

Respuesta anterior:

CÓMO PARA : pantalla de bienvenida simple

Esta respuesta muestra cómo mostrar una pantalla de bienvenida durante un período fijo de tiempo cuando se inicia la aplicación, por ejemplo, por motivos de marca. Por ejemplo, puede elegir mostrar la pantalla de bienvenida durante 3 segundos. Sin embargo, si desea mostrar la pantalla spash durante un período de tiempo variable (por ejemplo, el tiempo de inicio de la aplicación), debe consultar la respuesta de Abdullah https://stackoverflow.com/a/15832037/401025 . Sin embargo, tenga en cuenta que el inicio de la aplicación puede ser muy rápido en los dispositivos nuevos, por lo que el usuario solo verá un flash que es UX incorrecto.

Primero debe definir la pantalla spash en su archivo layout.xml

       

Y tu actividad:

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

Eso es todo 😉

Tenga en cuenta que esta solución no permitirá que el usuario espere más: la demora de la pantalla de inicio depende del tiempo de inicio de la aplicación.

Cuando abras una aplicación de Android obtendrás por defecto una pantalla en negro con el título y el ícono de la aplicación en la parte superior, puedes cambiar eso usando un estilo / tema.

Primero, cree un archivo style.xml en values ​​y añádale un estilo.

  

En lugar de usar @android:style/Theme.DeviceDefault.Light.NoActionBar , puede usar cualquier otro tema como padre.

En segundo lugar, en su aplicación Manifest.xml, agregue android:theme="@style/splashScreenTheme" a su actividad principal.

  

En tercer lugar, actualice su tema en su actividad de inicio onCreate ().

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

ACTUALIZAR Echa un vistazo a esta publicación https://plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd Gracias a @ mat1h y @adelriosantiago

  • Crear una actividad: Splash
  • Crear un archivo XML de diseño: splash.xml
  • Coloque los componentes de la interfaz de usuario en el diseño de splash.xml para que luzca como desee
  • su Splash.java puede verse así:

     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); } } 
  • cambie ActivityB.class a cualquier actividad que desee iniciar después de la pantalla de inicio

  • verifica tu archivo de manifiesto y debería verse como

          

La respuesta de @Abdullah es correcta, sin embargo Google ha publicado una explicación extendida sobre cómo implementar esto correctamente sin alterar el tema de su actividad:

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

Las aplicaciones como Google Maps y YouTube han comenzado a usar el mismo método.

Las respuestas anteriores son muy buenas, pero me gustaría agregar algo más. Soy nuevo en Android, conocí estos problemas durante mi desarrollo. Espero que esto pueda ayudar a alguien como yo.

  1. La pantalla de bienvenida es el punto de entrada de mi aplicación, así que agregue las siguientes líneas en AndroidManifest.xml.

            
  2. La pantalla de bienvenida solo debe mostrarse una vez en el ciclo de vida de la aplicación, utilizo una variable booleana para registrar el estado de la pantalla de presentación y solo la muestro la primera vez.

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

feliz encoding!

  1. Crear una 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 será así

        

Un Splash Screnn, de forma predeterminada, no hace que su aplicación se vea más profesional automáticamente. Una pantalla Splash diseñada profesionalmente tiene la posibilidad de hacer que su aplicación se vea más profesional, pero si no sabe cómo escribirla, entonces, ¿qué tan profesional será realmente el rest de su aplicación?

La única razón (excusa) para tener una pantalla de bienvenida es porque estás haciendo una gran cantidad de cálculos o estás esperando que se inicie el GPS / WiFi porque tu aplicación depende de eso antes de que comience. Sin el resultado de esos Cálculos o acceso a GPS / WiFi (etc.), su Aplicación está muerta en el agua, por lo tanto, usted siente que necesita una Pantalla de bienvenida, y DEBE bloquear la vista de la Pantalla por cualquier otro Progtwig en ejecución (incluido el Fondo )

Dicha pantalla de bienvenida debería parecerse a su aplicación de pantalla completa para dar la impresión de que ya se ha inicializado, y luego de completar los largos cálculos, los detalles finales podrían completarse (la imagen ajustada). La posibilidad de que sea el caso o que sea la única forma en que se podría diseñar el progtwig es muy pequeña .

Sería mejor permitir que el Usuario (y el rest del sistema operativo) haga algo más mientras esperan en lugar de diseñar su Progtwig para que dependa de algo que llevará un tiempo (cuando la duración de la espera es incierta).

Ya hay icons en su teléfono que dicen que el GPS / WiFi está comenzando. El tiempo o el espacio utilizado por la pantalla de bienvenida se puede gastar en cargar cálculos previos o hacer los cálculos. Consulte el primer enlace a continuación para conocer los problemas que crea y lo que debe tenerse en cuenta.

Si tiene que esperar estos Cálculos o GPS / WiFi, lo mejor sería simplemente dejar que la Aplicación se inicie y tener una ventana emergente que diga que es necesario esperar los Cálculos (un Mensaje TEXTUAL de “Inicialización” está bien). Se espera la espera de GPS / WiFi (si ya no estaban habilitados en otro progtwig), por lo que no es necesario anunciar sus tiempos de espera.

Recuerde que cuando la pantalla de bienvenida inicia su progtwig realmente se está ejecutando, todo lo que está haciendo es retrasar el uso de su progtwig y acaparar la CPU / GPU para hacer algo que la mayoría no cree que sea necesario.

Será mejor que realmente deseemos esperar y ver su pantalla de bienvenida cada vez que iniciemos su progtwig o NOSOTROS no sentiremos que está escrito de forma muy profesional. Hacer que la pantalla de bienvenida pantalla COMPLETA y un duplicado de la pantalla del progtwig real (por lo que pensamos que se inicializa cuando en realidad no) puede lograr su objective (hacer que su progtwig se vea más profesional) pero yo no apostaría mucho en eso.

Por qué no hacerlo: http://cyrilmottier.com/2012/05/03/splash-screens-are-evil-dont-use-them/

Cómo hacerlo: https://encrypted.google.com/search?q=Android+splash+screen+source

Entonces hay una buena razón para no hacerlo, pero SI está seguro de que de alguna manera su situación queda fuera de esos ejemplos, entonces los medios para hacerlo se dan arriba. Asegúrese de que realmente haga que su Aplicación se vea más profesional o que haya vencido la única razón por la que dio para hacerlo.

Es como un canal de YouTube que comienza cada video con una larga introducción gráfica (y Outro) o siente la necesidad de contar una broma o explicar lo que sucedió durante la última semana (cuando no es una comedia o un canal de LifeStyles). ¡Solo muestra el espectáculo! (Simplemente ejecuta el progtwig).

Sobretodo las respuestas son realmente muy buenas. Pero hay un problema de pérdida de memoria. Este problema a menudo se conoce en la comunidad de Android como “Fugas en una actividad” . ¿Qué significa eso exactamente?

Cuando se produce un cambio de configuración, como un cambio de orientación, Android destruye la Actividad y la recrea. Normalmente, el recolector de basura simplemente borrará la memoria asignada de la instancia de actividad anterior y todos estamos bien.

“Filtrar una actividad” se refiere a la situación en la que el recolector de basura no puede borrar la memoria asignada de la instancia de actividad anterior ya que se hace being (strong) referenced desde un objeto que vivió la instancia de actividad. Cada aplicación de Android tiene una cantidad específica de memoria asignada para ello. Cuando Garbage Collector no puede liberar la memoria no utilizada, el rendimiento de la aplicación disminuirá gradualmente y finalmente se bloqueará con el error OutOfMemory .

¿Cómo determinar si la aplicación pierde memoria o no? La forma más rápida es abrir la pestaña Memoria en Android Studio y prestar atención a la memoria asignada a medida que cambia la orientación. Si la memoria asignada sigue aumentando y nunca disminuye, entonces tiene una pérdida de memoria.

1.Fallo de memoria cuando el usuario cambia la orientación. enter image description here

En primer lugar, debe definir la pantalla de bienvenida en su recurso de diseño archivo splashscreen.xml

Código de muestra para la actividad de la pantalla de presentación.

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

Para obtener más información, vaya a este enlace

La respuesta de Abdullah es genial. Pero quiero agregar algunos detalles más con mi respuesta.

Implementando una pantalla de bienvenida

Implementar una pantalla de bienvenida de la manera correcta es un poco diferente de lo que imagina. La vista de bienvenida que ve debe estar lista inmediatamente, incluso antes de que pueda inflar un archivo de diseño en su actividad de bienvenida.

Entonces no usarás un archivo de diseño. En su lugar, especifique el fondo de la pantalla de presentación como el fondo del tema de la actividad. Para hacer esto, primero crea un XML dibujable en res / dibujable.

background_splash.xml

        

Es solo una lista de capas con el logo en el color de fondo del centro con ella.

Ahora abra styles.xml y agregue este estilo

  

Este tema deberá tener una barra de acciones y un fondo que acabamos de crear.

Y en manifiesto, debe establecer SplashTheme a la actividad que desea utilizar como splash.

      

Luego, dentro de su código de actividad, navegue al usuario a la pantalla específica después de la presentación con intención.

 public class SplashActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Intent intent = new Intent(this, MainActivity.class); startActivity(intent); finish(); } } 

Esa es la forma correcta de hacerlo. Utilicé estas referencias para la respuesta.

  1. https://material.google.com/patterns/launch-screens.html
  2. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ Gracias a estos chicos por empujarme en la dirección correcta. Quiero ayudar a otros porque la respuesta aceptada no es una pantalla de bienvenida recomendada.

Este es el código completo aquí

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

En dibujables crea este bg_splash.xml

      

En styles.xml crea un tema personalizado

  

y finalmente en AndroidManifest.xml especifica el tema para tu actividad

       

Aclamaciones.

Las pantallas de bienvenida no se deben cargar desde un archivo de diseño, aún puede haber algún retraso al cargarlo.

La mejor manera es crear un tema solo para su SplashScreenActivity y configurar the android:windowBackground en un the android:windowBackground .

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

En una palabra:

Declara tu SplashScreenActivity en el manifiesto:

       

En su SplashScreenActivity.java:

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

Luego crea el recurso para la ventana de fondo de tu tema:

  

Archivo extraíble splash.xml:

        

Después de Android Marshmallow , otro uso productivo de la pantalla Splash llego a pensar que está solicitando los Android Permissions necesarios en la pantalla de Android Permissions de su aplicación.

parece que la mayoría de las aplicaciones manejan solicitudes de permisos de esta manera.

  • Los cuadros de diálogo crean mal UIX y rompen el flujo principal y le hacen decidir sobre el tiempo de ejecución, y la verdad es que a la mayoría de los usuarios no les importa si su aplicación desea escribir algo en la tarjeta SD. Algunos de ellos podrían no entender lo que estamos tratando de transmitir hasta que lo traduzcamos en inglés.

  • Al solicitar permisos de una sola vez, se obtiene menos cantidad de “if else” antes de cada operación y el código se ve libre de obstáculos.

Este es un ejemplo de cómo puede solicitar permisos en su actividad splash para dispositivos que ejecutan Android OS 23+.

Si todos los permisos son otorgados O ya están otorgados O la aplicación se está ejecutando en Pre Marshmallow ENTONCES simplemente ve y muestra los contenidos principales con un poco de retraso de medio segundo para que el usuario pueda apreciar el esfuerzo que hemos puesto leyendo esta pregunta y tratando de dar lo mejor.

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

no usarás un archivo de diseño. En su lugar, especifique el fondo de la pantalla de presentación como el fondo del tema de la actividad. Para hacer esto, primero crea un XML dibujable en res / dibujable.

Nota: todo el código a continuación está disponible GitHub Link

        

Aquí, configuré un color de fondo y una imagen.

A continuación, configurará esto como el fondo de su actividad de salpicadura en el tema. Navegue a su archivo styles.xml y agregue un nuevo tema para su actividad splash:

      

En su nuevo SplashTheme, establezca el atributo de fondo de la ventana en su XML dibujable. Configure esto como el tema de su actividad splash en su AndroidManifest.xml:

       

Finalmente, su clase SplashActivity solo debería reenviarlo a su actividad principal:

 public class SplashActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Intent intent = new Intent(this, MainActivity.class); startActivity(intent); finish(); } } 

Tenga en cuenta que ni siquiera configura una vista para esta SplashActivity. La vista proviene del tema. Cuando configura la interfaz de usuario para su actividad de bienvenida en el tema, está disponible inmediatamente.

Si tenía un archivo de diseño para su actividad de bienvenida, ese archivo de diseño sería visible para el usuario solo después de que su aplicación se haya inicializado por completo, lo cual es demasiado tarde. Desea que el splash se muestre solo en ese pequeño período de tiempo antes de que la aplicación se inicialice.

Cree una Actividad, permítanos Actividad llamada ‘A’, luego cree un archivo xml llamado myscreen.xml, en ese ajuste una imagen de la pantalla de bienvenida como fondo, y luego use el temporizador de cuenta regresiva para navegar de una Actividad a otra. Para saber cómo utilizar el temporizador de cuenta regresiva, ver mi respuesta en esta pregunta TimerTask en Android?

Ejemplo de pantalla de bienvenida:

 public class MainActivity extends Activity { private ImageView splashImageView; boolean splashloading = false; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); splashImageView = new ImageView(this); splashImageView.setScaleType(ScaleType.FIT_XY); splashImageView.setImageResource(R.drawable.ic_launcher); setContentView(splashImageView); splashloading = true; Handler h = new Handler(); h.postDelayed(new Runnable() { public void run() { splashloading = false; setContentView(R.layout.activity_main); } }, 3000); } } 

La pantalla de bienvenida es un pequeño objeto inutilizable en Android: no se puede cargar lo más pronto posible para ocultar el retraso de la actividad principal. Hay dos razones para usarlo: publicidad y operaciones de red.

La implementación como diálogo hace saltar sin demora de la pantalla de inicio a la IU de actividad principal.

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

Diseño:

     

Y comienza:

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

La pantalla Detener en el Splash para 4’s 5 innecesariamente no tiene mucho sentido. Está bien si carga algo en segundo plano, siga este enfoque para implementar la pantalla de bienvenida: – Implementar una pantalla de bienvenida de la manera correcta es un poco diferente de lo que podría imaginar. La vista de bienvenida que ve debe estar lista inmediatamente, incluso antes de que pueda inflar un archivo de diseño en su actividad de bienvenida.

Entonces no usarás un archivo de diseño. En su lugar, especifique el fondo de la pantalla de presentación como el fondo del tema de la actividad. Para hacer esto, primero, crea un XML dibujable en res / dibujable.

        

Aquí, configuré un color de fondo y una imagen.

A continuación, configurará esto como el fondo de su actividad de salpicadura en el tema. Navegue a su archivo styles.xml y agregue un nuevo tema para su actividad splash:

      

En su nuevo SplashTheme, establezca el atributo de fondo de la ventana en su XML dibujable. Configure esto como el tema de su actividad splash en su AndroidManifest.xml:

       

Finalmente, la clase SplashActivity solo debe reenviarlo a su actividad principal:

  public class SplashActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Intent intent = new Intent(this, MainActivity.class); startActivity(intent); finish(); } } 

Más detalles lea esto: 1. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ 2. http://blog.goodbarber.com/3-tips-to-create-a -great-splash-screen-for-your-mobile-app_a287.html

¿Qué tal una pantalla de lanzamiento súper flexible que puede usar el mismo código y está definida en AndroidManifest.xml, por lo que el código nunca tendrá que cambiar? Generalmente desarrollo bibliotecas de código y no me gusta personalizar el código porque es descuidado.

         

Luego, SpashActivity busca los metadatos de “launch_class” para luego crear el Intent. La “duración” de metadatos define cuánto tiempo permanece activa la pantalla de bienvenida.

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

Otro enfoque se logra utilizando 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(); } 

En algún momento, el usuario abre SplashActivity y se cierra de inmediato, pero la aplicación sigue yendo a MainActivity después de SPLASH_SCREEN_DISPLAY_LENGTH .

Para evitarlo: en SplashActivity debe comprobar que SplashActivity está terminando o no antes de pasar a 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); } } } 

Hope this help

Though there are good answers, I will show the google recommended way:

1)First create a Theme for splash screen: you have a theme called splashscreenTheme , your launcher theme would be:

  

Nota:

android:windowBackground already sets your splashscreen image no
need to do this in UI again.

you can also use color here instead of a drawable.

2)Set the theme to manifest of 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.

¡Espero que esto ayude!

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

¡Disfrutar!

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!