Como faço para fazer uma tela inicial?

548

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?

Efraim
fonte
58
Por que um aplicativo parece mais profissional usando uma tela inicial? Não conheço nenhum aplicativo Android 'profissional' que tenha um.
theomega 30/03
7
Concordou com @theomega. As telas de abertura são simplesmente irritantes.
Matt Bola
85
Você só deve exibir uma tela inicial se tiver trabalho de carregamento em segundo plano. Caso contrário, seu aplicativo parecerá mais "profissional" quando você fornecer ao usuário o que ele deseja do seu aplicativo o mais rápido possível. Os usuários percebem (e se incomodam com) atrasos superiores a 100ms, e você está em uma ordem de magnitude acima desse limite adicionando uma tela inicial.
CodeFusionMobile
74
app kindle, aldiko (leitor), golfinho .. Umm o SO :) Todos eles se divertiram. Opera Mobile, Mantan Reader, Mapas. Eu poderia continuar. Se ele oculta uma carga, pelo menos informa ao usuário que seu aplicativo foi iniciado. Um atraso de alguns segundos fica oculto muito melhor quando há pelo menos algo de você na tela.
precisa saber é
9
A tela inicial oferece uma excelente oportunidade para anunciar o nome ou o logotipo da empresa do seu jogo ou aplicativo. Eu gosto de tornar a tela inicial clicável para que o usuário tenha a opção de avançar para o jogo. Se o usuário sempre vir o logotipo da sua empresa por até meio segundo sempre que abrir o aplicativo, será mais provável que você lembre quem você é. Apenas verifique se eles estão tendo uma boa experiência com seu aplicativo.
Chamatake-san 10/05

Respostas:

509

Leitura adicional:

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

Voto a favor
fonte
3
@ user2606414 crie uma pergunta no SO para o seu problema e cole todo o seu log de erros.
Upvote
39
Não se esqueça de adicionar respingos no manifesto
Jawad Zeb
8
@ Peter: a questão não é como mostrar uma tela inicial durante o carregamento de dados.
Aprovado
18
Essa não é uma solução adequada para uma tela inicial, pois o usuário espera para exibir uma tela inicial, no entanto, o objetivo da tela inicial é vice-versa. Ele deve mostrar uma tela inicial enquanto o usuário está aguardando. Por favor, veja a solução da @ Abdullah.
Efeyc
4
Em vez de parar o aplicativo por SPLASH_DISPLAY_LENGTHtempo. Você deve fazer isso em vez disso: bignerdranch.com/blog/splash-screens-the-right-way
miguel.martin
595

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

Abdullah
fonte
3
Parece que o "pai" é suportado apenas na API 14 e acima
user1832478 29/14
103
Este é o caminho certo para fazer uma tela inicial. Obrigado! A resposta com mais votos com atrasos é apenas uma prática ruim. Nada deve atrasar o usuário para ver a primeira tela funcional.
dineth
7
Um problema que tive com isso é que <item name="android:background">iria substituir o windowBackground. E, sem android:backgrounddefinido, meu histórico em qualquer fragmento seria transparente, revelando a atividade por trás do conteúdo em primeiro plano.
William Grand
4
@ Abdullah: Eu segui o caminho que você disse. Funciona bem, mas a tela inicial aparece por alguns milissegundos nas transições de atividade.
Nt.sp 11/11
3
@Abdullah Thanks! Essa seria uma solução possível, no entanto, achei o seguinte: plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd , para evitar a criação de imagens diferentes para cada tamanho de tela, também é possível criar um XML contendo a imagem para que ela pareça bem em todas as telas.
adelriosantiago
52
  • 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>
James
fonte
28
Este não é o objetivo da tela inicial. Isso gera um atraso adicional de 1 segundo. A tela inicial deve ser uma imagem ao carregar a primeira tela do aplicativo. Este link pode ajudar. stackoverflow.com/a/7057332/869451
efeyc
2
@efeyc: você está 100% certo .. ainda assim, parece muito bom quando o aplicativo inicia .. você não acha?
McLan
1
@ Suda.nese definitivamente não. Os usuários não querem olhar para uma foto, os usuários querem usar o aplicativo e não têm um atraso desnecessário
Tim
1
@TimCastelijns Depende do aplicativo em desenvolvimento e como é a tela inicial .. é claro que deve ser prática, mas quem disse que não pode ser usado de outra maneira !!
McLan
6
Concordado @ Suda.nese Se os requisitos do aplicativo incluem uma tela inicial, então é uma tela inicial! Claro, isso pode não ser desejável para os usuários, mas se um cliente quer uma tela de abertura, em seguida, por caramba dar a eles
james
29

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!

zdd
fonte
10
Você pode adicionar android:noHistory="true"em AndroidManifest.xmlpara impedir que o usuário de volta à tela inicial utilizando o botão voltar indo.
Rachel
15

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.
Zeeshan Shabbir
fonte
1
Eu vi um tutorial YouTubesobre isso. Mas acho que o tamanho do bitmap será o problema, já que você não pode redimensioná-lo usando layer-list.
RoCk RoCk
14
  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> 
saba
fonte
13

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

Roubar
fonte
12

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. insira a descrição da imagem aqui

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

Ligade de Maheshwar
fonte
7

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

vicky
fonte
4

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.

awsleiman
fonte
Como eu gostaria de acrescentar um arquivo xml em vez dedrawable
víbora
Quero dizer que você precisará criar bg_splash.xml no diretório drawable, conforme descrito acima.
awsleiman
4

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>
Danny Yassine
fonte
4

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


}
Hitesh Sahu
fonte
4

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.

Abhi Soni
fonte
3
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();
}
kamalasekar
fonte
2

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?

Sankar Ganesh
fonte
2

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

    }

}
kablu
fonte
2

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

    ...
}
tse
fonte
Há um beneficiário para essa abordagem e você pode iniciar o MainActivity diretamente. Por exemplo, quando você usa a notificação por push no seu aplicativo, ao iniciar o aplicativo clicando na notificação, dessa maneira, você pode gerenciar melhor os objetivos da notificação.
Farnad Tohidkhah
2

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();
}
ugur
fonte
2
     - 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>
Ashish Kumar
fonte
Você também pode adicionar alguma explicação, por favor?
Robert
Sim, claro ... que explicação você quer me avise, por favor.
Ashish Kumar
2

Abordagem realmente fácil & gr8:

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!

jony89
fonte
1

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();
    }
  }
}
Joel Teply
fonte
1

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

Phan Van Linh
fonte
1

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

Fusão a frio
fonte
1

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!

w3bshark
fonte
1

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.

Classe A
fonte
1

É 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);
    }
Agilanbu
fonte
1

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

Ankit Singh
fonte
1

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

Rahul Kushwaha
fonte
0

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);
Agilanbu
fonte
0
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();
  }
}
Rishabh Dixit
fonte
Este é um mau exemplo - o que acontece se você sair do SplashActivity pressionando para trás? O thread ainda será executado.
Mark Keen