¿Cómo hago una pantalla de bienvenida?

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

¿Cómo lo crearía y luego lo implementaría?

Otras lecturas:

• Tiempo de inicio de aplicaciones y pantallas de inicio temáticas (Patrones de rendimiento de Android Temporada 6 Ep. 4)
• Pantalla de bienvenida en Android: la forma correcta

Vieja respuesta:

CÓMO : Pantalla de inicio simple

Esta respuesta le muestra cómo mostrar una pantalla de bienvenida durante un período de tiempo fijo cuando se inicia su aplicación, por ejemplo, por razones de marca. Por ejemplo, puede elegir mostrar la pantalla de bienvenida durante 3 segundos. Sin embargo, si desea mostrar la pantalla de spash durante un período de tiempo variable (por ejemplo, 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 dispositivos nuevos, por lo que el usuario solo verá un flash que es una mala experiencia de usuario.

Primero debes definir la pantalla de spash en tu layout.xmlarchivo

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

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: el retraso de la pantalla de inicio depende del tiempo de inicio de la aplicación.

Cuando abra cualquier aplicación de Android, obtendrá de forma predeterminada una pantalla negra con el título y el ícono de la aplicación en la parte superior, puede cambiar eso usando un estilo / tema.

Primero, cree un style.xml en la carpeta de valores y agréguele un estilo.

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

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.

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

Tercero, actualice su tema en su actividad de lanzamiento 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 esta publicación .

Gracias a @ mat1h y @adelriosantiago

• Crea una actividad: Splash
• Cree un archivo XML de diseño: splash.xml
• Coloque los componentes de la interfaz de usuario en el diseño splash.xml para que se vea 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);
      }
  }

• cambiar ActivityB.classa la actividad que desee comenzar después de la pantalla de inicio

• revise su archivo de manifiesto y debería verse como

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

Las respuestas anteriores son muy buenas, pero me gustaría agregar algo más. Soy nuevo en Android, me encontré con este problema 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.

       <activity
           android:name=".SplashActivity"
           android:theme="@android:style/Theme.DeviceDefault.Light.NoActionBar">
           <intent-filter>
               <action android:name="android.intent.action.MAIN" />
               <category android:name="android.intent.category.LAUNCHER" />
           </intent-filter>
       </activity>

2. La pantalla de presentación 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 mostrarla 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 codificación!

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

Implementar una pantalla de bienvenida

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

Por lo tanto, no utilizará un archivo de diseño. En su lugar, especifique el fondo de la pantalla de inicio como el fondo del tema de la actividad. Para hacer esto, primero cree un XML dibujable en 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>

Es solo una lista de capas con el logotipo en el color de fondo central.

Ahora abra styles.xml y agregue este estilo

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

Este tema tendrá una barra de acción y con el fondo que acabamos de crear arriba.

Y en manifiesto, debe establecer SplashTheme en la actividad que desea usar como 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>

Luego, dentro de su código de actividad, navegue al usuario a la pantalla específica después de salpicar usando la 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 manera correcta de hacerlo. Usé estas referencias como respuesta.

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

1. Crear un Activity SplashScreen.java

   public class SplashScreen extends Activity {
   protected boolean _active = true;
   protected int _splashTime = 3000; // time to display the splash screen in ms
   
   
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.splashscreen);
   
       Thread splashTread = new Thread() {
           @Override
           public void run() {
               try {
                   int waited = 0;
                   while (_active && (waited < _splashTime)) {
                       sleep(100);
                       if (_active) {
                           waited += 100;
                       }
                   }
               } catch (Exception e) {
   
               } finally {
   
                   startActivity(new Intent(SplashScreen.this,
                           MainActivity.class));
                   finish();
               }
           };
                };
       splashTread.start();
   }
    }

2. splashscreen.xml será así

   <?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, por defecto, no hace que su aplicación se vea más profesional automáticamente. Una pantalla de bienvenida diseñada profesionalmente tiene la posibilidad de hacer que su aplicación se vea más profesional, pero si no sabe cómo escribir una, entonces qué tan profesional será realmente el resto de su aplicación.

La única razón (excusa) para tener una pantalla de bienvenida es porque está haciendo una gran cantidad de Cálculos o está esperando que se inicie GPS / WiFi porque su Aplicación se basa en eso antes de que comience. Sin el resultado de esos Cálculos o el acceso a GPS / WiFi (etc.), su aplicación está muerta en el agua, por lo tanto, siente que necesita una pantalla de bienvenida y DEBE bloquear la vista de la pantalla para cualquier otro programa 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, luego, una vez que se completan los largos cálculos, se pueden completar los detalles finales (la imagen modificada). La posibilidad de que ese sea el caso o de que sea la única forma en que se podría diseñar el Programa es muy pequeña .

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

Ya hay íconos en su teléfono que dicen que el GPS / WiFi se está iniciando. El tiempo o el espacio que ocupa la pantalla de bienvenida se puede gastar cargando cálculos previos o realmente haciendo los cálculos. Consulte el primer enlace a continuación para ver los problemas que crea y lo que debe considerarse.

Si absolutamente debe esperar estos Cálculos o GPS / WiFi, lo mejor sería simplemente dejar que la Aplicación se inicie y que aparezca una ventana emergente que dice que es necesario esperar los Cálculos (un mensaje TEXTUAL "Inicializando" está bien). Se espera la espera para GPS / WiFi (si ya no estaban habilitados en otro programa), por lo que no es necesario anunciar sus tiempos de espera.

Recuerde que cuando la pantalla de inicio inicia su programa ya se está ejecutando, todo lo que está haciendo es retrasar el uso de su programa y acaparar la CPU / GPU para hacer algo que la mayoría no considera necesario.

Es mejor que realmente esperemos y veamos su pantalla de bienvenida cada vez que comenzamos su programa o no sentiremos que esté escrito de manera muy profesional. Hacer que la pantalla de inicio sea una pantalla COMPLETA y un duplicado de la pantalla real del programa (por lo que creemos que se inicializa cuando en realidad no lo ha hecho) PODRÍA lograr su objetivo (hacer que su programa se vea más profesional), pero no apostaría mucho por 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 su situación de alguna manera 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 haya derrotado la única razón 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 semana pasada (cuando no es un canal de comedia o estilo de vida). ¡Solo muestra el espectáculo! (Solo ejecuta el programa).

Sobre todo 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 "Fuga de 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 solo borrará la memoria asignada de la instancia anterior de Activity 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 es being (strong) referencedde un objeto que vivió la instancia de actividad. Cada aplicación de Android tiene una cantidad específica de memoria asignada. Cuando Garbage Collector no puede liberar memoria no utilizada, el rendimiento de la aplicación disminuirá gradualmente y finalmente se bloqueará con un OutOfMemoryerror.

¿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.Fugas de memoria cuando el usuario cambia la orientación.

Primero debe definir la pantalla de presentación en su splashscreen.xmlarchivo de recursos de diseño

Código de muestra para la actividad de la pantalla de bienvenida.

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, visite este enlace.

La detención en la pantalla de bienvenida 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 inicio: Implementar una pantalla de presentación de la manera correcta es un poco diferente de lo que pueda imaginar. La vista de bienvenida que ve tiene que estar lista de inmediato, incluso antes de que pueda inflar un archivo de diseño en su actividad de bienvenida.

Por lo tanto, no utilizará un archivo de diseño. En su lugar, especifique el fondo de la pantalla de inicio como el fondo del tema de la actividad. Para hacer esto, primero, cree un XML dibujable en 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>

Aquí, he configurado un color de fondo y una imagen.

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

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

En su nuevo SplashTheme, establezca el atributo de fondo de la ventana en su dibujo XML. Configure esto como el tema de su actividad de bienvenida en su 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>

Finalmente, la clase SplashActivity 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();
    }
}

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

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

En styles.xml crea un tema personalizado

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

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

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

Salud.

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 establecerlo the android:windowBackgrounden un recurso extraíble.

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

En una palabra:

Declare su SplashScreenActivity en el manifiesto:

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

En su SplashScreenActivity.java:

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

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

}

A continuación, cree el recurso para la ventana de fondo de su tema:

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

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

Después de Android Marshmallow , otro uso productivo de la pantalla de bienvenida que se me ocurreAndroid Permissions es necesario en la pantalla de bienvenida de su aplicación.

Parece que la mayoría de las aplicaciones manejan la solicitud de permiso de esta manera.

• Los cuadros de diálogo hacen que UIX sea malo y rompen el flujo principal y te hacen decidir sobre el tiempo de ejecución y la verdad es que a la mayoría de los usuarios quizás no les importe si tu aplicación quiere escribir algo en la tarjeta SD. Es posible que algunos de ellos ni siquiera entiendan lo que estamos tratando de transmitir hasta que lo traduzcamos al inglés.

• Al solicitar permisos a la vez, haga menos cantidad de "si no" antes de cada operación y haga que su código se vea libre de desorden.

Este es un ejemplo de cómo puede solicitar permisos en su actividad de bienvenida para dispositivos con sistema operativo Android 23+.

Si se otorgan todos los permisos O ya se otorgó O la aplicación se está ejecutando en Pre Marshmallow ENTONCES, simplemente vaya y muestre los contenidos principales con un pequeño retraso de medio segundo para que el usuario pueda apreciar el esfuerzo que hemos realizado al leer esta pregunta y tratar de dar lo mejor de nosotros.

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


}

No utilizará un archivo de diseño. En su lugar, especifique el fondo de la pantalla de inicio como el fondo del tema de la actividad. Para hacer esto, primero cree un XML dibujable en res / drawable.

Nota: todo el código a continuación 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>

Aquí, he configurado un color de fondo y una imagen.

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

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

En su nuevo SplashTheme, establezca el atributo de fondo de la ventana en su dibujo XML. Configure esto como el tema de su actividad de bienvenida en su 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>

Finalmente, su clase SplashActivity 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 IU para su actividad de bienvenida en el tema, está disponible de inmediato.

Si tuviera 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 la presentación se muestre solo en ese pequeño período de tiempo antes de que se inicialice la aplicación.

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

Cree una Actividad, déjenos Actividad llamada 'A', luego cree un archivo xml llamado myscreen.xml, en el que establezca una imagen de pantalla de inicio como fondo, y luego use el temporizador de cuenta regresiva para navegar de una Actividad a otra. Para saber cómo usar el temporizador de cuenta regresiva, vea 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 antes posible para ocultar el retraso del inicio de la actividad principal. Hay dos razones para usarlo: publicidad y operaciones de red.

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

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:

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

Y empezar:

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

    ...
}

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

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

Enfoque realmente fácil y gr8:

• Primero crea tu splash con el siguiente sitio web:

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

  Elija su logotipo y lema, elija su hermoso fondo. redimensionarlo a 4096x4096.

• Ahora descargue esa imagen y actualícela a:

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

  Y genere todas las pantallas de presentación necesarias, todos los dispositivos, todas las plataformas.

¡Disfrutar!

Aquí hay suficientes respuestas que ayudarán con la implementación. ¡Esta publicación estaba destinada a ayudar a otros con el primer paso para crear la pantalla de bienvenida!

¿Qué tal una pantalla de inicio súper flexible que puede usar el mismo código y se define 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.

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

Luego, la propia SpashActivity busca los metadatos para "launch_class" para luego hacer la intención. La "duración" de los 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();
    }
  }
}

En algún momento, el usuario abre SplashActivityy cierra inmediatamente, pero la aplicación continúa MainActivitydespués SPLASH_SCREEN_DISPLAY_LENGTH.

Para evitarlo: en SplashActivitydebe comprobar si SplashActivityestá terminando o no antes de pasar aMainActivity

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

Espero que esto ayude

Aunque hay buenas respuestas, mostraré la forma recomendada de Google:

1) Primero cree una Themepantalla de presentación: tiene un tema llamado splashscreenTheme, su tema de inicio sería:

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

Nota:

android:windowBackgroundya configura la imagen de la pantalla de bienvenida, no es
necesario volver a hacer esto en la interfaz de usuario.

También puede usar el color aquí en lugar de un dibujable.

2) Establecer el tema para manifestar 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) asegúrese de que launch_screen drawableno esté en la drawablecarpeta si su imagen no es pequeña.

Esto dará como resultado un inicio de pantalla de inicio más rápido y lo salvará de la pantalla negra

También evita el sobregiro adicional

Esta es la mejor publicación que he visto en pantallas de bienvenida: http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero entra en dos opciones diferentes para las pantallas de bienvenida: Aprovechando el fondo de la ventana para animar en su pantalla inicial y mostrando la interfaz de usuario de marcador de posición (que es una opción popular que Google usa para la mayoría de sus aplicaciones en estos días).

Me refiero a esta publicación cada vez que necesito considerar el tiempo de inicio en frío y evitar la baja del usuario debido a los largos tiempos de inicio.

¡Espero que esto ayude!

En mi caso, no quería crear una nueva Actividad solo para mostrar una imagen durante 2 segundos. Al iniciar mi MainAvtivity, las imágenes se cargan en soportes con picasso, sé que esto tarda aproximadamente 1 segundo en cargarse, así que decidí hacer lo siguiente dentro de mi 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);

Al iniciar la aplicación, lo primero que sucede es que ImageViewse muestra y se elimina la barra de estado configurando los indicadores de ventana en pantalla completa. Luego usé a Handlerpara correr durante 2 segundos, después de los 2 segundos borro las banderas de pantalla completa y establezco la visibilidad de ImageViewa GONE. Fácil, simple, efectivo.

Es realmente simple en Android, solo usamos el concepto de controlador para implementar la pantalla de inicio

En su archivo Java SplashScreenActivity pegue este código.

En su archivo xml SplashScreenActivity, coloque cualquier imagen usando 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);
    }

Puede agregar esto en su método 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);

E inicialice su valor de tiempo en milisegundos como desee ...

private  static int time=5000;

para más detalles descargue el código completo desde este enlace ...

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

En Kotlin escribe este código: -

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

Espero que esto te ayude. Gracias ........

Código simple, funciona :) 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();
  }
}