दिलचस्प पोस्ट
Proguard के साथ संकलन SimException देता है: "स्थानीय चर प्रकार बेमेल" jQuery: एक ही घटना के लिए एक से अधिक हैंडलर एचटीएमएल को एक छवि के रूप में प्रस्तुत करना AngularJS में संसाधित करने के लिए $ संसाधन `मिल` कैसे काम करता है? एक सामान्य पैरामीटर के रूप में संभव है? युद्ध में एनोटेशंस का उपयोग करके निष्पादन के सर्वलेट फिल्टर ऑर्डर को कैसे परिभाषित किया जाए सर्वर पर एक्सक्शंस डिक्टचर इन्फॉल्ट (यानी सेवाविशेषित्र से या <serviceDebug> कॉन्फ़िगरेशन वर्तन से) को शामिल करें चालू करें C ++ स्ट्रिंग में चारों की सभी घटनाओं को कैसे निकालें एनजी-क्लिक का उपयोग करके कोणीय जेएस में कक्षाएं जोड़ना और निकालना किसी दिए गए प्रकार के ऑब्जेक्ट के साथ जेनेरिक विधि को कैसे कॉल करें? एक स्ट्रिंग में सबसे लंबे समय से दोहराव अनुक्रम ढूंढें पृष्ठ के नीचे जावास्क्रिप्ट? मैं कैनवास तत्व पर माउस क्लिक के निर्देशांक कैसे प्राप्त करूं? क्या आप समापन समझा सकते हैं (जैसा कि वे पायथन से संबंधित हैं)? निर्भरता वाकर: लापता डीएलएलएस

मैं स्प्लैश स्क्रीन कैसे करूं?

मैं अपना ऐप अधिक पेशेवर दिखाना चाहता था, इसलिए मैंने तय किया कि मैं एक स्पलैश स्क्रीन बनाना चाहता हूं।

मैं इसे कैसे बनाऊँगा और फिर इसे लागू करूँगा?

वेब के समाधान से एकत्रित समाधान "मैं स्प्लैश स्क्रीन कैसे करूं?"

आगे की पढाई:

  • ऐप लॉन्च टाइम और थीम्ड लॉन्च स्क्रीन (एंड्रॉइड परफॉर्मेंस पैटर्न्स सीजन 6 एपी 4)
  • Android में स्पलैश स्क्रीन: सही तरीके से

पुराना उत्तर:

कैसे करें : सरल स्पलैश स्क्रीन

यह उत्तर आपको दिखाता है कि एक निश्चित समय के लिए एक स्प्लैश स्क्रीन कैसे प्रदर्शित करें, जब आपका ऐप शुरू होता है जैसे कि ब्रांडिंग कारण उदाहरण के लिए आप 3 सेकंड के लिए स्पलैश स्क्रीन दिखाने का विकल्प चुन सकते हैं। हालांकि यदि आप समय की एक चर राशि (जैसे ऐप स्टार्टअप समय) के लिए स्काइप स्क्रीन दिखाना चाहते हैं तो आपको अब्दुल्ला का जवाब https://stackoverflow.com/a/15832037/401025 पर देखना चाहिए। हालांकि इस बात से अवगत रहें कि ऐप स्टार्टअप नए उपकरणों पर बहुत तेजी से हो सकता है ताकि उपयोगकर्ता सिर्फ एक फ्लैश देख पाए जो खराब यूएक्स है।

पहले आपको अपने layout.xml फ़ाइल में 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> 

और आपकी गतिविधि:

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

बस इतना ही 😉

नोट करें कि यह समाधान उपयोगकर्ता को अधिक इंतजार नहीं करने देगा: स्प्लैश स्क्रीन की देरी, आवेदन के शुरुआती समय पर निर्भर करती है।

जब आप किसी भी एंड्रॉइड ऐप को खोलते हैं, तो आप डिफ़ॉल्ट रूप से मिलेगा, कुछ शीर्ष पर ऐप के शीर्षक और आइकन के साथ कुछ ब्लैक स्क्रीन, आप एक स्टाइल / थीम का उपयोग करके इसे बदल सकते हैं।

पहले, मान फ़ोल्डर में एक शैली। Xml बनाएं और इसमें एक शैली जोड़ें।

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

@android:style/Theme.DeviceDefault.Light.NoActionBar का उपयोग करने के बजाय। @android:style/Theme.DeviceDefault.Light.NoActionBar आप माता-पिता के रूप में किसी अन्य विषय का उपयोग कर सकते हैं।

दूसरा, अपने ऐप में Manifest.xml android:theme="@style/splashScreenTheme" जोड़ें android:theme="@style/splashScreenTheme" आपकी मुख्य गतिविधि में।

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

तीसरा, अपनी थीम को अपने ऑन क्रेट () लॉन्च गतिविधि में अपडेट करें

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

अद्यतन करें इस पोस्ट को देखें https://plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd @ mat1h और @adelriosantiago के लिए धन्यवाद

  • एक गतिविधि बनाएं: स्पलैश
  • लेआउट XML फ़ाइल बनाएँ: splash.xml
  • Splash.xml लेआउट में यूआई घटकों को रखो ताकि आप यह देख सकें कि आप कैसे चाहते हैं
  • आपका स्पलैश.जावा इस तरह दिख सकता है:

     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); } } 
  • स्प्लैश स्क्रीन के बाद जो भी गतिविधि आप शुरू करना चाहते हैं, उसके लिए ActivityB.class बदलें

  • अपनी मैनिफ़ेस्ट फ़ाइल की जांच करें और इसे दिखना चाहिए

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

@ अब्दुल्ला का जवाब सही है, हालांकि Google ने अपनी गतिविधि के विषय को बदलने के बिना इसे ठीक से लागू करने के बारे में विस्तृत व्याख्या पोस्ट की है:

https://plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd

Google मानचित्र और YouTube जैसे ऐप्स समान विधि का उपयोग करना शुरू कर चुके हैं।

ऊपर दिए गए उत्तर बहुत अच्छे हैं, लेकिन मैं कुछ और जोड़ना चाहता हूं। मैं एंड्रॉइड के लिए नया हूँ, मैंने अपने विकास के दौरान इन समस्याओं को पूरा किया। आशा है कि यह मेरे जैसे किसी को मदद कर सकता है

  1. स्पलैश स्क्रीन मेरे ऐप का प्रवेश बिंदु है, इसलिए एंड्रॉइड मैनिफ़ेस्ट.एक्सएमएल में निम्नलिखित पंक्तियां जोड़ें।

      <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. स्प्लैश स्क्रीन केवल एप जीवन चक्र में एक बार दिखाए जाने चाहिए, मैं स्प्लैश स्क्रीन की स्थिति रिकॉर्ड करने के लिए बुलियन वैरिएबल का उपयोग करता हूं, और इसे केवल पहली बार दिखाता हूं

     public class SplashActivity extends Activity { private static boolean splashLoaded = false; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); if (!splashLoaded) { setContentView(R.layout.activity_splash); int secondsDelayed = 1; new Handler().postDelayed(new Runnable() { public void run() { startActivity(new Intent(SplashActivity.this, MainActivity.class)); finish(); } }, secondsDelayed * 500); splashLoaded = true; } else { Intent goToMainActivity = new Intent(SplashActivity.this, MainActivity.class); goToMainActivity.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT); startActivity(goToMainActivity); finish(); } } } 

खुश कोडन!

  1. एक 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 इस तरह होगा

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

एक स्पलैश Scren, डिफ़ॉल्ट रूप से, स्वचालित रूप से आपके आवेदन को और अधिक पेशेवर देखो नहीं बनाता है पेशेवर रूप से डिजाइन किए स्पलैश स्क्रीन में आपके आवेदन को और अधिक पेशेवर बनाने की संभावना है, लेकिन अगर आपको नहीं पता कि कैसे एक लिखना है तो आपका बाकी आवेदन कैसे पेशेवर होगा

एक स्पलैश स्क्रीन के लिए एकमात्र कारण (बहाना) के कारण है क्योंकि आप बड़े पैमाने पर गणना कर रहे हैं या जीपीएस / वाईफाई के स्टार्टअप के लिए इंतजार कर रहे हैं क्योंकि आपका आवेदन उस पर शुरू होने से पहले निर्भर करता है। उन गणनाओं या जीपीएस / वाईफाई (आदि) तक पहुंच के परिणाम के बिना आपका आवेदन पानी में मर गया है, इस प्रकार आपको लगता है कि आपको स्पलैश स्क्रीन की आवश्यकता है, और किसी अन्य चलने वाले कार्यक्रमों के लिए स्क्रीन के दृश्य को ब्लॉक करना आवश्यक है (पृष्ठभूमि सहित )।

इस तरह की स्पलैश स्क्रीन को आपके पूर्ण स्क्रीन एप्लिकेशन की तरह दिखना चाहिए कि यह छाप देने के लिए पहले से ही आरंभ किया गया है, फिर लंबी गणना पूरी होने के बाद अंतिम विवरण (छवि को छूटे) में भर दिया जा सकता है। उस मामले की संभावना है या यह एकमात्र तरीका है कि कार्यक्रम तैयार किया जा सकता है वह बहुत कम है

यह उपयोगकर्ता (और बाकी के ओएस) को कुछ और करने की अनुमति देने के लिए बेहतर होगा, जब वे कुछ समय के लिए निर्भर होने के लिए अपने प्रोग्राम को डिज़ाइन करने के बजाय प्रतीक्षा करते हैं (जब प्रतीक्षा की अवधि अनिश्चित होती है)।

आपके फोन पर पहले से ही ये चिन्ह हैं कि जीपीएस / वाईफाई शुरू हो रही है स्पलैश स्क्रीन द्वारा उठाए गए समय या स्थान को पूर्व-गणना लोड करने या वास्तव में गणना करना खर्च किया जा सकता है। आपके द्वारा बनाए गए समस्याओं के लिए नीचे दिए गए पहले लिंक को देखें और क्या विचार किया जाना चाहिए।

यदि आपको इन गणनाओं या जीपीएस / वाईफाई के लिए बिल्कुल इंतजार करना होगा, तो यह सिर्फ आवेदन शुरू करने और एक पॉप-अप होने का सबसे अच्छा होगा, जो कहते हैं कि गणना के लिए इंतजार करना आवश्यक है (एक टेक्स्ट "संदेश" शुरू करना ठीक है)। जीपीएस / वाईफाई के लिए इंतजार की उम्मीद है (अगर वे पहले से किसी अन्य प्रोग्राम में सक्षम नहीं थे) तो उनके इंतजार के समय की घोषणा अनावश्यक है।

याद रखें कि जब स्प्लैश स्क्रीन शुरू होती है, आपका प्रोग्राम वास्तव में पहले से ही चल रहा है, तो आप जो कर रहे हैं वह अपने कार्यक्रम के उपयोग में देरी कर रहा है और कुछ ऐसा करने के लिए सीपीयू / जीपीयू को दबाना दे रहा है, जो सबसे ज्यादा जरूरी नहीं है।

जब हम आपके प्रोग्राम को शुरू करते हैं तो हम वास्तव में इंतजार करना चाहते हैं और अपनी स्पलैश स्क्रीन को देखना चाहते हैं या हमें यह नहीं लगेगा कि यह बहुत पेशेवर लिखित है। स्पलैश स्क्रीन फुल स्क्रीन और वास्तविक प्रोग्राम की स्क्रीन का डुप्लिकेट बनाना (इसलिए हमें लगता है कि जब यह वास्तव में नहीं है, तो इसका आरंभ होता है) अपने लक्ष्य को पूरा कर सकते हैं (अपने प्रोग्राम को और अधिक पेशेवर बनाने के लिए), लेकिन मैं उस पर ज्यादा शर्त नहीं लगाऊंगा

ऐसा करने के लिए क्यों नहीं: http://cyrilmottier.com/2012/05/03/splash-screens-are-evil-dont-use-them/

इसे कैसे करें: https://encrypted.google.com/search?q=Android+splash+screen+source

तो ऐसा करने के लिए एक अच्छा कारण नहीं है, लेकिन अगर आप निश्चित हैं कि आपकी परिस्थिति उन उदाहरणों के बाहर होती है तो इसके लिए इसका मतलब उपरोक्त दिया गया है। सुनिश्चित करें कि यह वास्तव में आपका आवेदन अधिक पेशेवर बना लेता है या आपने ऐसा करने के लिए दिए गए एकमात्र कारण को हरा दिया है।

यह एक यूट्यूब चैनल की तरह है जो हर वीडियो को एक लंबा ग्राफिक पहचान (और आउटो) के साथ शुरू करता है या एक मजाक या पिछले हफ्ते (जब वह कॉमेडी या लाइफस्टाइल चैनल नहीं है) के दौरान हुआ है, की व्याख्या करने की आवश्यकता महसूस करता है। बस शो दिखाओ! (बस कार्यक्रम चलाएं)

सभी उत्तर के ऊपर वास्तव में बहुत अच्छा है। लेकिन मेमोरी रिसाव की मुठभेड़ समस्याएं हैं यह समस्या प्रायः एंड्रॉइड समुदाय में "लीकिंग ए एक्टिविटी" के रूप में जाना जाता है अब इसका क्या मतलब है?

जब कॉन्फ़िगरेशन परिवर्तन होता है, जैसे ओरिएंटेशन परिवर्तन, एंड्रॉइड गतिविधि को नष्ट कर देता है और इसे पुनः बनाता है आम तौर पर, कचरा कलेक्टर केवल पुराने गतिविधि आवृत्ति की आवंटित स्मृति को साफ़ कर देगा और हम सभी अच्छे हैं।

"एक गतिविधि को लेना" उस स्थिति को संदर्भित करता है जहां कचरा कलेक्टर पुराने गतिविधि के उदाहरण की आवंटित स्मृति को स्पष्ट नहीं कर सकता क्योंकि यह एक ऐसी वस्तु से being (strong) referenced जिसने गतिविधि का उदाहरण जीता था। हर एंड्रॉइड ऐप में इसके लिए आवंटित स्मृति की विशिष्ट मात्रा होती है। जब कचरा कलेक्टर अप्रयुक्त स्मृति को मुक्त नहीं कर सकता, तो ऐप का प्रदर्शन धीरे-धीरे कम हो जाएगा और अंततः OutOfMemory त्रुटि के साथ दुर्घटना होगी।

यह निर्धारित करने के लिए कि ऐप लीक की स्मृति या नहीं? सबसे तेज़ तरीका है एंड्रॉइड स्टूडियो में मेमोरी टैब को खोलना और आवंटित स्मृति पर ध्यान देना ताकि आप अभिविन्यास बदल सकें। यदि आवंटित मेमोरी बढ़ती रहती है और कभी घटती नहीं तो आपके पास स्मृति रिसाव होता है

1. उपयोगकर्ता रसीन बदलते समय मेमोरी रिसाव यहां छवि विवरण दर्ज करें

सबसे पहले आपको अपने लेआउट संसाधन splashscreen.xml फ़ाइल में छप स्क्रीन को परिभाषित करने की आवश्यकता है

स्प्लैश स्क्रीन गतिविधि के लिए नमूना कोड

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

अधिक जानकारी के लिए कृपया इस लिंक के माध्यम से जाएं

अब्दुल्ला का जवाब महान है लेकिन मैं अपने जवाब के साथ इसमें कुछ और विवरण जोड़ना चाहता हूं।

स्पलैश स्क्रीन को लागू करना

एक छप स्क्रीन को लागू करना सही तरीके से थोड़ा अलग है, जितना कि आप कल्पना कर सकते हैं। अपनी छप गतिविधि में एक लेआउट फ़ाइल को फुलाए जाने से पहले, आपको दिखाई देने वाला स्पलैश दृश्य तुरंत तैयार होना चाहिए।

इसलिए आप लेआउट फ़ाइल का उपयोग नहीं करेंगे। इसके बजाय, गतिविधि की थीम पृष्ठभूमि के रूप में अपनी छप स्क्रीन की पृष्ठभूमि को निर्दिष्ट करें ऐसा करने के लिए, पहले आरएएस / ड्रॉएबल में एक एक्सएमएल ड्रॉएबल बनाएं।

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> 

यह केवल इसके साथ एक पृष्ठभूमि परत में लोगो के साथ एक परत सूची है।

अब styles.xml खोलें और यह शैली जोड़ें

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

इस थीम को एक्शनबार और पृष्ठभूमि के साथ करना होगा जो हमने अभी बनाया है।

और मैनिफेस्ट में आपको स्पलैश थीम को उस गतिविधि में सेट करना होगा जिसे आप स्पलैश के रूप में इस्तेमाल करना चाहते हैं।

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

फिर अपने गतिविधि कोड के अंदर प्रयोजन का उपयोग करके छपने के बाद उपयोगकर्ता को विशिष्ट स्क्रीन पर नेविगेट करें।

 public class SplashActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Intent intent = new Intent(this, MainActivity.class); startActivity(intent); finish(); } } 

यह करने का सही तरीका है मैंने जवाब के लिए इन संदर्भों का इस्तेमाल किया

  1. https://material.google.com/patterns/launch-screens.html
  2. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ इन लोगों के लिए मुझे सही दिशा में धकेलने के लिए धन्यवाद मैं दूसरों की मदद करना चाहता हूँ क्योंकि स्वीकार किए जाते हैं जवाब छपने की स्क्रीन करने के लिए अनुशंसित नहीं है।

यह पूर्ण कोड है यहाँ

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

Drawables में इस 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> 

Styles.xml में कस्टम थीम बनाएं

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

और अंत में AndroidManifest.xml में आपकी गतिविधि को थीम निर्दिष्ट करें

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

चीयर्स।

स्पलैश स्क्रीन को लेआउट फ़ाइल से लोड नहीं किया जाना चाहिए, फिर भी लोड होने पर कुछ अंतराल हो सकती है।

सबसे अच्छा तरीका है कि केवल अपने स्लैशस्क्रीनएक्टिवटी के लिए थीम बनाइए और एंड्रॉइड सेट the android:windowBackground

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

संक्षेप में:

मैनिफेस्ट में अपनी स्लैशस्क्रीन ऐक्टिविटी घोषित करें:

 <activity android:name=".activities.SplashScreenActivity" android:theme="@style/SplashTheme" android:screenOrientation="portrait"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> 

आपके स्लैशस्क्रीनएक्टविविटी.जावा में:

 @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); Intent intent = new Intent(this, MainActivity_.class); startActivity(intent); finish(); } 

आगे अपनी थीम की पृष्ठभूमि विंडो के लिए ressource बनाएँ:

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

ड्रॉएबल फ़ाइल स्प्लैश.एक्सएमएल:

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

स्पलैश स्क्रीन उदाहरण:

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

स्पलैश स्क्रीन एंड्रॉइड में एक छोटे से अनुपयोगी वस्तु है: यह प्रारंभ होने वाली मुख्य गतिविधि की देरी को छिपाने के लिए जितनी जल्दी हो सके लोड नहीं की जा सकती इसका इस्तेमाल करने के दो कारण हैं: विज्ञापन और नेटवर्क संचालन

क्रियान्वयन के रूप में संवाद स्लैश स्क्रीन से देरी के बिना गतिविधि के मुख्य यूआई के लिए कूदता है।

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

लेआउट:

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

और शुरू करें:

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

Android Marshmallow के बाद, स्पलैश स्क्रीन का अन्य उत्पादक उपयोग मैं सोचता हूं कि आपके ऐप के स्प्लैश स्क्रीन में आवश्यक Android Permissions का अनुरोध कर रहा है

ऐसा लगता है कि अधिकांश एप्लिकेशन इस तरह से अनुमति अनुरोध संभालते हैं

  • डायलॉग खराब यूआईएस बनाते हैं और वे मुख्य प्रवाह को तोड़ते हैं और रनटाइम पर फैसला करते हैं और सच्चाई यह है कि अधिकतर उपयोगकर्ताओं को भी ध्यान नहीं दिया जा सकता है कि आपका ऐप एसडी कार्ड पर कुछ लिखना चाहता है। उनमें से कुछ भी समझ नहीं सकते हैं कि हम जब तक इसका सादे अंग्रेजी में अनुवाद नहीं करते, तब तक हम क्या कहने की कोशिश कर रहे हैं।

  • एक बार में अनुमतियों का अनुरोध करने से प्रत्येक ऑपरेशन से पहले "यदि अन्य" की संख्या कम हो जाती है और आपके कोड में अव्यवस्था मुक्त दिखती है

यह एक उदाहरण है कि आप Android ओएस 23+ चलाने वाले डिवाइस के लिए अपनी स्पलैश गतिविधि में अनुमति के लिए कह सकते हैं

यदि सभी अनुमतियां दी गई हैं या पहले से ही दी गई है या प्री मार्शमॉलो पर ऐप चल रहा है तो बस जाकर मुख्य सामग्री को आधा सेकंड में देरी के साथ प्रदर्शित करें जिससे कि उपयोगकर्ता इस सवाल को पढ़ने में हमारी पूरी कोशिश कर सके और हमारी पूरी कोशिश दे सके।

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

एक गतिविधि बनाएं, हमें 'ए' नाम की गतिविधि बनाएं, फिर myscreen.xml नामक एक एक्सएमएल फाइल बनाएं, उसमें पृष्ठभूमि के रूप में छप स्क्रीन छवि सेट करें, और फिर एक एक्टिटाटी से दूसरे में नेविगेट करने के लिए गिनती नीचे टाइमर का उपयोग करें गणना डाउन टाइमर का उपयोग करने के बारे में जानने के लिए इस प्रश्न में मेरा जवाब देखें एंड्रॉइड में टाइमरटस्क?

कैसे एक सुपर लचीला लांच स्क्रीन है जो एक ही कोड का उपयोग कर सकता है और एंड्रॉइड मैनिफ़ेस्ट। एक्सएमएल में परिभाषित है, इसलिए कोड को कभी भी बदलने की आवश्यकता नहीं होगी। मैं आम तौर पर कोड के पुस्तकालयों का विकास करता हूं और कोड अनुकूलित नहीं करना चाहता क्योंकि यह मैला है

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

फिर स्पैश ऍक्टिविटीज खुद "लॉन्च-क्लास" के लिए मेटा-डेटा को देखती है, फिर इंटेंट खुद बनाते हैं। मेटा डेटा "अवधि" परिभाषित करती है कि स्प्लैश स्क्रीन कितनी देर तक रहता है।

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

आप लेआउट फ़ाइल का उपयोग नहीं करेंगे। इसके बजाय, गतिविधि की थीम पृष्ठभूमि के रूप में अपनी छप स्क्रीन की पृष्ठभूमि को निर्दिष्ट करें ऐसा करने के लिए, पहले आरएएस / ड्रॉएबल में एक एक्सएमएल ड्रॉएबल बनाएं।

नोट: नीचे दिए गए सभी कोड उपलब्ध हैं GitHub लिंक

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

यहां, मैंने एक पृष्ठभूमि रंग और एक छवि सेट की है

इसके बाद, आप इसे थीम में अपनी छप गतिविधि की पृष्ठभूमि के रूप में सेट करेंगे। अपनी styles.xml फ़ाइल पर जाएं और अपनी छप गतिविधि के लिए एक नई थीम जोड़ें:

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

आपके नए स्पलैश थीम में, अपने एक्सएमएल ड्रॉएबल में विंडो पृष्ठभूमि विशेषता सेट करें। इसे अपने 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> 

अंत में, आपकी स्पलैश एक्टिविटी क्लास को आपको अपनी मुख्य गतिविधि के साथ आगे बढ़ा देना चाहिए:

 public class SplashActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Intent intent = new Intent(this, MainActivity.class); startActivity(intent); finish(); } } 

ध्यान दें कि आप इस स्पलैश एक्टिविटी के लिए भी एक दृश्य सेट नहीं करते हैं। दृश्य थीम से आता है जब आप थीम में अपनी स्प्लैश गतिविधि के लिए यूआई सेट अप करते हैं, तो यह तुरंत उपलब्ध होता है।

अगर आपके स्प्लैश गतिविधि के लिए आपके पास एक लेआउट फाइल है, तो उस ऐप को पूरी तरह से आरम्भ करने के बाद ही लेआउट फ़ाइल उपयोगकर्ता को दिखाई देगी, जो बहुत देर हो चुकी है। आप चाहते हैं कि स्प्लैश को ऐप के प्रारंभ होने से पहले ही उस छोटी मात्रा में प्रदर्शित किया जाए।

काउंटडाउन टाइमर द्वारा एक अन्य दृष्टिकोण प्राप्त किया जाता है

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

कुछ समय तक उपयोगकर्ता SplashActivity और तत्काल छोड़ देते हैं लेकिन ऐप अभी भी MainActivity बाद SPLASH_SCREEN_DISPLAY_LENGTH पर SPLASH_SCREEN_DISPLAY_LENGTH

इसे रोकने के लिए: SplashActivity आपको SplashActivity जांच करनी चाहिए या 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); } } } 

उममीद है कि इससे मदद मिलेगी

Though there are good answers, I will show the google recommended way:

1)First create a Theme for splash screen: you have a theme called splashscreenTheme , your launcher theme would be:

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

ध्यान दें:

android:windowBackground already sets your splashscreen image no
need to do this in UI again.

you can also use color here instead of a drawable.

2)Set the theme to manifest of 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)make sure you launch_screen drawable is not in drawable folder if your image is not small.

It will result in faster launch screen start and save you from the black screen

It also avoids extra overdraw

This is the best post I've seen on splash screens: http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero goes into two different options for splash screens: Taking advantage of the window background to animate into your initial screen and displaying placeholder UI (which is a popular choice that Google uses for most of their apps these days).

I refer to this post every time I need to consider cold start time and avoiding user dropoff due to long startup times.

उम्मीद है की यह मदद करेगा!

Simple Code, it works:) Simple splash

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

The Stopping on the Splash screen for 4's 5's unnecessarily doesn't make much sense. It's Ok if you loading something in background else follow this approach to implement splash screen:- Implementing a splash screen the right way is a little different than you might imagine. The splash view that you see has to be ready immediately, even before you can inflate a layout file in your splash activity.

So you will not use a layout file. Instead, specify your splash screen's background as the activity's theme background. To do this, first, create an XML drawable in 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> 

Here, I've set up a background color and an image.

Next, you will set this as your splash activity's background in the theme. Navigate to your styles.xml file and add a new theme for your splash activity:

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

In your new SplashTheme, set the window background attribute to your XML drawable. Configure this as your splash activity's theme in your 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> 

Finally, SplashActivity class should just forward you along to your main activity:

  public class SplashActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Intent intent = new Intent(this, MainActivity.class); startActivity(intent); finish(); } } 

More Details read this: 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

activity_splash.xml

 <?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:background="@drawable/gradient_background" > <ImageView android:id="@+id/imgLogo" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerInParent="true" android:src="@drawable/wwe_logo" /> <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginBottom="10dp" android:textSize="12dp" android:textColor="#454545" android:gravity="center_horizontal" android:layout_alignParentBottom="true" android:text="www.androidhive.info" /> </RelativeLayout> 

SplashScreen.java

 import android.app.Activity; import android.content.Intent; import android.os.Bundle; import android.os.Handler; public class SplashScreen extends Activity { // Splash screen timer private static int SPLASH_TIME_OUT = 3000; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_splash); 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() { // This method will be executed once the timer is over // Start your app main activity Intent i = new Intent(SplashScreen.this, MainActivity.class); startActivity(i); // close this activity finish(); } }, SPLASH_TIME_OUT); } } 

आउटपुट:

यहां छवि विवरण दर्ज करें

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

In my case I didn't want to create a new Activity only to show a image for 2 seconds. When starting my MainAvtivity , images gets loaded into holders using picasso, I know that this takes about 1 second to load so I decided to do the following inside my 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); 

When starting the application the first thing that happens is the ImageView gets displayed and the statusBar is removed by setting the window flags to full screen. Then I used a Handler to run for 2 seconds, after the 2 seconds I clear the full screen flags and set the visibility of the ImageView to GONE . Easy, simple, effective.