android - studio - ¿Cómo hago una pantalla de bienvenida?

splash screen android studio 2017

Question

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

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

Answer 1

1. Crear una Activity SplashScreen.java

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

2. splashscreen.xml será así

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

Answer 2

¿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 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, el SpashActivity busca los metadatos de "launch_class" para luego realizar el Intent. La "duración" de los metadatos define la duración de la pantalla de inicio.

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

Answer 3

Cree una actividad, permítenos la actividad llamada ''A'', luego cree un archivo xml llamado myscreen.xml, en el que se establece la imagen de la 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 ¿ Tarea de tiempo en Android?

Answer 4

Después de Android Marshmallow , otro uso productivo de la pantalla de bienvenida que se me ocurre es solicitar los Android Permissions necesarios de Android Permissions en la pantalla de presentación de la aplicación.

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

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

• Solicitar permisos al mismo tiempo hace que haya menos cantidad de "en caso contrario" 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 inicio para dispositivos con Android OS 23+.

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

import android.Manifest;
import android.annotation.TargetApi;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.widget.Toast;
import com.c2h5oh.beer.R;
import com.c2h5oh.beer.utils.Animatrix;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SplashActivity extends AppCompatActivity {
final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.splash);
//show animations
Animatrix.scale(findViewById(R.id.title_play), 100);
Animatrix.scale(findViewById(R.id.title_edit), 100);
Animatrix.scale(findViewById(R.id.title_record), 100);
Animatrix.scale(findViewById(R.id.title_share), 100);
if (Build.VERSION.SDK_INT >= 23) {
// Marshmallow+ Permission APIs
fuckMarshMallow();
} else {
// Pre-Marshmallow
///Display main contents
displaySplashScreen();
}
}
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
switch (requestCode) {
case REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS: {
Map<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);
}
}

Answer 5

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

Answer 6

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 drawables 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 especifique el tema para 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>

Aclamaciones.

Answer 7

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

La implementación como diálogo hace saltar sin demora desde la pantalla de inicio a la IU principal de 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 empieza:

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

Answer 8

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

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

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

Answer 9

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

Implementando una pantalla de bienvenida

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

Así que no usarás un archivo de diseño. En su lugar, especifique el fondo de la pantalla de bienvenida como fondo del tema de la actividad. Para hacer esto, primero cree un dibujable 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 logo en el centro del color de fondo.

Ahora abre styles.xml y agrega este estilo

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

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

Y en el manifiesto, debe configurar SplashTheme para 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 el usuario a la pantalla específica después del inicio utilizando 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 forma correcta de hacerlo. Utilicé estas referencias para la respuesta.

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

Answer 10

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

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

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>

Answer 11

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

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

    <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, uso una variable booleana para registrar el estado de la pantalla de presentación y solo la muestro la primera vez.

   public class SplashActivity extends Activity {
   private static boolean splashLoaded = false;
   @Override
   public void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   if (!splashLoaded) {
   setContentView(R.layout.activity_splash);
   int secondsDelayed = 1;
   new Handler().postDelayed(new Runnable() {
   public void run() {
   startActivity(new Intent(SplashActivity.this, MainActivity.class));
   finish();
   }
   }, secondsDelayed * 500);
   splashLoaded = true;
   }
   else {
   Intent goToMainActivity = new Intent(SplashActivity.this, MainActivity.class);
   goToMainActivity.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
   startActivity(goToMainActivity);
   finish();
   }
   }
   }

feliz codificación!

Answer 12

Otras lecturas:

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

Respuesta antigua:

CÓMO : Pantalla de inicio simple

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

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

 <?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="fill_parent"
android:layout_height="fill_parent">
<ImageView android:id="@+id/splashscreen" android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:src="@drawable/splash"
android:layout_gravity="center"/>
<TextView android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Hello World, splash"/>
</LinearLayout>

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

Answer 13

Por encima de todas las respuestas son realmente muy buenas. Pero hay problemas de fuga de memoria. Este problema a menudo se conoce en la comunidad de Android como "Fuga de una actividad" . Ahora, ¿qué significa eso exactamente?

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

"Fugas en 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 la actividad anterior, ya que se hace being (strong) referenced a un objeto que vivió la instancia de la actividad. Cada aplicación de Android tiene una cantidad específica de memoria asignada para ello. Cuando el recolector de basura no puede liberar memoria no utilizada, el rendimiento de la aplicación disminuirá gradualmente y eventualmente OutOfMemory con el error OutOfMemory .

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

1. Fuga de memoria cuando el usuario cambia la orientación.

Primero debe definir la pantalla de bienvenida en su archivo de presentación de recursos splashscreen.xml

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 más información por favor vaya a este link

Answer 14

Un Splash Screnn, de manera predeterminada, no hace que su aplicación se vea más profesional. 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, ¿cuán profesional será el resto de su aplicación?

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

Dicha pantalla de presentación debe parecerse a su aplicación de pantalla completa para dar la impresión de que ya se ha inicializado, y luego de completar los largos cálculos, se pueden completar los detalles finales (se ha modificado la imagen). 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 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 tiempo o el espacio ocupado por la pantalla de bienvenida se puede gastar en la realización de cálculos previos o en la realización de cálculos. Vea el primer enlace a continuación para conocer los problemas que crea y lo que debe ser considerado.

Si es absolutamente necesario esperar estos cálculos o GPS / WiFi, sería mejor dejar que la aplicación se inicie y tener una ventana emergente que indique que es necesario esperar los cálculos (un mensaje de "Inicialización" TEXTUAL es correcto). Se espera la espera de GPS / WiFi (si aún no estaban habilitados en otro programa), por lo que no es necesario anunciar sus tiempos de espera.

Recuerde que cuando Splash Screen inicia su programa, el 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 deseemos esperar y ver su Pantalla de bienvenida cada vez que iniciemos su Programa o NOSOTROS no sentiremos que está escrito de manera muy profesional. Hacer la pantalla completa de la pantalla de presentación y un duplicado de la pantalla del programa real (por lo que creemos que se inicia 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 en eso.

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

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

Por lo tanto, hay una buena razón para no hacerlo, pero SI está seguro de que, de alguna manera, su situación queda fuera de esos ejemplos, los medios para hacerlo están indicados anteriormente. Asegúrese de que realmente haga que su Aplicación se vea más profesional o que haya rechazado la única razón que dio para hacer esto.

Es como un canal de YouTube que comienza cada video con una introducción gráfica larga (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 de estilos de vida). Solo muestra el show! (Solo ejecuta el programa).

Answer 15

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

Nota: todo el código de abajo 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, establecerá esto como el fondo de su actividad de bienvenida en el tema. Navegue hasta 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 a su XML dibujable. 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 de SplashActivity simplemente lo reenviará 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 viene del tema. Cuando configura la interfaz de usuario para su actividad de inicio en el tema, está disponible de inmediato.

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

Answer 16

Código simple, funciona :) Splash simple

int secondsDelayed = 1;
new Handler().postDelayed(new Runnable() {
public void run() {
startActivity(new Intent(LoginSuccessFull.this, LoginActivity.class));
finish();
}
}, secondsDelayed * 1500);

Answer 17

La parada en la pantalla de inicio de 4''s 5''s no tiene mucho sentido. Está bien si está cargando algo en segundo plano; si no, siga este enfoque para implementar la pantalla de presentación: - Implementar una pantalla de presentación de la manera correcta es un poco diferente de lo que podría imaginar. La vista de bienvenida que ve debe estar lista inmediatamente, incluso antes de que pueda inflar un archivo de diseño en su actividad de bienvenida.

Así que no usarás un archivo de diseño. En su lugar, especifique el fondo de la pantalla de bienvenida como 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, establecerá esto como el fondo de su actividad de bienvenida en el tema. Navegue hasta 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 a su XML dibujable. 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 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();
}
}

Más detalles lea esto: 1. 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

Answer 18

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 abres cualquier aplicación de Android obtendrás por defecto un poco de pantalla negra con el título y el ícono de la aplicación en la parte superior, puedes cambiar eso usando un estilo / tema.

Primero, cree un 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 , puedes usar cualquier otro tema como padre.

Segundo, en tu aplicación Manifest.xml agrega android:theme="@style/splashScreenTheme" a tu 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);
}

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

Answer 19

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

1) Primero cree una Themepantalla de inicio: 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 sin
necesidad de hacer esto en la interfaz de usuario nuevamente.

También puedes usar color aquí en lugar de dibujar.

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.

El inicio de la pantalla de inicio será más rápido y te salvará de la pantalla en negro

También evita el sobregiro extra

Answer 20

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 eslogan, elija su hermoso fondo. cambiar el tamaño a 4096x4096.

• Ahora descargue esa imagen y actualícela a:

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

  Y genera todas las pantallas de bienvenida necesarias, todos los dispositivos, todas las plataformas.

¡Disfrutar!

Hay suficientes respuestas aquí 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 inicio!

Answer 21

Es realmente sencillo 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);
}

Answer 22

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

Answer 23

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

Answer 24

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

Para evitarlo: en el SplashActivitydebe comprobar si SplashActivityestá finalizando o no antes de mover 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

Answer 25

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

Cuando se inicia la aplicación, lo primero que ocurre es que ImageViewse muestra y se elimina la barra de estado al configurar los indicadores de ventana en pantalla completa. Luego utilicé a Handlerpara correr durante 2 segundos, después de los 2 segundos borro las marcas de pantalla completa y configuro la visibilidad del ImageViewa GONE. Fácil, sencillo, eficaz.

Answer 26

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

Saúl Molinero tiene dos opciones diferentes para pantallas de presentación: aprovechar el fondo de la ventana para animar su pantalla inicial y mostrar la UI 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 la hora de inicio en frío y evitar el abandono del usuario debido a los largos tiempos de inicio.

¡Espero que esto ayude!

Answer 27

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

Answer 28

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

Answer 29

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

Answer 30

• Crear una actividad: Splash
• Crear un archivo XML de diseño: splash.xml
• Coloque los componentes de la interfaz de usuario en el diseño de splash.xml para que se vea como desea

• tu Splash.java puede verse así:

  public class Splash extends Activity {
  @Override
  public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.splash);
  int secondsDelayed = 1;
  new Handler().postDelayed(new Runnable() {
  public void run() {
  startActivity(new Intent(Splash.this, ActivityB.class));
  finish();
  }
  }, secondsDelayed * 1000);
  }
  }

• cambie ActivityB.class a la actividad que desee iniciar después de la pantalla de inicio

• revisa tu 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>