Jak zrobić ekran powitalny?

Uwaga To rozwiązanie nie pozwoli użytkownikowi czekać dłużej: opóźnienie ekranu powitalnego zależy od czasu uruchomienia aplikacji.

Po otwarciu dowolnej aplikacji na Androida domyślnie otrzymasz czarny ekran z tytułem i ikoną aplikacji na górze, możesz to zmienić za pomocą stylu / motywu.

Najpierw Utwórz styl.xml w folderze values i dodaj do niego styl.

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

Zamiast @android:style/Theme.DeviceDefault.Light.NoActionBar możesz użyć dowolnego innego motywu jako rodzic.

Po drugie, w manifeście aplikacji.XML dodaj android:theme="@style/splashScreenTheme" do głównej aktywności.

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

Po Trzecie, Zaktualizuj swój motyw w aktywności uruchamiania onCreate ().

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

UPDATE Sprawdź ten post https://plus.google.com / + AndroidDevelopers/posts / z1wwainpjhd Dzięki @mat1h i @ adelriosantiago

• Utwórz działanie: Splash
• Utwórz plik XML układu: splash.xml
• Umieść elementy interfejsu w splash.układ xml więc wygląda tak jak chcesz

• Twój Plusk.java może wyglądać tak:

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

• Zmień ActivityB.class na aktywność, którą chcesz rozpocząć po ekranie powitalnym

• Sprawdź swój plik manifest i powinien wyglądać jak

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

@ Abdullah odpowiedź jest poprawna, jednak Google zamieściło rozszerzone wyjaśnienie, jak prawidłowo to wdrożyć bez zmiany tematu twojej aktywności:

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

Aplikacje takie jak Google Maps i YouTube zaczęły używać tej samej metody.

Powyższe odpowiedzi są bardzo dobre, ale chciałbym dodać coś jeszcze. Jestem nowy w Androidzie, spotkałem się z tymi problemami podczas mojego rozwoju. mam nadzieję, że to pomoże komuś takiemu jak ja.

1. Ekran powitalny jest punktem wejścia mojej aplikacji, więc dodaj następujące linie w 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. Ekran powitalny powinien pokazać się tylko raz w cyklu życia aplikacji, używam zmiennej logicznej, aby zapisać stan ekranu powitalnego i pokazać go tylko na pierwszym czas.

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

1. Create an 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 będzie tak

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

Splash Screnn domyślnie nie sprawia, że aplikacja wygląda bardziej profesjonalnie. Profesjonalnie zaprojektowany ekran powitalny ma możliwość, aby Twoja aplikacja wyglądała bardziej profesjonalnie, ale jeśli nie wiesz, jak go napisać, to jak profesjonalna będzie reszta Twojej aplikacji.

O jedynym powodem (wymówką), aby mieć ekran powitalny, jest to, że wykonujesz ogromną ilość obliczeń lub czekasz na uruchomienie GPS/WiFi, ponieważ twój Aplikacja opiera się na tym przed jego uruchomieniem. Bez wyniku tych obliczeń lub dostępu do GPS / WiFi (itp.) Twoja aplikacja jest martwa w wodzie, więc czujesz, że potrzebujesz ekranu powitalnego i musisz zablokować widok Ekranu dla innych uruchomionych programów (w tym tła).

Taki ekran powitalny powinien wyglądać jak aplikacja pełnoekranowa, aby sprawiać wrażenie, że jest już zainicjowany, a następnie po długich obliczeniach zostaną zakończone ostateczne szczegóły może być wypełniony (obraz podrasowany). Szansa na to, że tak jest lub że jest to jedyny sposób na zaprojektowanie programu jest bardzo mała .

Byłoby lepiej pozwolić użytkownikowi (i reszcie systemu operacyjnego) zrobić coś innego podczas oczekiwania, a nie zaprojektować program tak, aby był zależny od czegoś, co zajmie trochę czasu(gdy czas oczekiwania jest niepewny).

W telefonie są już ikony, które mówią, że GPS / WiFi się uruchamia. Na czas lub miejsce zajęte przez ekran powitalny można poświęcić na ładowanie wstępnych obliczeń lub faktycznie wykonywanie obliczeń. Zobacz pierwszy Link poniżej dla problemów, które tworzysz i co należy wziąć pod uwagę.

Jeśli koniecznie musisz poczekać na te obliczenia lub GPS / WiFi, najlepiej byłoby po prostu pozwolić aplikacji na uruchomienie i mieć wyskakujące okienko z informacją, że należy poczekać na obliczenia (tekstowy komunikat "inicjalizacji" jest w porządku). Oczekiwane jest oczekiwanie na GPS/WiFi (gdyby były nie włączone już w innym programie), więc ogłaszanie czasu oczekiwania jest zbędne.

Pamiętaj, że po uruchomieniu ekranu powitalnego Twój Program jest już uruchomiony, wszystko co robisz, to opóźnianie korzystania z programu i blokowanie procesora / GPU, aby zrobić coś, co większość nie uważa za konieczne.

Lepiej poczekać i zobaczyć Twój ekran powitalny za każdym razem, gdy uruchamiamy Twój Program, bo nie będziemy czuć, że jest on bardzo profesjonalnie napisany. Making the Splash Ekran Pełny ekran i duplikat rzeczywistego ekranu programu (więc uważamy, że jest on zainicjowany, gdy w rzeczywistości nie ma) może osiągnąć swój cel (aby Twój Program wyglądał bardziej profesjonalnie), ale nie postawiłbym na to zbyt wiele.

Dlaczego tego nie robić: http://cyrilmottier.com/2012/05/03/splash-screens-are-evil-dont-use-them/

Jak to zrobić: https://encrypted.google.com/search?q=Android+splash+screen + source

Więc jest dobry powód, aby nie robić ale jeśli jesteś pewien, że w jakiś sposób Twoja sytuacja wypada poza te przykłady, to środki, aby to zrobić, podano powyżej. Upewnij się, że naprawdę sprawia, że aplikacja wygląda bardziej profesjonalnie lub pokonałeś jedyny powód, dla którego to zrobiłeś.

To jest jak Kanał na YouTube, który zaczyna każdy film od długiego graficznego Intro (i Outro) lub czuje potrzebę opowiedzenia żartu lub wyjaśnienia, co wydarzyło się w ciągu ostatniego tygodnia (kiedy nie jest to kanał komediowy lub LifeStyles). Just Pokaż program ! (Wystarczy uruchomić Program).

Przede wszystkim odpowiedzi są naprawdę bardzo dobre. Ale występują problemy wycieku pamięci. Ten problem jest często znany w społeczności Androida jako "wyciekanie aktywności" . Co to dokładnie znaczy?

Gdy nastąpi zmiana konfiguracji, na przykład zmiana orientacji, Android niszczy aktywność i odtwarza ją. Zwykle Garbage Collector wyczyści przydzieloną pamięć starej instancji Activity i wszystko będzie dobrze.

"Leaking an Activity " odnosi się do sytuacji, w której Garbage Collector nie może wyczyścić przydzielonej pamięci starej instancji Activity, ponieważ jest ona being (strong) referenced z obiektu, który zamieszkiwał instancję Activity. Każda aplikacja na Androida ma przydzieloną określoną ilość pamięci. Gdy Garbage Collector nie może zwolnić nieużywanej pamięci, wydajność aplikacji będzie stopniowo spadać i ostatecznie zawiesi się z błędem OutOfMemory.

Jak określić, czy aplikacja wycieka pamięć, czy nie? Najszybszym sposobem jest otwarcie karta pamięci w Android Studio i zwróć uwagę na przydzieloną pamięć podczas zmiany orientacji. Jeśli przydzielona pamięć rośnie i nigdy nie maleje, to masz wyciek pamięci.

1.Wyciek pamięci po zmianie orientacji przez użytkownika.

Najpierw musisz zdefiniować ekran powitalny w swoim zasobie układu splashscreen.xml Plik

Przykładowy kod aktywności ekranu powitalnego.

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

Aby uzyskać więcej informacji, przejdź do tego link

Odpowiedź Abdullaha jest świetna. Ale chcę dodać do niego więcej szczegółów z moją odpowiedzią.

Implementacja ekranu powitalnego

Implementacja ekranu powitalnego we właściwy sposób jest trochę inna, niż możesz sobie wyobrazić. Widok splash, który widzisz, musi być gotowy natychmiast, nawet zanim będziesz mógł nadmuchać plik układu w swojej aktywności splash.

Więc nie będziesz używać pliku układu. Zamiast tego określ tło ekranu powitalnego jako tło motywu działania. Aby to zrobić, najpierw Utwórz XML drawable w 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>

To tylko lista warstw z logo w środku koloru tła z nim.

Teraz otwórz style.xml i dodaj ten styl

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

Ten temat będzie musiał actionbar i z tłem, które właśnie stworzyliśmy powyżej.

I w manifeście musisz ustawić splashtheme na aktywność, którą chcesz użyć jako 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>

Następnie wewnątrz kodu aktywności Nawiguj użytkownika do konkretnego ekranu po splash za pomocą intent.

public class SplashActivity extends AppCompatActivity {

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

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

1. https://material.google.com/patterns/launch-screens.html
2. https://www.bignerdranch.com/blog/splash-screens-the-right-way / Dzięki tym gościom za popchnięcie mnie we właściwym kierunku. Chcę pomagać innym, ponieważ akceptowana odpowiedź nie jest zalecanym do zrobienia ekranu powitalnego.

To jest pełny kod tutaj

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

W drawables Utwórz 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>

W stylach.XML utwórz własny motyw

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

I wreszcie w AndroidManifest.XML określ motyw do swojej aktywności

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

Ekrany powitalne nie powinny być ładowane z pliku układu, nadal mogą występować pewne opóźnienia podczas ładowania.

Najlepszym sposobem jest stworzenie motywu tylko dla SplashScreenActivity i ustawić the android:windowBackground na drawable ressource.

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

W skrócie:

Zadeklaruj swoją aktywność Splashscreen w manifeście:

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

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

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

}

Następnie utwórz ressource dla okna tła Twojego motywu:

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

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

Po Androidzie Marshmallow inne produktywne wykorzystanie ekranu powitalnego, o którym myślę, to Prośba o niezbędne Android Permissions na ekranie powitalnym aplikacji.

Wygląda na to, że większość aplikacji obsługuje żądania uprawnień w ten sposób.

• Okna dialogowe sprawiają, że zły interfejs użytkownika i łamią główny przepływ i sprawiają, że decydujesz o uruchomieniu, a prawda jest taka, że większość użytkowników może nawet nie dbać o to, czy Twoja aplikacja chce coś napisać na karcie SD. Niektórzy z nich mogą nawet nie zrozumieć, co próbujemy aby przekazać, dopóki nie przetłumaczymy go na angielski.

• Prośba o uprawnienia w jednym czasie zrób mniejszą liczbę "if else" przed każdą operacją i spraw, aby Twój kod wyglądał na wolny od bałaganu.

To jest przykład, jak możesz poprosić o uprawnienia w aktywności splash dla Urządzenia z systemem Android OS 23+ .

Jeśli wszystkie uprawnienia są przyznane lub już przyznane lub aplikacja działa na Pre Marshmallow to po prostu idź i wyświetl główną zawartość z małym opóźnieniem o połowę po drugie, aby użytkownik mógł docenić wysiłek, który włożyliśmy w przeczytanie tego pytania i staramy się dać z siebie wszystko.

import android.Manifest;
import android.annotation.TargetApi;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.widget.Toast;

import com.c2h5oh.beer.R;
import com.c2h5oh.beer.utils.Animatrix;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SplashActivity extends AppCompatActivity {

    final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.splash);

        //show animations 
        Animatrix.scale(findViewById(R.id.title_play), 100);
        Animatrix.scale(findViewById(R.id.title_edit), 100);
        Animatrix.scale(findViewById(R.id.title_record), 100);
        Animatrix.scale(findViewById(R.id.title_share), 100);

        if (Build.VERSION.SDK_INT >= 23) {

            // Marshmallow+ Permission APIs
            fuckMarshMallow();

        } else {

            // Pre-Marshmallow
            ///Display main contents
            displaySplashScreen();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        switch (requestCode) {
            case REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS: {
                Map<String, Integer> perms = new HashMap<String, Integer>();
                // Initial
                perms.put(Manifest.permission.READ_EXTERNAL_STORAGE, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.RECORD_AUDIO, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.MODIFY_AUDIO_SETTINGS, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.VIBRATE, PackageManager.PERMISSION_GRANTED);
                // Fill with results
                for (int i = 0; i < permissions.length; i++)
                    perms.put(permissions[i], grantResults[i]);

                // Check for ACCESS_FINE_LOCATION
                if (perms.get(Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
                        && perms.get(Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
                        && perms.get(Manifest.permission.MODIFY_AUDIO_SETTINGS) == PackageManager.PERMISSION_GRANTED
                        && perms.get(Manifest.permission.VIBRATE) == PackageManager.PERMISSION_GRANTED) {
                    // All Permissions Granted

                    // Permission Denied
                    Toast.makeText(SplashActivity.this, "All Permission GRANTED !! Thank You :)", Toast.LENGTH_SHORT)
                            .show();

                    displaySplashScreen();

                } else {
                    // Permission Denied
                    Toast.makeText(SplashActivity.this, "One or More Permissions are DENIED Exiting App :(", Toast.LENGTH_SHORT)
                            .show();

                    finish();
                }
            }
            break;
            default:
                super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
    }


    @TargetApi(Build.VERSION_CODES.M)
    private void fuckMarshMallow() {
        List<String> permissionsNeeded = new ArrayList<String>();

        final List<String> permissionsList = new ArrayList<String>();
        if (!addPermission(permissionsList, Manifest.permission.READ_EXTERNAL_STORAGE))
            permissionsNeeded.add("Read SD Card");
        if (!addPermission(permissionsList, Manifest.permission.RECORD_AUDIO))
            permissionsNeeded.add("Record Audio");
        if (!addPermission(permissionsList, Manifest.permission.MODIFY_AUDIO_SETTINGS))
            permissionsNeeded.add("Equilizer");
        if (!addPermission(permissionsList, Manifest.permission.VIBRATE))
            permissionsNeeded.add("Vibrate");

        if (permissionsList.size() > 0) {
            if (permissionsNeeded.size() > 0) {

                // Need Rationale
                String message = "App need access to " + permissionsNeeded.get(0);

                for (int i = 1; i < permissionsNeeded.size(); i++)
                    message = message + ", " + permissionsNeeded.get(i);

                showMessageOKCancel(message,
                        new DialogInterface.OnClickListener() {

                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                                        REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
                            }
                        });
                return;
            }
            requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                    REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
            return;
        }

        Toast.makeText(SplashActivity.this, "No new Permission Required- Launching App .You are Awesome!!", Toast.LENGTH_SHORT)
                .show();

        displaySplashScreen();
    }


    private void showMessageOKCancel(String message, DialogInterface.OnClickListener okListener) {
        new AlertDialog.Builder(SplashActivity.this)
                .setMessage(message)
                .setPositiveButton("OK", okListener)
                .setNegativeButton("Cancel", null)
                .create()
                .show();
    }

    @TargetApi(Build.VERSION_CODES.M)
    private boolean addPermission(List<String> permissionsList, String permission) {

        if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
            permissionsList.add(permission);
            // Check for Rationale Option
            if (!shouldShowRequestPermissionRationale(permission))
                return false;
        }
        return true;
    }

    /**
     * Display main content with little delay just so that user can see
     * efforts I put to make this page
     */
    private void displaySplashScreen() {
        new Handler().postDelayed(new Runnable() {

        /*
         * Showing splash screen with a timer. This will be useful when you
         * want to show case your app logo / company
         */

            @Override
            public void run() {
                startActivity(new Intent(SplashActivity.this, AudioPlayerActivity.class));
                finish();
            }
        }, 500);
    }


}

public class MainActivity extends Activity {

@Override

public void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    Thread t=new Thread()
    {

        public void run()
        {   

            try {

                sleep(2000);
                finish();
                Intent cv=new Intent(MainActivity.this,HomeScreen.class/*otherclass*/);
                startActivity(cv);
            } 

            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    t.start();
}

Nie będziesz używać pliku układu. Zamiast tego określ tło ekranu powitalnego jako tło motywu działania. Aby to zrobić, najpierw Utwórz XML drawable w res / drawable.

Uwaga: wszystkie poniższe kody są dostępne 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>

Następnie ustawisz to jako tło twojej aktywności splash w temacie. Przejdź do stylów.plik xml i dodaj nowy motyw do swojego splasha aktywność:

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

W nowym SplashTheme, ustaw atrybut tła okna na XML drawable. Skonfiguruj to jako motyw aktywności splash w 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>

Wreszcie, Klasa SplashActivity powinna po prostu przesunąć Cię do głównej aktywności:

public class SplashActivity extends AppCompatActivity {

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

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

Zauważ, że nawet nie skonfigurowałeś widoku dla tej SplashActivity. Widok pochodzi z tematu. Po skonfigurowaniu interfejsu użytkownika dla aktywności splash w motywie jest on dostępny natychmiast.

Jeśli Masz plik układu dla swojej aktywności splash, ten plik układu będzie widoczny dla użytkownika dopiero po pełnej inicjalizacji aplikacji, co jest za późno. Chcesz, aby splash był wyświetlany tylko w tak krótkim czasie, zanim aplikacja zostanie zainicjowana.

Utwórz aktywność, pozwól nam aktywność o nazwie 'A', a następnie utwórz plik xml o nazwie myscreen.xml, w którym Ustaw obraz ekranu powitalnego jako tło, a następnie użyj count down timer, aby przejść od jednej Activtity do drugiej. Aby dowiedzieć się, jak korzystać z odliczania timera, zobacz moją odpowiedź na to pytanie TimerTask w Androidzie?

Przykład ekranu powitalnego:

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

    }

}

Ekran powitalny to trochę bezużyteczny obiekt w Androidzie: nie można go załadować tak szybko, jak to możliwe, aby ukryć opóźnienie rozpoczęcia głównej aktywności. Istnieją dwa powody, aby z niego korzystać: Reklama i operacje sieciowe.

Implementacja jako dialog sprawia, że skok bez opóźnienia z ekranu powitalnego do głównego interfejsu użytkownika aktywności.

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

    }
}

Układ:

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

I początek:

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

    ...
}

Zatrzymywanie się na ekranie powitalnym dla 4 'S 5' s niepotrzebnie nie ma większego sensu. Jest Ok, jeśli ładujesz coś w tle, postępuj zgodnie z tym podejściem, aby zaimplementować ekran powitalny: - Wdrożenie ekranu powitalnego we właściwy sposób jest trochę inne, niż możesz sobie wyobrazić. Widok splash, który widzisz, musi być gotowy natychmiast, nawet zanim będziesz mógł nadmuchać plik układu w swojej aktywności splash.

Więc nie będziesz używać pliku układu. Zamiast tego określ swój splash tło ekranu jako tło motywu działania. Aby to zrobić, najpierw Utwórz XML drawable w 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>

Następnie ustawisz to jako tło twojej aktywności splash w temacie. Przejdź do stylów.plik xml i dodaj nowy motyw dla swojej aktywności splash:

<resources>

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

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

</resources>

W nowym SplashTheme, ustaw atrybut tła okna na XML drawable. Skonfiguruj to jako motyw aktywności splash w Twoim 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>

Wreszcie Klasa SplashActivity powinna po prostu przesunąć Cię do głównej aktywności:

     public class SplashActivity extends AppCompatActivity {

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

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

Więcej szczegółów przeczytaj to: 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

Co powiesz na super-elastyczny ekran startowy, który może używać tego samego kodu i jest zdefiniowany w AndroidManifest.xml, więc kod nigdy nie będzie musiał się zmieniać. Generalnie rozwijam biblioteki kodu i nie lubię dostosowywania kodu, ponieważ jest niechlujny.

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

Następnie sama SpashActivity wyszukuje meta-dane dla "launch_class", aby następnie zrobić intencję. Metadane "czas trwania" określają, jak długo ekran powitalny pozostaje aktywny.

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

Inną metodą jest użycie 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();
}

Czasami użytkownik otwiera SplashActivity i natychmiast kończy, ale aplikacja nadal przechodzi do MainActivity po SPLASH_SCREEN_DISPLAY_LENGTH.

Aby zapobiec: w SplashActivity należy sprawdzić, czy SplashActivity kończy się czy nie przed przejściem do MainActivity

public class SplashActivity extends Activity {

    private final int SPLASH_SCREEN_DISPLAY_LENGTH = 2000;

    @Override
    public void onCreate(Bundle icicle) {
        ...
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {

                if (!isFinishing()) {//isFinishing(): If the activity is finishing, returns true; else returns false.
                    startActivity(new Intent(SplashActivity.this, MainActivity.class));
                    finish();
                }

            }, SPLASH_SCREEN_DISPLAY_LENGTH);
        }                             
   }                                
}

Hope this help

Chociaż są dobre odpowiedzi, pokażę google zalecany sposób:

1)najpierw Utwórz Theme dla ekranu powitalnego: masz motyw o nazwie splashscreenTheme, twój motyw launchera będzie:

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

Uwaga:

android:windowBackground ustawia już obrazek splashscreen nr
trzeba to zrobić ponownie w interfejsie użytkownika.

Możesz również użyć koloru zamiast rysowalnego.

2) Ustaw temat na manifest splashscreenActivity

   <activity
            android:name=".activity.splashscreenActivity"
            android:screenOrientation="portrait"
            android:theme="@style/splashscreenTheme">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

3) Upewnij się, że launch_screen drawable jest Nie w folderze drawable, jeśli obraz nie jest mały.

Spowoduje to szybsze uruchomienie ekranu startowego i uratowanie cię z czarnego ekranu

Pozwala również uniknąć dodatkowego przeciążenia

To jest najlepszy post jaki widziałem na ekranach powitalnych: http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero oferuje dwie różne opcje ekranów powitalnych: wykorzystanie tła okna do animowania na ekranie początkowym i wyświetlanie interfejsu zastępczego (który jest popularnym wyborem, którego Google używa obecnie w większości swoich aplikacji).

Odnoszę się do tego posta za każdym razem, gdy muszę wziąć pod uwagę zimny czas rozpoczęcia i unikanie porzucenia użytkownika z powodu długie czasy uruchamiania.

Mam nadzieję, że to pomoże!

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

Prosty kod, działa:) Simple splash

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

public class SplashActivity extends Activity {

  Context ctx;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      ctx = this;
      setContentView(R.layout.activity_splash);

      Thread thread = new Thread(){
          public void run(){
              try {
                  sleep(3000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }

              Intent in = new Intent(ctx,MainActivity.class);
              startActivity(in);
              finish();
          }
      };
      thread.start();
  }
}

W moim przypadku nie chciałem tworzyć nowej aktywności tylko po to, aby pokazać obraz przez 2 sekundy. Podczas uruchamiania mojego MainAvtivity, obrazy ładowane są do uchwytów za pomocą Picassa, wiem, że ładowanie trwa około 1 sekundy, więc postanowiłem wykonać następujące czynności wewnątrz mojej głównej aktywności 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);

Podczas uruchamiania aplikacji pierwszą rzeczą, która się dzieje, jest wyświetlenie ImageView i usunięcie paska stanu poprzez ustawienie FLAG okna na Pełny ekran. Następnie użyłem Handler, aby uruchomić przez 2 sekundy, po 2 sekundy czyszczę flagi pełnoekranowe i ustawiam Widoczność ImageView na GONE. Łatwe, proste, skuteczne.

Użyłem wątków, aby zrobić ekran Flash w Androidzie.

    import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;

public class HomeScreen extends AppCompatActivity{
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.screen_home);

        Thread thread = new Thread(){
            public void run(){
                try {
                    Thread.sleep(3 * 1000);
                    Intent i = new Intent(HomeScreen.this, MainActivity.class);
                    startActivity(i);
                } catch (InterruptedException e) {
                }
            }
        };
        thread.start();
    }
}

To naprawdę proste w Androidzie używamy tylko koncepcji obsługi do implementacji ekranu powitalnego

W pliku SplashScreenActivity java wklej ten kod.

W pliku SplashScreenActivity xml Umieść dowolny obraz za pomocą 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);
    }

Really easy & gr8 approach:

• Najpierw Stwórz swój splash z następującej strony:

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

  Wybierz swoje logo i slogan, wybierz swoje piękne tło. Zmień rozmiar na 4096x4096.

• Teraz pobierz to zdjęcie i uploduj do:

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

  I wygenerować wszystkie potrzebne ekrany powitalne, wszystkie urządzenia, wszystkie platformy.

Enjoy!

Jest tu wystarczająco dużo odpowiedzi, które pomogą w realizacji. ten post miał pomóc innym w pierwszym kroku tworzenia ekranu powitalnego!