Jak zrobić ekran powitalny?

Chciałem, aby moja aplikacja wyglądała bardziej profesjonalnie, więc zdecydowałem, że chcę zrobić ekran powitalny.

Jak mam go stworzyć, a następnie wdrożyć?

Dalsza lektura:

• Czas uruchamiania aplikacji i tematyczne ekrany uruchamiania (Android Performance Patterns Season 6 Ep. 4)
• Ekran powitalny w Androidzie: właściwa droga

Stara odpowiedź:

JAK : Prosty ekran powitalny

Te odpowiedzi pokazują, jak wyświetlać ekran powitalny przez określony czas, gdy aplikacja się uruchamia, np. Z powodów związanych z brandingiem. Np. Możesz wybrać wyświetlanie ekranu powitalnego przez 3 sekundy. Jeśli jednak chcesz wyświetlać ekran spash przez różny czas (np. Czas uruchamiania aplikacji), powinieneś sprawdzić odpowiedź Abdullaha https://stackoverflow.com/a/15832037/401025 . Należy jednak pamiętać, że uruchomienie aplikacji może być bardzo szybkie na nowych urządzeniach, więc użytkownik zobaczy tylko flash, który jest zły UX.

Najpierw musisz zdefiniować ekran spash w swoim layout.xmlpliku

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

A twoja aktywność:

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

To wszystko ;)

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

Gdy otworzysz dowolną aplikację na Androida, domyślnie pojawi się jakiś czarny ekran z tytułem i ikoną aplikacji na górze, możesz to zmienić za pomocą stylu / motywu.

Najpierw utwórz plik style.xml w folderze wartości 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 używać @android:style/Theme.DeviceDefault.Light.NoActionBarmożesz użyć dowolnego innego motywu jako elementu nadrzędnego.

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

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

Po trzecie, zaktualizuj motyw w swojej aktywności uruchamiania onCreate ().

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

AKTUALIZACJA Sprawdź ten post .

Dzięki @ mat1h i @adelriosantiago

• Utwórz działanie: Splash
• Utwórz plik XML układu: splash.xml
• Umieść komponenty interfejsu użytkownika w układzie splash.xml, aby wyglądało to tak, jak chcesz

• twój Splash.java może wyglądać następująco:

  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.classna dowolną aktywność, którą chcesz rozpocząć po ekranie powitalnym

• sprawdź plik manifestu i powinien on wyglądać

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

Powyższe odpowiedzi są bardzo dobre, ale chciałbym dodać coś jeszcze. Jestem nowym użytkownikiem Androida, ten problem spotkałem podczas programowania. mam nadzieję, że to może pomóc komuś jak ja.

1. Ekran powitalny jest punktem wejściowym mojej aplikacji, więc dodaj następujące wiersze 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 pokazywać się tylko raz w cyklu życia aplikacji, używam zmiennej boolean do rejestrowania stanu ekranu powitalnego i pokazuję go tylko za pierwszym razem.

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

szczęśliwego kodowania!

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

Wdrażanie ekranu powitalnego

Wdrożenie ekranu powitalnego jest trochę inne niż można sobie wyobrazić. Widok powitalny, który widzisz, musi być natychmiast gotowy, nawet zanim będziesz mógł nadmuchać plik układu w swojej aktywności powitania.

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 plik XML w formacie 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>

Jest to po prostu lista warstw z logo w środkowym kolorze tła.

Teraz otwórz styles.xml i dodaj ten styl

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

Ten motyw będzie musiał mieć pasek akcji i tło, które właśnie utworzyliśmy powyżej.

I oczywiście musisz ustawić SplashTheme na aktywność, której 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 w kodzie aktywności przejdź do określonego ekranu po powitaniu, używając zamiaru.

public class SplashActivity extends AppCompatActivity {

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

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

To jest właściwy sposób. Użyłem tych referencji do odpowiedzi.

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

1. Stworzyć 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 tak będzie

   <?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 powoduje, że Twoja aplikacja wygląda bardziej profesjonalnie. Profesjonalnie zaprojektowany ekran powitalny może sprawić, że Twoja aplikacja będzie wyglądać bardziej profesjonalnie, ale jeśli nie wiesz, jak ją napisać, to jak profesjonalna będzie reszta aplikacji.

Jedynym powodem (usprawiedliwieniem) posiadania ekranu powitalnego jest to, że wykonujesz ogromną liczbę obliczeń lub czekasz na uruchomienie GPS / WiFi, ponieważ Twoja aplikacja opiera się na tym przed 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 została już zainicjowana, a po zakończeniu długich obliczeń można uzupełnić końcowe szczegóły (poprawiono obraz). Szansa na to jest przypadek lub że jest to jedyny sposób, w jaki program mógłby być przeznaczony jest potężny małe .

Lepiej byłoby pozwolić użytkownikowi (i reszcie systemu operacyjnego) zrobić coś innego podczas oczekiwania, niż zaprojektować program tak, aby był zależny od czegoś, co potrwa chwilę (gdy czas oczekiwania jest niepewny).

W telefonie są już ikony, które mówią, że GPS / WiFi się uruchamia. Czas lub miejsce zajmowane przez ekran powitalny można poświęcić na ładowanie wstępnych obliczeń lub wykonywanie obliczeń. Zobacz pierwszy link poniżej, aby dowiedzieć się, jakie problemy tworzysz i co należy wziąć pod uwagę.

Jeśli absolutnie musisz poczekać na te Obliczenia lub GPS / WiFi, najlepiej po prostu pozwól aplikacji się uruchomić i wyświetlić wyskakujące okienko z informacją, że należy poczekać na Obliczenia (tekstowa „Inicjalizacja” komunikatu jest w porządku). Oczekiwanie na GPS / WiFi jest oczekiwane (jeśli nie zostały jeszcze włączone w innym Programie), więc ogłaszanie ich czasów oczekiwania jest niepotrzebne.

Pamiętaj, że kiedy zaczyna się ekran powitalny, twój program JEST już uruchomiony, wszystko, co robisz, to opóźnianie korzystania z programu i zmuszanie procesora / karty graficznej do zrobienia czegoś, co według większości nie jest konieczne.

Powinniśmy naprawdę chcieć czekać i zobaczyć Twój ekran powitalny za każdym razem, gdy uruchamiamy Twój program, w przeciwnym razie MY nie poczujemy, że jest bardzo profesjonalnie napisany. Tworzenie pełnego ekranu powitalnego i duplikatu rzeczywistego ekranu programu (więc uważamy, że jest on inicjowany, gdy tak naprawdę nie jest) MOGĄ osiągnąć cel (uczynić twój program bardziej profesjonalnym), ale nie postawiłbym na to wiele.

Dlaczego tego nie zrobić: 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

Jest więc dobry powód, aby tego nie robić, ale JEŚLI masz pewność, że Twoja sytuacja nie mieści się w tych przykładach, to sposoby na to, jak podano powyżej. Bądź pewien, że to naprawdę sprawia, że ​​Twoja 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 rozpoczyna każdy film od długiego wstępu graficznego (i outro) lub odczuwa potrzebę opowiedzenia dowcipu lub wyjaśnienia, co wydarzyło się w ciągu ostatniego tygodnia (gdy nie jest to kanał komediowy lub LifeStyles). Po prostu pokaż program! (Wystarczy uruchomić program).

Przede wszystkim odpowiedzi są naprawdę bardzo dobre. Ale pojawia się problem wycieku pamięci. Ten problem jest często znany w społeczności Androida jako „Leaking an Activity” . Co to dokładnie oznacza?

Gdy nastąpi zmiana konfiguracji, na przykład zmiana orientacji, Android niszczy działanie i odtwarza je. Zwykle Garbage Collector po prostu wyczyści przydzieloną pamięć starej instancji Activity i wszyscy mamy się dobrze.

„Przeciekanie działania” odnosi się do sytuacji, w której Garbage Collector nie może wyczyścić przydzielonej pamięci starej instancji Activity, ponieważ pochodzi being (strong) referencedz obiektu, który przeżył 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 się stopniowo zmniejszać i ostatecznie zawiesi się z OutOfMemorybłędem.

Jak ustalić, czy aplikacja wycieka pamięć, czy nie? Najszybszym sposobem jest otwarcie karty Pamięć w Android Studio i zwracanie uwagi na przydzieloną pamięć podczas zmiany orientacji. Jeśli przydzielona pamięć stale rośnie i nigdy się nie zmniejsza, oznacza to, że występuje przeciek pamięci.

1. Wyciek pamięci, gdy użytkownik zmieni orientację.

Najpierw musisz zdefiniować ekran powitalny w splashscreen.xmlpliku zasobów układu

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ź przez ten link

Zatrzymywanie się na ekranie powitalnym dla 4-tych 5 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 jest nieco inne niż możesz sobie wyobrazić. Widok powitalny, który widzisz, musi być natychmiast gotowy, nawet zanim będziesz mógł nadmuchać plik układu w swojej aktywności powitania.

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

Tutaj ustawiłem kolor tła i obraz.

Następnie ustaw to jako tło swojej aktywności powitalnej w motywie. Przejdź do pliku styles.xml i dodaj nowy motyw 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 format XML do rysowania. Skonfiguruj to jako motyw swojej aktywności powitalnej 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>

Na koniec klasa SplashActivity powinna po prostu przenieść 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: 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

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 ten plik 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 styles.xml stwó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 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>

Twoje zdrowie.

Ekrany powitalne nie powinny być ładowane z pliku układu, podczas ładowania może nadal występować pewne opóźnienie.

Najlepszym sposobem jest utworzenie motywu tylko dla SplashScreenActivity i ustawienie the android:windowBackgroundzasobu do rysowania.

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

W skrócie:

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

W swoim SplashScreenActivity.java:

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

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

}

Następnie utwórz zasób dla okna tła swojego motywu:

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

Plik rysunkowy 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 korzystanie z ekranu powitalnego, o którym myślę, jest wymaganeAndroid Permissions na ekranie powitalnym aplikacji.

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

• Okna dialogowe źle wpływają na UIX i przerywają główny przepływ i powodują, że decydujesz o czasie wykonywania, a prawda jest taka, że ​​większość użytkowników może nawet nie dbać o to, czy Twoja aplikacja chce napisać coś na karcie SD. Niektóre z nich mogą nawet nie zrozumieć, co próbujemy przekazać, dopóki nie przetłumaczymy tego na zwykły angielski.

• Żądanie uprawnień naraz zmniejsza liczbę „jeśli inaczej” przed każdą operacją i sprawia, że ​​kod wydaje się niepotrzebny.

To jest przykład tego, w jaki sposób możesz poprosić o uprawnienia w swojej aktywności powitalnej dla urządzenia z systemem Android OS 23+.

Jeśli wszystkie uprawnienia są udzielone LUB już przyznane LUB aplikacja działa na Pre Marshmallow TO NASTĘPNIE po prostu przejdź i wyświetl główną zawartość z niewielkim opóźnieniem wynoszącym pół sekundy, aby użytkownik mógł docenić wysiłek włożony w czytanie tego pytania i staranie się jak najlepiej.

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


}

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 plik XML w formacie res / drawable.

Uwaga: cały poniższy kod jest dostępny 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>

Tutaj ustawiłem kolor tła i obraz.

Następnie ustaw to jako tło swojej aktywności powitalnej w motywie. Przejdź do pliku styles.xml i dodaj nowy motyw 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 format XML do rysowania. Skonfiguruj to jako motyw swojej aktywności powitalnej 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, twoja klasa SplashActivity powinna po prostu przenieść 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 funkcji SplashActivity. Widok pochodzi z motywu. Po skonfigurowaniu interfejsu użytkownika dla działania powitalnego w kompozycji jest on dostępny natychmiast.

Jeśli masz plik układu dla działania powitalnego, ten plik układu będzie widoczny dla użytkownika dopiero po pełnej inicjalizacji aplikacji, co jest za późno. Chcesz, aby powitanie było wyświetlane tylko w tak krótkim czasie, zanim aplikacja zostanie zainicjowana.

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

Utwórz działanie, pozwól nam na działanie o nazwie „A”, a następnie utwórz plik xml o nazwie myscreen.xml, w tym zestawie obrazu ekranu powitalnego jako tła, a następnie użyj licznika odliczania czasu do przechodzenia od jednej Aktywności do drugiej. Aby dowiedzieć się, jak korzystać z odliczania, zobacz moją odpowiedź w tym pytaniu 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 mało przydatny obiekt w systemie Android: nie można go załadować tak szybko, jak to możliwe, aby ukryć opóźnienie rozpoczęcia głównej aktywności. Są dwa powody, aby z niego korzystać: reklama i operacje sieciowe.

Implementacja w oknie dialogowym powoduje natychmiastowe przejście 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 zacznij:

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

    ...
}

Inne podejście uzyskuje się za pomocą CountDownTimer

@Override
public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.splashscreen);

 new CountDownTimer(5000, 1000) { //5 seconds
      public void onTick(long millisUntilFinished) {
          mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
      }

     public void onFinish() {
          startActivity(new Intent(SplashActivity.this, MainActivity.class));
          finish();
     }

  }.start();
}

     - Add in SplashActivity 

   public class SplashActivity extends Activity {

       private ProgressBar progressBar;
       int i=0;
       Context context;
       private GoogleApiClient googleApiClient;

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

           new Handler().postDelayed(new Runnable() {
               @Override
               public void run() {
                   startActivity(new Intent(Splash.this, LoginActivity.class));
                   finish();
               }
           }, 2000);

       }

   }

  - Add in activity_splash.xml

   <RelativeLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools"
       xmlns:custom="http://schemas.android.com/apk/res-auto"
       android:background="@color/colorAccent"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       tools:context=".Splash">

       <ImageView
           android:id="@+id/ivLogo"
           android:layout_width="match_parent"
           android:layout_height="match_parent"
           android:src="@mipmap/icon_splash"
           android:layout_centerHorizontal="true"
           android:layout_centerVertical="true"/>


       <ProgressBar
           android:id="@+id/circle_progress"
           style="?android:attr/progressBarStyleHorizontal"
           android:layout_width="fill_parent"
           android:layout_height="wrap_content"
           android:layout_alignParentBottom="true"
           android:layout_marginBottom="5dp"
           android:max="100"
           android:progressTint="@color/green"
           android:visibility="visible" />

   </RelativeLayout>

  - Add in AndroidManifest.xml

    <activity android:name="ex.com.SplashActivity">
               <intent-filter>
                   <action android:name="android.intent.action.MAIN" />

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

Naprawdę łatwe i gr8 podejście:

• Najpierw utwórz swój splash z następującą witryną:

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

  Wybierz swoje logo i hasło, wybierz piękne tło. zmień rozmiar na 4096 x 4096.

• Teraz pobierz to zdjęcie i umieść je na:

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

  I wygeneruj wszystkie potrzebne ekrany powitalne, wszystkie urządzenia, wszystkie platformy.

Cieszyć się!

Tutaj jest wystarczająco dużo odpowiedzi, które pomogą we wdrożeniu. ten post miał pomóc innym w pierwszym etapie tworzenia ekranu powitalnego!

Co powiesz na superelastyczny ekran uruchamiania, który może używać tego samego kodu i jest zdefiniowany w pliku AndroidManifest.xml, więc kod nigdy nie będzie wymagał zmiany. Generalnie tworzę biblioteki kodu i nie lubię dostosowywać 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 sam SpashActivity wyszukuje metadane dla „launch_class”, aby następnie wykonać sam Intent. „Czas trwania” metadanych określa, jak długo ekran powitalny pozostaje bezczynny.

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

Czasami użytkownik SplashActivitynatychmiast otwiera i kończy pracę, ale aplikacja nadal działa MainActivitypo SPLASH_SCREEN_DISPLAY_LENGTH.

Aby temu zapobiec: SplashActivitynależy sprawdzić, czy SplashActivitykończy się przed przejściem doMainActivity

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

Mam nadzieję, że to pomoże

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

1) Najpierw utwórz Themeekran powitalny: masz motyw o nazwie splashscreenTheme, motywem uruchamiania będzie:

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

Uwaga:

android:windowBackground ustawia już twój ekran powitalny nr
trzeba tego ponownie robić w interfejsie użytkownika.

możesz także użyć tutaj koloru zamiast szuflady.

2) Ustaw temat, aby manifestował ekran powitalny Aktywność

   <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 ekran uruchamiania drawablenie znajduje się w drawablefolderze, jeśli obraz nie jest mały.

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

Pozwala to również uniknąć dodatkowego overdraw

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

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

Odnoszę się do tego postu za każdym razem, gdy muszę wziąć pod uwagę czas zimnego startu i unikać rezygnacji użytkownika z powodu długich czasów uruchamiania.

Mam nadzieję że to pomoże!

W moim przypadku nie chciałem tworzyć nowego działania tylko po to, aby wyświetlać obraz przez 2 sekundy. Po uruchomieniu moje MainAvtivityobrazy są ładowane do uchwytów za pomocą Picassa, wiem, że ładowanie zajmuje około 1 sekundy, więc postanowiłem wykonać następujące czynności w mojej 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);

Podczas uruchamiania aplikacji pierwszą rzeczą, która się dzieje, jest ImageViewwyświetlany, a pasek statusu jest usuwany poprzez ustawienie flag okna na pełny ekran. Następnie użyłem a Handlerdo uruchomienia przez 2 sekundy, po 2 sekundach wyczyściłem flagi pełnego ekranu i ustawiłem widoczność ImageViewdo GONE. Łatwy, prosty, skuteczny.

To jest naprawdę proste w Androidzie. Po prostu używamy koncepcji modułu obsługi do wdrożenia ekranu powitalnego

W twoim pliku Java SplashScreenActivity wklej ten kod.

W swoim pliku xml SplashScreenActivity umieść dowolne zdjęcie za pomocą podglądu obrazu.

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

Możesz to dodać w metodzie 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);

I zainicjuj swoją wartość czasu w milisekundach, jak chcesz ...

private  static int time=5000;

po więcej szczegółów pobierz pełny kod z tego linku ...

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

W Kotlin wpisz ten kod: -

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

Mam nadzieję, że to ci pomoże. Dzięki ........

Prosty kod, to działa :) Prosty powitalny

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