¿Cómo hago una pantalla de bienvenida?

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

Cuando se abre cualquier aplicación de Android obtendrá por defecto un poco de lo que la pantalla negra con el título y el icono de la aplicación en la parte superior, se puede cambiar mediante el uso de un estilo/tema.

Primero, crea un estilo.xml en la carpeta valores y agregarle 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 un padre.

En segundo lugar, en el manifiesto de la aplicación.xml añade android:theme="@style/splashScreenTheme" a tu actividad principal.

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

Tercero, Actualiza tu tema en tu actividad de lanzamiento de onCreate ().

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

ACTUALIZACIÓN Echa un vistazo a este post https://plus.google.com / + AndroidDevelopers / posts / Z1Wwainpjhd Gracias a @ mat1h y @ adelriosantiago

• Crear una actividad: Splash
• Cree un archivo XML de diseño: splash.xml
• Ponga los componentes de la interfaz de usuario en el splash.diseño xml por lo que se ve como quieres

• Tu Splash.java puede tener este aspecto:

  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 bienvenida

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

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

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

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

Las respuestas anteriores son muy buenas, pero me gustaría añadir algo más. Soy nuevo en Android, me encontré con 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 agrega 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 la muestro en la primera tiempo.

   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!

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, de forma predeterminada, no hace que su Aplicación se vea más profesional automáticamente. Una pantalla de presentación 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á 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 el GPS/WiFi se inicie porque su La aplicación se basa en 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 que 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).

Tal pantalla de bienvenida debe parecerse a su aplicación de pantalla completa para dar la impresión de que ya se ha inicializado, luego, después de que se completen los largos cálculos, los detalles finales podría ser rellenado (la Imagen ajustado). La posibilidad de que ese sea el caso o que sea la única manera en que el Programa podría ser diseñado es muy pequeña.

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

Ya hay Iconos en su teléfono que dicen que el GPS/WiFi se está iniciando. El el tiempo o el espacio ocupado por la pantalla de bienvenida podría ser gastado cargando pre-cálculos o realmente haciendo los Cálculos. Vea el primer enlace a continuación para los problemas que crea y lo que debe considerarse.

Si es absolutamente necesario 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 fueran no habilitado en otro Programa ya) por lo que anunciar sus tiempos de espera son innecesarios.

Recuerde que cuando se inicia la pantalla de bienvenida, 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 siente que es necesario.

Es mejor que realmente queremos esperar y ver su pantalla de bienvenida cada vez que iniciamos su Programa o no vamos a sentir que está escrito muy profesionalmente. Haciendo el chapoteo Pantalla COMPLETA y un duplicado de la Pantalla del Programa real (por lo que creemos que se inicializa cuando en realidad no lo ha hecho) PODRÍA lograr su objetivo (de 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+pantalla+fuente

Así que hay una buena razón para no hacer pero SI usted está seguro de que de alguna manera su situación cae fuera de esos ejemplos, entonces los medios para hacerlo se da anteriormente. Asegúrese de que realmente hace que su solicitud se vea más profesional o que haya derrotado la única razón que dio para hacer esto.

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 Estilos de Vida). Simplemente ¡muestra el show ! (Simplemente ejecute el Programa).

Sobre todo las respuestas son realmente muy buenas. Pero hay problema de encuentro de pérdida de memoria. Este problema se conoce a menudo en la comunidad Android como "Filtrar 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 de Actividad antigua y todos estaremos bien.

"Fuga de un Activity " se refiere a la situación en la que el Recolector de basura no puede borrar la memoria asignada de la instancia de Actividad antigua ya que es being (strong) referenced de un objeto que vivió la instancia de Actividad. Cada aplicación de Android tiene una cantidad específica de memoria asignada para ella. Cuando el recolector de basura no puede liberar memoria no utilizada, el rendimiento de la aplicación disminuirá gradualmente y eventualmente 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 presta atención a la memoria asignada a medida que cambias la orientación. Si la memoria asignada sigue aumentando y nunca disminuye, entonces tiene una fuga de memoria.

1.Pérdida de memoria cuando el usuario cambia la orientación.

Primero debe definir la pantalla de bienvenida en su recurso de diseño splashscreen.xml archivo

Código de ejemplo 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, consulte este link

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

Implementación de una pantalla de bienvenida

Implementar una pantalla de bienvenida de la manera correcta es un poco diferente de lo que podría imaginar. La vista splash que ves tiene que estar lista inmediatamente, incluso antes de que puedas inflar un archivo de diseño en tu actividad splash.

Así que no va a utilizar un archivo de diseño. En su lugar, especifique el fondo de la pantalla de bienvenida como el fondo del tema de la actividad. Para hacer esto, primero cree un elemento de diseño XML 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 color de fondo central con él.

Ahora abre estilos.xml y añadir este estilo

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

Este tema tendrá que actionbar y con el fondo que acabamos de crear arriba.

Y en manifest es necesario establecer SplashTheme a la actividad que desea utilizar 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 por el usuario a la pantalla específica después de splash usando intent.

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. Usé estas referencias para responder.

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 los elementos de diseño crea 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 estilos .xml crear un tema personalizado

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

Y finalmente en AndroidManifest.xml especifique el tema de su 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>

Saludos.

Las pantallas de presentación no deben cargarse desde un archivo de diseño, todavía puede haber algún retraso al cargarlo.

La mejor manera es crear un tema solo para su SplashScreenActivity y establecer the android:windowBackground a un recurso de diseño.

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

En pocas palabras:

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, crear el ressource para la ventana de fondo de su tema:

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

Splash de archivo de elemento de diseño.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 en el que pienso es solicitando lo necesario Android Permissions en la pantalla de bienvenida de tu app.

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

• Los diálogos hacen que UIX sea malo y rompen el flujo principal y lo hacen decidir sobre el tiempo de ejecución y la verdad es que a la mayoría de los usuarios ni siquiera les importa si su aplicación desea escribir algo en la tarjeta SD. Algunos de ellos podrían ni siquiera entender lo que estamos tratando para transmitir hasta que lo traduzcamos en un inglés sencillo.

• Solicitar permisos de una vez hacer menos número de "si else" antes de cada operación y hacer que su código parece desorden libre.

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

Si todos los permisos están otorgados O ya otorgados O la aplicación se está ejecutando en Pre Marshmallow, simplemente vaya y muestre el contenido principal con un pequeño retraso de la mitad segundo para que el usuario pueda apreciar el esfuerzo que habíamos puesto en la lectura de esta pregunta y tratando 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);
    }


}

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 utilizará un archivo de diseño. En su lugar, especifique el fondo de la pantalla de bienvenida como el fondo del tema de la actividad. Para hacer esto, primero cree un elemento de diseño XML en res / drawable.

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

<?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, establecerá esto como el fondo de su actividad splash en el tema. Navega a tus estilos.archivo xml y añadir un nuevo tema para su splash actividad:

<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 tu nuevo SplashTheme, establece el atributo window background en tu elemento de diseño XML. Configura esto como el tema de tu actividad splash en tu 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>

Por último, tu clase SplashActivity debería enviarte a tu 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();
    }
}

Observe que ni siquiera configura una vista para esta actividad de Splash. La vista proviene del tema. Cuando configura la interfaz de usuario para su actividad splash en el tema, está disponible inmediatamente.

Si tuviera un archivo de diseño para su actividad splash, ese archivo de diseño sería visible para el usuario solo después de que su aplicación se haya inicializado completamente, lo que es demasiado tarde. Desea que el splash se muestre solo en esa pequeña cantidad de tiempo antes de que se inicialice la aplicación.

Cree una Actividad, permítanos una Actividad llamada 'A', luego cree un archivo xml llamado myscreen.xml, en el que establecer una imagen de la pantalla de bienvenida como fondo, y luego utilizar cuenta regresiva temporizador para navegar de una actividad a otra. Para saber cómo utilizar el temporizador de cuenta atrás 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 objeto poco 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 saltar sin demora de la pantalla de bienvenida a la interfaz 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);

    }
}

Disposición:

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

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 parada en la pantalla de presentación de 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 imaginas. La vista splash que ves tiene que estar lista inmediatamente, incluso antes de que puedas inflar un archivo de diseño en tu actividad splash.

Así que no va a utilizar un archivo de diseño. En su lugar, especifique su splash fondo de la pantalla como fondo del tema de la actividad. Para hacer esto, primero, cree un elemento de diseño XML 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, establecerá esto como el fondo de su actividad splash en el tema. Navega a tus estilos.archivo xml y añadir un nuevo tema para su actividad splash:

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
    </style>

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

</resources>

En tu nuevo SplashTheme, establece el atributo window background en tu elemento de diseño XML. Configura esto como el tema de tu actividad splash en tu 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>

Por último, la clase SplashActivity debería remitirte a tu 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 el 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>

Entonces la propia SpashActivity busca los metadatos de "launch_class" para luego hacer la Intent en sí. 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();
    }
  }
}

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 del usuario abrir el SplashActivity y salir de inmediato, pero la aplicación todavía ir a MainActivity después de SPLASH_SCREEN_DISPLAY_LENGTH.

Para prevenirlo: En SplashActivity debe comprobar que el SplashActivity está terminando o no antes de mover 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);
        }                             
   }                                
}

Espero que esto ayude

Aunque hay buenas respuestas, voy a mostrar la forma recomendada por Google:

1) Primero crea un Theme para la pantalla de bienvenida: tienes un tema llamado splashscreenTheme, tu tema de lanzador sería:

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

Nota:

android:windowBackground ya establece su imagen splashscreen no
necesidad de hacer esto en la interfaz de usuario de nuevo.

También puede usar color aquí en lugar de un elemento de diseño.

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 drawable es no en la carpeta drawable si su imagen no es pequeña.

Resultará en un inicio más rápido de la pantalla de inicio y lo salvará de la pantalla negra

También evita el sobregiro adicional

Este es el mejor post que he visto en las pantallas de presentación: http://saulmm.github.io/avoding-android-cold-starts

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

Me refiero a este post cada vez que necesito considerar el tiempo de arranque en frío y evitar la caída del usuario debido a tiempos de arranque largos.

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

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

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

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 los titulares usando picasso, sé que esto toma aproximadamente 1 segundo para cargar, 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 ImageView se muestra y la barra de estado se elimina configurando las banderas de la ventana a pantalla completa. Luego usé un Handler para correr durante 2 segundos, después de los 2 segundos que borro las banderas de pantalla completa y establecer la visibilidad de la ImageView a GONE. Fácil, simple, eficaz.

Usé hilos para hacer la pantalla Flash en 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();
    }
}

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

En su archivo java SplashScreenActivity pegue este código.

En su archivo xml SplashScreenActivity ponga 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);
    }

Muy fácil enfoque & gr8:

• Primero crea tu splash con el siguiente sitio web :

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

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

• Ahora descarga esa imagen y súbela a :

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

  Y generar todas las pantallas de bienvenida necesarias, todas dispositivos, todas las plataformas.

Disfrute!

Aquí hay suficientes respuestas que ayudarán con la implementación. este post fue pensado para ayudar a otros con el primer paso de crear la pantalla de bienvenida!