Como faço para fazer uma tela inicial?

Eu queria fazer meu aplicativo parecer mais profissional, então decidi que queria criar uma tela inicial.

Como eu o criaria e depois o implementaria?

Leitura adicional:

• Hora de lançamento do aplicativo e telas de lançamento temáticas (Android Performance Patterns Season 6 Ep. 4)
• Tela inicial no Android: o caminho certo

Resposta antiga:

COMO : Tela inicial simples

Essas respostas mostram como exibir uma tela inicial por um período fixo de tempo quando o aplicativo é iniciado por, por exemplo, motivos de marca. Por exemplo, você pode optar por mostrar a tela inicial por 3 segundos. No entanto, se você quiser mostrar a tela de spash por um período variável de tempo (por exemplo, tempo de inicialização do aplicativo), verifique a resposta de Abdullah https://stackoverflow.com/a/15832037/401025 . No entanto, esteja ciente de que a inicialização do aplicativo pode ser muito rápida em novos dispositivos, para que o usuário veja apenas um flash com mau UX.

Primeiro você precisa definir a tela de spash no seu layout.xmlarquivo

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

E sua atividade:

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

Isso é tudo ;)

Observe que esta solução não permitirá que o usuário espere mais: o atraso da tela inicial depende do tempo de inicialização do aplicativo.

Ao abrir qualquer aplicativo Android, você terá, por padrão, uma tela preta com o título e o ícone do aplicativo na parte superior, pode alterar isso usando um estilo / tema.

Primeiro, crie um style.xml na pasta values ​​e adicione um estilo a ela.

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

Em vez de usar, @android:style/Theme.DeviceDefault.Light.NoActionBarvocê pode usar qualquer outro tema como pai.

Segundo, no seu aplicativo Manifest.xml, adicione android:theme="@style/splashScreenTheme"à sua atividade principal.

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

Terceiro, atualize seu tema em sua atividade de inicialização onCreate ().

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

ATUALIZAÇÃO Confira este post .

Obrigado a @ mat1h e @adelriosantiago

• Crie uma atividade: Splash
• Crie um arquivo XML de layout: splash.xml
• Coloque os componentes da interface do usuário no layout splash.xml para que fique com a aparência desejada

• seu Splash.java pode ficar assim:

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

• mude ActivityB.classpara a atividade que você deseja iniciar após a tela inicial

• verifique seu arquivo de manifesto e ele deve parecer

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

As respostas acima são muito boas, mas gostaria de acrescentar outra coisa. Eu sou novo no Android, conheci esses problemas durante o meu desenvolvimento. Espero que isso possa ajudar alguém como eu.

1. A tela inicial é o ponto de entrada do meu aplicativo, então adicione as seguintes linhas no 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. A tela inicial deve aparecer apenas uma vez no ciclo de vida do aplicativo, eu uso uma variável booleana para registrar o estado da tela inicial e mostrá-la apenas na primeira 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 codificação!

A resposta de Abdullah é ótima. Mas quero acrescentar mais alguns detalhes com a minha resposta.

Implementando uma tela inicial

A implementação de uma tela inicial da maneira certa é um pouco diferente do que você imagina. A exibição inicial exibida deve estar pronta imediatamente, mesmo antes de você poder aumentar um arquivo de layout em sua atividade inicial.

Portanto, você não usará um arquivo de layout. Em vez disso, especifique o plano de fundo da tela inicial como plano de fundo do tema da atividade. Para fazer isso, primeiro crie um drawable XML em 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>

É apenas uma lista de camadas com o logotipo na cor de fundo do centro.

Agora abra styles.xml e adicione este estilo

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

Este tema terá que barra de ação e com fundo que acabamos de criar acima.

E no manifesto, você precisa definir o SplashTheme para a atividade que deseja 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>

Em seguida, dentro do código de atividade, navegue o usuário para a tela específica após o splash usando a intenção.

public class SplashActivity extends AppCompatActivity {

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

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

Essa é a maneira certa de fazer. Eu usei essas referências para resposta.

1. https://material.google.com/patterns/launch-screens.html
2. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ Obrigado a esses caras por me empurrarem na direção certa. Quero ajudar os outros, porque a resposta aceita não é recomendada para fazer a tela inicial.

1. Criar um 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 vai ser assim

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

Um Splash Screnn, por padrão, não torna automaticamente seu Aplicativo mais profissional. Uma tela inicial projetada profissionalmente tem a possibilidade de tornar seu aplicativo mais profissional, mas se você não sabe escrever um, qual será o nível profissional do restante do aplicativo.

O único motivo (desculpa) para ter uma tela de abertura é porque você está realizando uma grande quantidade de cálculos ou está aguardando a inicialização do GPS / WiFi porque o seu aplicativo depende disso antes de iniciar. Sem o resultado desses cálculos ou acesso ao GPS / WiFi (etc.), seu aplicativo está morto na água, assim você sente que precisa de uma tela inicial e DEVE bloquear a visualização da tela para quaisquer outros programas em execução (incluindo o plano de fundo )

Essa tela inicial deve se parecer com o seu aplicativo de tela cheia para dar a impressão de que já foi inicializado; depois que os cálculos demorados forem concluídos, os detalhes finais poderão ser preenchidos (a imagem foi aprimorada). A chance de que isso aconteça ou que seja a única maneira de o Programa ser concebido é muito pequena .

Seria melhor permitir que o usuário (e o restante do sistema operacional) fizesse outra coisa enquanto espera, em vez de projetar seu programa para depender de algo que levará um tempo (quando a duração da espera for incerta).

Já existem ícones no seu telefone que indicam que o GPS / WiFi está sendo iniciado. O tempo ou espaço ocupado pela tela inicial pode ser gasto carregando pré-cálculos ou realmente fazendo os cálculos. Veja o primeiro link abaixo para os problemas que você cria e o que deve ser considerado.

Se você absolutamente precisar aguardar esses cálculos ou GPS / WiFi, seria melhor simplesmente iniciar o aplicativo e exibir uma janela pop-up indicando que é necessário aguardar os cálculos (uma mensagem TEXTUAL de "Inicialização" está correta). A espera por GPS / WiFi é esperada (se já não estiver ativada em outro programa), portanto, anunciar os tempos de espera é desnecessário.

Lembre-se de que quando a tela inicial inicia, o programa já está em execução, tudo o que você está fazendo é atrasar o uso do programa e monopolizar a CPU / GPU para fazer algo que a maioria não considera necessário.

É melhor que realmente desejemos esperar e ver sua tela inicial toda vez que iniciarmos o seu programa, ou NÃO sentiremos que é muito profissionalmente escrito. Tornar a tela inicial tela cheia e uma duplicata da tela do programa real (então achamos que ela foi inicializada quando na verdade não foi) PODE atingir seu objetivo (tornar o programa mais profissional), mas eu não apostaria muito nisso.

Por que não fazê-lo: http://cyrilmottier.com/2012/05/03/splash-screens-are-evil-dont-use-them/

Como fazer: https://encrypted.google.com/search?q=Android+splash+screen+source

Portanto, há uma boa razão para não fazê-lo, mas se você tiver certeza de que, de alguma forma, sua situação está fora desses exemplos, os meios para fazê-lo são dados acima. Certifique-se de que realmente faz seu aplicativo parecer mais profissional ou você derrotou o único motivo que você deu para fazer isso.

É como um canal do YouTube que inicia todos os vídeos com uma introdução gráfica longa (e Outro) ou sente a necessidade de contar uma piada ou explicar o que aconteceu durante a semana passada (quando não é um canal de comédia ou de estilo de vida). Apenas mostre o show! (Basta executar o programa).

Acima de todas as respostas são realmente muito boas. Mas existem problemas de vazamento de memória. Esse problema geralmente é conhecido na comunidade Android como "Vazando uma atividade" . Agora, o que exatamente isso significa?

Quando ocorre uma alteração na configuração, como mudança de orientação, o Android destrói a Atividade e a recria. Normalmente, o Garbage Collector apenas limpa a memória alocada da instância antiga da Activity e estamos todos bem.

"Vazando uma atividade" refere-se à situação em que o Garbage Collector não pode limpar a memória alocada da instância antiga da Activity, pois é being (strong) referencedde um objeto que viveu fora da instância da Activity. Todo aplicativo Android tem uma quantidade específica de memória alocada para ele. Quando o Garbage Collector não pode liberar memória não utilizada, o desempenho do aplicativo diminui gradualmente e, eventualmente, trava com OutOfMemoryerro.

Como determinar se o aplicativo vaza memória ou não? A maneira mais rápida é abrir a guia Memória no Android Studio e preste atenção à memória alocada conforme você altera a orientação. Se a memória alocada continuar aumentando e nunca diminuir, haverá um vazamento de memória.

Vazamento 1.Memory quando o usuário muda a orientação.

Primeiro, você precisa definir a tela inicial no splashscreen.xmlarquivo de recursos de layout

Código de amostra para a atividade da tela inicial.

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 mais informações, acesse este link

A tela Parando na tela inicial para os 4 e 5 desnecessariamente não faz muito sentido. Tudo bem se você carregar algo em segundo plano, caso contrário, siga esta abordagem para implementar a tela inicial: - A implementação de uma tela inicial da maneira correta é um pouco diferente do que você imagina. A exibição inicial que você vê precisa estar pronta imediatamente, mesmo antes que você possa aumentar um arquivo de layout em sua atividade inicial.

Portanto, você não usará um arquivo de layout. Em vez disso, especifique o plano de fundo da tela inicial como plano de fundo do tema da atividade. Para fazer isso, primeiro, crie um drawable XML em 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>

Aqui, configurei uma cor de fundo e uma imagem.

Em seguida, você definirá isso como plano de fundo da sua atividade inicial no tema. Navegue até o arquivo styles.xml e adicione um novo tema para sua atividade inicial:

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

No seu novo SplashTheme, defina o atributo background da janela como seu drawable XML. Configure isso como o tema da sua atividade inicial no seu 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 fim, a classe SplashActivity deve encaminhar você para a sua atividade 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();
    }
}

Mais detalhes leia isto: 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 é o código completo aqui

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

Nos drawables, crie 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>

No styles.xml, crie um tema personalizado

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

e, finalmente, no AndroidManifest.xml, especifique o tema para sua atividade

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

Felicidades.

As telas iniciais não devem ser carregadas de um arquivo de layout; ainda pode haver algum atraso ao carregá-lo.

A melhor maneira é criar um tema apenas para o seu SplashScreenActivity e definir the android:windowBackgroundum recurso desenhável.

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

Em poucas palavras:

Declare sua SplashScreenActivity no manifesto:

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

No seu SplashScreenActivity.java:

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

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

}

Em seguida, crie o recurso para a janela de plano de fundo do seu tema:

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

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

Após o Android Marshmallow , outro uso produtivo da tela inicial que eu penso é a solicitação necessáriaAndroid Permissions na tela inicial do seu aplicativo.

parece que a maioria dos aplicativos processa solicitações de permissão dessa maneira.

• Os diálogos produzem um UIX ruim e interrompem o fluxo principal e fazem você decidir sobre o tempo de execução, e a verdade é que a maioria dos usuários pode nem se importar se seu aplicativo deseja escrever algo no cartão SD. Alguns deles podem nem entender o que estamos tentando transmitir até traduzi-lo para o inglês comum.

• Solicitar permissões de uma vez gera menos número de "se houver" antes de cada operação e faz com que seu código pareça desorganizado.

Este é um exemplo de como você pode solicitar permissões na sua atividade inicial para o dispositivo com Android OS 23+.

Se todas as permissões forem concedidas OU já concedidas OU o aplicativo estiver sendo executado no Pre Marshmallow, ENTÃO, basta exibir o conteúdo principal com pouco atraso de meio segundo para que o usuário possa apreciar o esforço que fizemos ao ler esta pergunta e tentar dar o nosso melhor.

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


}

você não usará um arquivo de layout. Em vez disso, especifique o plano de fundo da tela inicial como plano de fundo do tema da atividade. Para fazer isso, primeiro crie um drawable XML em res / drawable.

Nota: todo o código abaixo está disponível no 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>

Aqui, configurei uma cor de fundo e uma imagem.

Em seguida, você definirá isso como plano de fundo da sua atividade inicial no tema. Navegue até o arquivo styles.xml e adicione um novo tema para sua atividade inicial:

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

No seu novo SplashTheme, defina o atributo background da janela como seu drawable XML. Configure isso como o tema da sua atividade inicial no seu 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 fim, sua classe SplashActivity deve encaminhar você para a sua atividade 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 você nem configurou uma exibição para esta SplashActivity. A visão vem do tema. Quando você configura a interface do usuário para sua atividade inicial no tema, ela fica disponível imediatamente.

Se você tivesse um arquivo de layout para a sua atividade inicial, esse arquivo de layout ficaria visível para o usuário somente depois que o aplicativo fosse totalmente inicializado, o que é muito tarde. Você deseja que o splash seja exibido apenas nessa pequena quantidade de tempo antes que o aplicativo seja inicializado.

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

Crie uma atividade, deixe-nos a atividade denominada 'A', crie um arquivo xml chamado myscreen.xml, que defina a imagem da tela inicial como plano de fundo e use o temporizador para navegar de uma atividade para outra. Para saber como usar o temporizador de contagem regressiva, veja minha resposta nesta pergunta TimerTask no Android?

Exemplo de tela inicial:

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

    }

}

A tela inicial é um pequeno objeto inutilizável no Android: não pode ser carregada o mais rápido possível para ocultar o atraso do início da atividade principal. Há duas razões para usá-lo: operações de publicidade e rede.

A implementação como caixa de diálogo dá um salto sem demora da tela inicial para a interface principal da atividade.

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

    }
}

Layout:

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

E comece:

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

    ...
}

Outra abordagem é alcançada usando o 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>

Abordagem realmente fácil & gr8:

• Primeiro, crie seu splash com o seguinte site:

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

  Escolha seu logotipo e slogan, escolha seu plano de fundo bonito. redimensione para 4096x4096.

• Agora baixe essa imagem e a atualize para:

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

  E gere todas as telas de apresentação necessárias, todos os dispositivos, todas as plataformas.

Aproveitar!

Aqui existem respostas suficientes que ajudarão na implementação. este post foi criado para ajudar outras pessoas com a primeira etapa da criação da tela inicial!

Que tal uma tela de inicialização super flexível que possa usar o mesmo código e esteja definida no AndroidManifest.xml, para que o código nunca precise ser alterado. Geralmente desenvolvo bibliotecas de código e não gosto de personalizar o código porque é desleixado.

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

Em seguida, o próprio SpashActivity pesquisa os metadados para "launch_class" para criar o próprio Intent. A "duração" dos metadados define por quanto tempo a tela inicial permanece ativa.

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

Em algum momento, o usuário abre SplashActivitye sai imediatamente, mas o aplicativo ainda é utilizado MainActivitydepois SPLASH_SCREEN_DISPLAY_LENGTH.

Para evitá-lo: SplashActivityvocê deve verificar se SplashActivityestá terminando ou não antes de passar paraMainActivity

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

Embora haja boas respostas, mostrarei a maneira recomendada pelo Google:

1) Primeiro crie uma Themetela inicial: você tem um tema chamado splashscreenTheme, seu tema do iniciador seria:

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

Nota:

android:windowBackgroundjá define sua imagem da tela inicial, não é
necessário fazer isso na interface do usuário novamente.

você também pode usar cores aqui em vez de um drawable.

2) Defina o tema como manifesto da tela de abertura

   <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) verifique se launch_screen drawablenão está na drawablepasta se a sua imagem não for pequena.

Isso resultará em um início mais rápido da tela de inicialização e salvará você da tela preta

Também evita o excesso de extração

Este é o melhor post que eu já vi nas telas de abertura: http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero entra em duas opções diferentes para telas de abertura: aproveitando o plano de fundo da janela para animar sua tela inicial e exibindo a interface do usuário do marcador de posição (que é uma escolha popular que o Google usa para a maioria dos aplicativos atualmente).

Refiro-me a este post toda vez que preciso considerar o tempo de inicialização a frio e evitar a desistência do usuário devido a longos períodos de inicialização.

Espero que isto ajude!

No meu caso, não queria criar uma nova atividade apenas para mostrar uma imagem por 2 segundos. Ao iniciar MainAvtivity, as imagens são carregadas nos suportes usando o picasso, eu sei que isso leva cerca de 1 segundo para carregar, então decidi fazer o seguinte na minha 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);

Ao iniciar o aplicativo, a primeira coisa que acontece é a ImageViewexibição e a barra de status é removida configurando os sinalizadores de janela para tela cheia. Em seguida, usei a Handlerpara executar por 2 segundos, após os 2 segundos, limpei os sinalizadores de tela cheia e defino a visibilidade de ImageViewpara GONE. Fácil, simples, eficaz.

É realmente simples no Android, apenas usamos o conceito de manipulador para implementar a tela inicial

No seu arquivo java SplashScreenActivity, cole esse código.

No seu arquivo xml SplashScreenActivity, coloque qualquer imagem usando o 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);
    }

Você pode adicionar isso no seu 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 inicialize seu valor de tempo em milissegundos conforme você deseja ...

private  static int time=5000;

para obter mais detalhes, faça o download do código completo neste link ...

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

No Kotlin, escreva este código: -

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

Espero que isso ajude você.Obrigado ........

Código simples, funciona :) Respingo simples

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