Jak zrobić ekran powitalny? [zamknięte]
chcesz poprawić to pytanie? Update the question so it edytując ten post.
Zamknięte 4 miesiące temu .
Popraw to pytanieChciałem, aby moja aplikacja wyglądała bardziej profesjonalnie, więc zdecydowałem, że chcę zrobić ekran powitalny.
Jak go stworzyć, a następnie wdrożyć?
30 answers
Czytaj dalej:
- Czas uruchomienia aplikacji i tematyczne ekrany startowe (Android performance Patterns Season 6 Ep. 4)
- ekran powitalny w Androidzie: właściwy sposób
Stara odpowiedź:
Jak: Simple splash screen
Ta odpowiedź pokazuje, jak wyświetlić ekran powitalny przez określony czas, gdy aplikacja uruchamia się np. z powodów brandingowych. Na przykład możesz wybrać wyświetlanie ekranu powitalnego przez 3 sekundy. Jeśli jednak chcesz pokazać ekran spash przez zmienną ilość czasu (np. czas uruchamiania aplikacji) powinieneś sprawdzić odpowiedź https://stackoverflow.com/a/15832037/401025 . Należy jednak pamiętać, że uruchamianie aplikacji może być bardzo szybkie na nowych urządzeniach, więc użytkownik zobaczy po prostu Flasha, który jest zły UX.
Najpierw musisz zdefiniować ekran spash w pliku layout.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="fill_parent"
android:layout_height="fill_parent">
<ImageView android:id="@+id/splashscreen" android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:src="@drawable/splash"
android:layout_gravity="center"/>
<TextView android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Hello World, splash"/>
</LinearLayout>
I 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;)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-05-30 20:52:56
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.
Dzięki @ mat1h i @ adelriosantiagoWarning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-02-12 15:34:15
- 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>
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-06-19 07:56:20
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.
-
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>
-
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(); } } }
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2015-06-15 02:27:27
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();
}
}
To właściwy sposób. Użyłem tych referencji do odpowiedzi.
- https://material.google.com/patterns/launch-screens.html
- 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.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-10-03 07:24:17
-
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(); } }
-
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>
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2013-11-09 09:59:28
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).
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2014-05-21 01:03:34
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
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-10-25 13:30:38
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>
Tutaj ustawiłem kolor tła i obrazek.
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
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-01-15 04:29:34
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>
Tutaj ustawiłem kolor tła i obrazek.
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.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-12-27 19:44:54
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>
Zdrówko.Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-02-12 21:35:52
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>
/ Align = "left" / 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 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>
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-08-11 20:22:23
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);
}
}
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-10-17 03:52:48
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();
}
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2013-02-17 20:15:17
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?
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-05-23 12:26:27
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);
}
}
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2014-06-09 07:07:10
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();
}
...
}
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2015-04-09 18:19:06
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();
}
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-04-10 19:05:04
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
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-05-24 03:37:15
- 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>
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2018-02-23 12:15:26
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!
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2018-06-25 07:19:34
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();
}
}
}
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2015-06-25 21:35:51
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
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-06-13 11:10:36
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!
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-07-16 20:52:01
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.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-11-16 05:20:54
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);
}
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2018-03-29 07:19:26
Możesz dodać to w swojej 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 zainicjalizuj wartość czasu w milisekundach, jak chcesz...
private static int time=5000;
Aby uzyskać więcej szczegółów pobierz pełny kod z tego linku...
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2019-04-02 19:23:54
W Kotlinie 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........Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2019-07-03 06:04:00
Jednym ze sposobów jest utworzenie FullScreenActivity / EmptyActivity (powiedzmy SplashScreenActivity) i ustawić go jako pierwszą aktywność, która pojawia się po otwarciu aplikacji. Dodaj do swojej aktywności w AndroidManifest.xml
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
Możesz następnie ustawić obsługę, aby zamknąć tę czynność po kilku sekundach.
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
Intent i= new Intent(SplashScreenActivity.this,MainActivity.class);
startActivity(i); //start new activity
finish();
}
}, 3000); //time in milliseconds
Po drugie, jeśli nie chcesz tworzyć osobnego działania, możesz nadmuchać układ MainActivity
i ustawić widoczność układu na GONE
lub nadmuchać główny układ istniejący układ ekranu powitalnego po kilku milisekundach.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-09-18 03:00:06
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);
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-12-12 12:09:44