मैं एक स्प्लैश स्क्रीन कैसे बनाऊं?

548

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

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

android  splash-screen 
— एप्रैम
स्रोत
58
स्प्लैश स्क्रीन का उपयोग करके एप्लिकेशन अधिक पेशेवर क्यों दिखता है? मुझे पता है कि कोई भी 'पेशेवर' एंड्रॉइड ऐप नहीं है जो एक मिला।
— ओमेगा
7
@Theomega से सहमत हैं। स्प्लैश स्क्रीन सिर्फ सादे कष्टप्रद हैं।
— मैट बॉल
85
अगर आपको बैकग्राउंड लोडिंग का काम करना है तो आपको केवल एक स्प्लैश स्क्रीन दिखानी चाहिए। अन्यथा, आपका ऐप अधिक "पेशेवर" दिखता है जब आप उपयोगकर्ता को अपने ऐप से जितनी जल्दी हो सके उतना जल्दी दे सकते हैं। उपयोगकर्ता नोटिस करते हैं (और परेशान होते हैं) 100ms से अधिक की देरी करते हैं, और आप एक स्प्लैश स्क्रीन जोड़कर इस सीमा से ऊपर परिमाण का एक क्रम है।
— कोडफ्यूज़न मोब
74
किंडल ऐप, एल्डिको (रीडर), डॉल्फिन .. उम्म द ओएस :) वे सभी एक छप गए। ओपेरा मोबाइल, मंथन रीडर, मैप्स। मैं जा सकता था। यदि यह एक लोड को छुपाता है, तो यह कम से कम उपयोगकर्ता को बताए कि आपका ऐप शुरू हो गया है। स्क्रीन पर कम से कम आप में से कुछ होने पर कुछ सेकंड की देरी बहुत बेहतर छिपी है।
— baash05
9
स्पलैश स्क्रीन आपको अपने गेम या ऐप कंपनी के नाम या लोगो का विज्ञापन करने का उत्कृष्ट अवसर देता है। मुझे स्प्लैश स्क्रीन को क्लिक करने योग्य बनाना पसंद है इसलिए उपयोगकर्ता के पास खेल के आगे स्किप करने का विकल्प है। यदि उपयोगकर्ता हमेशा आपके ऐप को खोलने पर हर बार आपकी कंपनी के लोगो को आधे से एक सेकंड के लिए देखता है, तो उन्हें याद रखने की अधिक संभावना होगी कि वे कौन हैं। बस सुनिश्चित करें कि वे आपके ऐप के साथ अच्छा अनुभव कर रहे हैं।
— चमत्के-सान

जवाबों:

509

आगे की पढाई:

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

कैसे : सरल छप स्क्रीन

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

सबसे पहले आपको अपनी 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);
    }
}

बस इतना ही ;)

— वोट दें
स्रोत
3
@ user2606414 कृपया SO पर एक प्रश्न बनाएं, जिससे आपको अपनी संपूर्ण त्रुटि लॉग का पेस्ट करने में समस्या हो।
— वोट दें
39
मैनिफेस्ट में स्प्लैश जोड़ना मत भूलना
— जवाद ज़ेब
8
@ सवाल यह है कि डेटा लोड करते समय स्प्लैश स्क्रीन कैसे दिखाएं।
— अपराह्न
18
यह स्प्लैश स्क्रीन के लिए एक उचित समाधान नहीं है, यह उपयोगकर्ता को स्प्लैश स्क्रीन दिखाने के लिए प्रतीक्षा करता है, हालांकि स्प्लैश स्क्रीन का उद्देश्य इसके विपरीत है। उपयोगकर्ता को प्रतीक्षा करते समय इसे एक स्प्लैश स्क्रीन दिखानी चाहिए। कृपया @ अब्दुल्ला का समाधान देखें।
— efeyc
4
SPLASH_DISPLAY_LENGTHसमय के लिए एप्लिकेशन को रोकने के बजाय । आपको इसके बजाय यह करना चाहिए: bignerdranch.com/blog/splash-screens-the-right-way
— miguel.martin
594

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

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

सबसे पहले, वैल्यू फ़ोल्डर में एक style.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:theme="@style/splashScreenTheme"में अपनी मुख्य गतिविधि जोड़ें ।

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

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

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

अद्यतन इस पोस्ट की जाँच करें ।

@ Mat1h और @adelriosantiago को धन्यवाद

— अब्दुल्ला
स्रोत
3
ऐसा लगता है कि "माता-पिता" केवल एपीआई 14 और इसके बाद के संस्करण में समर्थित हैं
— user1832478
103
यह स्प्लैश स्क्रीन करने का सही तरीका है। धन्यवाद! देरी के साथ अधिक वोट के साथ जवाब सिर्फ बुरा अभ्यास है। पहली कार्यात्मक स्क्रीन को देखने से उपयोगकर्ता को कुछ भी देरी नहीं होनी चाहिए।
— दिन के
7
इसके साथ मेरी एक समस्या यह है कि <item name="android:background">यह ओवरराइड होगी windowBackground। और android:backgroundपरिभाषित किए बिना , किसी भी टुकड़े में मेरी पृष्ठभूमि पारदर्शी होगी जो अग्रभूमि सामग्री के पीछे की गतिविधि का खुलासा करेगी।
— विलियम ग्रैंड
4
@ अब्दुल्ला: मैंने आपके कहे तरीके का पालन किया। यह ठीक काम करता है, लेकिन गतिविधि संक्रमण पर कुछ मिलीसेकंड के लिए स्प्लैश स्क्रीन दिखाई देती है।
— nizam.sp 16
3
@ अब्दुल्लाह धन्यवाद! यह एक संभव समाधान होगा, हालाँकि मैंने यह पाया: plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd , प्रत्येक स्क्रीन आकार के लिए अलग-अलग चित्र बनाने से बचने के लिए XML युक्त छवि बनाना भी संभव है ताकि यह दिखेगा सभी स्क्रीन पर ठीक है।
— adelriosantiago
52
  • एक गतिविधि बनाएँ: स्पलैश
  • एक लेआउट XML फ़ाइल बनाएँ: splash.xml
  • UI घटकों को 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>
— जेम्स
स्रोत
28
यह स्प्लैश स्क्रीन का उद्देश्य नहीं है। यह अतिरिक्त 1 सेकंड की देरी करता है। एप्लिकेशन की पहली स्क्रीन लोड करते समय स्प्लैश स्क्रीन एक छवि होनी चाहिए। यह लिंक मदद कर सकता है। stackoverflow.com/a/7057332/869451
— efeyc
2
@efeyc: आप 100% सही हैं .. फिर भी, ऐप शुरू होने पर यह बहुत अच्छा लगता है .. क्या आपको नहीं लगता?
— मैकलन
1
@ Suda.nese निश्चित रूप से नहीं। उपयोगकर्ताओं को एक तस्वीर को देखने के लिए नहीं करना चाहते हैं, उपयोगकर्ताओं को एप्लिकेशन का उपयोग करना चाहते हैं और एक आवश्यक देरी नहीं है
— टिम
1
@TimCastelijns यह विकास के तहत ऐप पर निर्भर करता है और स्प्लैश स्क्रीन कैसा दिखता है .. बेशक यह व्यावहारिक होने के लिए है, लेकिन कौन कहता है कि इसका उपयोग नहीं किया जा सकता है !!
— मैकलान
6
सहमत @ Suda.nese यदि एप्लिकेशन की आवश्यकताओं में स्प्लैश स्क्रीन शामिल है, तो स्प्लैश स्क्रीन की तुलना में यह है! निश्चित रूप से, यह उपयोगकर्ताओं के लिए वांछनीय नहीं हो सकता है, लेकिन अगर कोई ग्राहक एक स्प्लैश स्क्रीन चाहता है, तो गॉश द्वारा उन्हें दे
— james
29

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

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

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

खुश कोडिंग!

— zdd
स्रोत
10
आप जोड़ सकते हैं android:noHistory="true"में AndroidManifest.xmlवापसी बटन का प्रयोग स्प्लैश स्क्रीन में वापस जाने से उपयोगकर्ता को रोकने के लिए।
— राहेल
15

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

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

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

तो आप एक लेआउट फ़ाइल का उपयोग नहीं करेंगे। इसके बजाय, गतिविधि की थीम पृष्ठभूमि के रूप में अपनी स्प्लैश स्क्रीन की पृष्ठभूमि निर्दिष्ट करें। ऐसा करने के लिए, पहले Res / drawable में XML 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>

यह इसके साथ सेंटर बैकग्राउंड कलर में लोगो के साथ सिर्फ एक लेयरलिस्ट है।

अब style.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/ मुझे सही दिशा में धकेलने के लिए इन लोगों का धन्यवाद। मैं दूसरों की मदद करना चाहता हूं क्योंकि स्वीकृत उत्तर छप स्क्रीन करने के लिए अनुशंसित नहीं है।
— जीशान शब्बीर
स्रोत
1
मैंने YouTubeइस बारे में एक ट्यूटोरियल देखा । लेकिन मुझे लगता है कि बिटमैप आकार समस्या होगी क्योंकि आप इसका उपयोग नहीं कर सकते layer-list।
— RoCk RoCk
14

  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>
— सबा
स्रोत
13

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

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

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

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

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

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

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

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

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

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

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

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

— लूटना
स्रोत
12

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

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

"लीकिंग एक्टिविटी" उस स्थिति को संदर्भित करता है जहां कचरा कलेक्टर पुरानी गतिविधि उदाहरण की आवंटित स्मृति को साफ नहीं कर सकता है क्योंकि यह 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;
    }
}

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

— महेश्वर लिगड़े
स्रोत
7

4 के 5 के लिए स्पलैश स्क्रीन पर रोकना अनावश्यक रूप से ज्यादा मायने नहीं रखता है। यह ठीक है अगर आप पृष्ठभूमि में कुछ लोड कर रहे हैं तो स्प्लैश स्क्रीन को लागू करने के लिए इस दृष्टिकोण का पालन करें: - स्प्लैश स्क्रीन को सही तरीके से लागू करना आपके द्वारा कल्पना की गई तुलना में थोड़ा अलग है। आपके द्वारा देखा जाने वाला स्प्लैश दृश्य तुरंत तैयार होना होगा, इससे पहले कि आप अपनी स्प्लैश गतिविधि में एक लेआउट फ़ाइल को बढ़ा सकें।

तो आप एक लेआउट फ़ाइल का उपयोग नहीं करेंगे। इसके बजाय, गतिविधि की थीम पृष्ठभूमि के रूप में अपनी स्प्लैश स्क्रीन की पृष्ठभूमि निर्दिष्ट करें। ऐसा करने के लिए, सबसे पहले, Res / drawable में 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>

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

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

अपने नए SplashTheme में, विंडो की पृष्ठभूमि विशेषता को अपने XML ड्रा करने योग्य पर सेट करें। इसे अपने 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>

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

     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://www.bignerdranch.com/blog/splash-screens-the-right-way/ 2. http://blog.goodbarber.com/3-tips-to-create-a ग्रेट-छप स्क्रीन के लिए अपने-मोबाइल-app_a287.html

— विक्की
स्रोत
4

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

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

ड्राअबल्स में यह 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>

चीयर्स।

— awsleiman
स्रोत
मैं drawable
— viper
मेरा मतलब है कि आपको उपरोक्त वर्णित निर्देशिका में bg_splash.xml बनाना होगा।
— ऐलेसलीमन
4

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

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

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

संक्षेप में:

घोषणा में अपनी SplashScreenActivity की घोषणा करें:

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

अपने SplashScreenActivity.java में:

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

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

}

अपने विषय की पृष्ठभूमि विंडो के लिए अगला स्रोत बनाएँ:

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

ड्रा करने योग्य फ़ाइल स्पलैश। 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>
— डैनी यासीन
स्रोत
4

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

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

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

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

यह एक उदाहरण है कि आप एंड्रॉइड ओएस 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);
    }


}
— हितेश साहू
स्रोत
4

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

नोट: नीचे सभी कोड 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>

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

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

अपने नए SplashTheme में, विंडो की पृष्ठभूमि विशेषता को अपने XML ड्रा करने योग्य पर सेट करें। इसे अपने 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>

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

public class SplashActivity extends AppCompatActivity {

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

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

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

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

— अभि सोनी
स्रोत
3 
public class MainActivity extends Activity {

@Override

public void onCreate(Bundle savedInstanceState) {

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

    Thread t=new Thread()
    {

        public void run()
        {   

            try {

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

            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    t.start();
}
— kamalasekar
स्रोत
2

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

— शंकर गणेश
स्रोत
2

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

public class MainActivity extends Activity {
    private ImageView splashImageView;
    boolean splashloading = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        splashImageView = new ImageView(this);
        splashImageView.setScaleType(ScaleType.FIT_XY);
        splashImageView.setImageResource(R.drawable.ic_launcher);
        setContentView(splashImageView);
        splashloading = true;
        Handler h = new Handler();
        h.postDelayed(new Runnable() {
            public void run() {
                splashloading = false;
                setContentView(R.layout.activity_main);
            }

        }, 3000);

    }

}
— kablu
स्रोत
2

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

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

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

    ...
}
— त्से
स्रोत
इस दृष्टिकोण के लिए एक लाभार्थी है और यह है कि आप सीधे MainActivity लॉन्च कर सकते हैं। उदाहरण के लिए जब आप अपने ऐप में पुश नोटिफिकेशन का उपयोग करते हैं, जब आप सूचना पर क्लिक करके अपने ऐप को लॉन्च कर रहे होते हैं, तो इस तरीके से आप बेहतर नोटिफिकेशन उद्देश्यों का प्रबंधन कर सकते हैं।
— फरनाद तोहदखाह
2

एक और दृष्टिकोण CountDownTimer का उपयोग करके प्राप्त किया गया है

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

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

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

  }.start();
}
— ugur
स्रोत
2 
     - Add in SplashActivity 

   public class SplashActivity extends Activity {

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

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

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

       }

   }

  - Add in activity_splash.xml

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

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


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

   </RelativeLayout>

  - Add in AndroidManifest.xml

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

                   <category android:name="android.intent.category.LAUNCHER" />
               </intent-filter>
           </activity>
— आशीष कुमार
स्रोत
क्या आप कृपया कुछ स्पष्टीकरण भी जोड़ सकते हैं?
— रॉबर्ट
हाँ, ज़रूर ... आप मुझे क्या समझाना चाहते हैं।
— आशीष कुमार
2

वास्तव में आसान और gr8 दृष्टिकोण:

  • निम्नलिखित वेबसाइट के साथ सबसे पहले अपना स्पलैश बनाएं:

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

    अपना लोगो और नारा चुनें, अपनी सुंदर पृष्ठभूमि चुनें। इसे 4096x4096 का आकार बदलें।

  • अब उस चित्र को डाउनलोड करें और उसे ऊपर उठाएँ:

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

    और सभी छप स्क्रीन की जरूरत है, सभी उपकरणों, सभी प्लेटफार्मों उत्पन्न करते हैं।

का आनंद लें!

यहां पर्याप्त उत्तर हैं जो कार्यान्वयन में मदद करेंगे। यह पोस्ट छप स्क्रीन बनाने के पहले चरण के साथ दूसरों की मदद करने के लिए थी!

— jony89
स्रोत
1

कैसे एक सुपर-लचीली लॉन्च स्क्रीन के बारे में जो समान कोड का उपयोग कर सकते हैं और AndroidManifest.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();
    }
  }
}
— जोएल टेपली
स्रोत
1

SplashActivityशायद ही कभी उपयोगकर्ता खुलता है और तुरंत छोड़ देता है लेकिन ऐप अभी भी MainActivityबाद में जाता है 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);
        }                             
   }                                
}

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

— फान वन लिन्ह
स्रोत
1

हालांकि अच्छे उत्तर हैं, मैं Google को अनुशंसित तरीका दिखाऊंगा:

1) पहले Themeस्प्लैश स्क्रीन बनाएं : आपके पास एक थीम है splashscreenTheme, जिसे आपका लॉन्चर थीम कहा जाएगा:

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

ध्यान दें:

android:windowBackgroundपहले से ही अपनी स्प्लैशस्क्रीन छवि
को यूआई में फिर से करने की आवश्यकता नहीं है।

तुम भी एक drawable के बजाय यहाँ रंग का उपयोग कर सकते हैं।

2) स्प्लैशस्क्रीनएक्टिविटी को प्रकट करने के लिए थीम सेट करें

   <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) सुनिश्चित करें कि आप launch_screen drawableनहीं है drawableफ़ोल्डर यदि आपकी छवि छोटे नहीं है।

यह तेजी से लॉन्च स्क्रीन शुरुआत में परिणाम देगा और आपको काली स्क्रीन से बचाएगा

यह अतिरिक्त ओवरड्रॉ से भी बचता है

— ठंडा गलन
स्रोत
1

यह सबसे अच्छी पोस्ट है जो मैंने स्प्लैश स्क्रीन पर देखी है: http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero स्प्लैश स्क्रीन के लिए दो अलग-अलग विकल्पों में जाता है: विंडो बैकग्राउंड का लाभ उठाते हुए अपनी प्रारंभिक स्क्रीन में एनिमेट करना और प्लेसहोल्डर UI प्रदर्शित करना (जो कि एक लोकप्रिय विकल्प है जिसका उपयोग Google इन दिनों अपने अधिकांश ऐप के लिए करता है)।

मैं हर बार इस पोस्ट को संदर्भित करता हूं, मुझे लंबे स्टार्टअप समय के कारण ठंड शुरू करने के समय पर विचार करने और उपयोगकर्ता छोड़ने से बचने की आवश्यकता होती है।

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

— w3bshark
स्रोत
1

मेरे मामले में मैं केवल 2 सेकंड के लिए एक छवि दिखाने के लिए एक नई गतिविधि नहीं बनाना चाहता था। जब मेरी शुरुआत होती है MainAvtivity, तो चित्र पिकस्सो का उपयोग करके धारकों में लोड हो जाते हैं, मुझे पता है कि यह लोड होने में लगभग 1 सेकंड लेता है इसलिए मैंने अपने मेनऐक्टिविटी के अंदर निम्नलिखित करने का निर्णय लिया 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);

आवेदन शुरू करते समय सबसे पहले जो होता है वह ImageViewप्रदर्शित होता है और स्टेटबार को पूर्ण स्क्रीन पर खिड़की के झंडे स्थापित करके हटा दिया जाता है। तब मैं एक प्रयोग Handler, 2 सेकंड के लिए चलाने के लिए 2 सेकंड के बाद मैं पूर्ण स्क्रीन झंडे स्पष्ट और की दृश्यता सेट ImageViewकरने के लिए GONE। आसान, सरल, प्रभावी।

— कक्षा
स्रोत
1

एंड्रॉइड में इसका वास्तव में सरल है हम केवल छप स्क्रीन को लागू करने के लिए हैंडलर अवधारणा का उपयोग करते हैं

अपने SplashScreenActivity जावा फ़ाइल में इस कोड को पेस्ट करें।

अपनी SplashScreenActivity xml फ़ाइल में किसी भी चित्र को इमेजव्यू का उपयोग करते हुए डालें।

public void LoadScreen() {
        final Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {                 
                Intent i = new Intent(SplashScreenActivity.this, AgilanbuGameOptionsActivity.class);
                startActivity(i);
            }
        }, 2000);
    }
— Agilanbu
स्रोत
1

आप इसे अपने ऑनक्रिएट मेथड में जोड़ सकते हैं

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

और अपने समय के मूल्य को मिलीसेकंड में आरंभ करें जैसा कि आप चाहते हैं ...

private  static int time=5000;

अधिक जानकारी के लिए इस लिंक से पूरा कोड डाउनलोड करें ...

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

— अंकित सिंह
स्रोत
1

कोटलिन में यह कोड लिखें: -

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

आशा है कि यह आपकी मदद करेगा। धन्यवाद ........

— राहुल कुशवाहा
स्रोत
0

सरल कोड, यह काम करता है :) सरल छप

int secondsDelayed = 1;
    new Handler().postDelayed(new Runnable() {
        public void run() {
            startActivity(new Intent(LoginSuccessFull.this, LoginActivity.class));
            finish();
        }
    }, secondsDelayed * 1500);
— Agilanbu
स्रोत
0 
public class SplashActivity extends Activity {

  Context ctx;

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

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

              Intent in = new Intent(ctx,MainActivity.class);
              startActivity(in);
              finish();
          }
      };
      thread.start();
  }
}
— ऋषभ दीक्षित
स्रोत
यह एक बुरा उदाहरण है - यदि आप स्पलैशएक्टिविटी से बाहर निकलते हैं तो क्या होता है? धागा अभी भी निष्पादित करेगा।
— मार्क कीन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.