एंड्रॉइड में देरी के बाद एक विधि कैसे कॉल करें

Question

मैं एक निर्दिष्ट देरी के बाद निम्नलिखित विधि को कॉल करने में सक्षम होना चाहता हूं। उद्देश्य सी में कुछ इस तरह था:

[self performSelector:@selector(DoSomething) withObject:nil afterDelay:5];

क्या जावा के साथ एंड्रॉइड में इस पद्धति के बराबर है? उदाहरण के लिए मुझे 5 सेकंड के बाद एक विधि को कॉल करने में सक्षम होना चाहिए।

public void DoSomething()
{
     //do something here
}

Answer 1

Kotlin

Handler().postDelayed({
  //Do something after 100ms
}, 100)

जावा

final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Comments

यह समाधान केवल यूआई थ्रेड पर उपयोगी है। अन्यथा सामान्य धागे पर, आपको लूपर को लागू करने की आवश्यकता है जो मुझे लगता है कि सबसे अच्छा संस्करण नहीं है

— ओलिवियर_एसडीजी

@olivier_sdg आपको लूपर को लागू करने की आवश्यकता क्यों है?

— djechlin

@djechlin ए हैंडलर को हमेशा एक लूपर से जोड़ा जाना चाहिए, जो वास्तव में रननेबल आप पोस्ट () को संसाधित करेगा। यूआई धागा पहले से ही एक लूपर के साथ आता है, इसलिए आप यूआई थ्रेड और पोस्ट पर सीधे एक नया हैंडलर () बना सकते हैं (इसे चलाने के लिए)। ये Runnables UI थ्रेड पर निष्पादित होते हैं। किसी अन्य थ्रेड पर Runnables निष्पादित करने के लिए, आपको एक नया थ्रेड बनाने की आवश्यकता है, फिर Looper.prepare (), एक नया हैंडलर () और फिर Looper.loop () बनाएं। इस नए हैंडलर पर पोस्ट किया गया कोई भी Runnables इस नए धागे पर अमल करेगा। यदि आप यह सब नहीं करते हैं, तो पोस्ट () अपवाद छोड़ देगा।

— डोरोरो

यदि आपको जरूरत है, तो आप निष्पादन को रद्द भी कर सकते हैं, जब तक कि रननेबल अभी भी संदेश कतार में है कॉल removeCallbacks(Runnable r)करके Handler।

— डेनिस

चाहिएimport android.os.handler

— काका

Answer 2

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

new Timer().schedule(new TimerTask() {          
    @Override
    public void run() {
        // this code will be executed after 2 seconds       
    }
}, 2000);

Comments

यह उन लोगों की तुलना में बेहतर है जो हैंडलर का उपयोग करते हैं, क्योंकि इसमें लोपर मुद्दे नहीं हैं जब हैंडलर यूआई थ्रेड पर नहीं चलाया जाता है।

— बेन एच

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

— पूक्स

ध्यान! यह UI थ्रेड पर नहीं चलता है। यूआई थ्रेड पर इसे चलाने से एक घातक त्रुटि हुई: android.view.ViewRootImpl $ CalledFromWrongThreadException: केवल मूल धागा जिसने दृश्य पदानुक्रम बनाया, उसके विचारों को छू सकता है।

— वॉवहॉस्ट

@vovahost केवल इसलिए कि आप टाइमर ब्लॉक के अंदर यूआई घटकों को अपडेट कर रहे हैं

— टिम

ध्यान दें कि java.util.Timer (और TimerTask) को JDK 9. में चित्रित किया जाएगा। TimerTask उन कार्यों के लिए नए थ्रेड बनाता है जो बहुत अच्छे नहीं हैं।

— वरवारा कलिनािना

Answer 3

नोट: यह उत्तर उस समय दिया गया था जब प्रश्न एंड्रॉइड को संदर्भ के रूप में निर्दिष्ट नहीं करता था। Android UI थ्रेड देखने के लिए विशिष्ट उत्तर के लिए यहां देखें।

---

ऐसा लगता है कि मैक ओएस एपीआई वर्तमान धागे को जारी रखने देता है, और कार्य को अतुल्यकालिक रूप से चलाने के लिए शेड्यूल करता है। जावा में, समकक्ष फ़ंक्शन java.util.concurrentपैकेज द्वारा प्रदान किया जाता है। मुझे यकीन नहीं है कि एंड्रॉइड क्या सीमाएं लगा सकता है।

private static final ScheduledExecutorService worker = 
  Executors.newSingleThreadScheduledExecutor();

void someMethod() {
  ⋮
  Runnable task = new Runnable() {
    public void run() {
      /* Do something… */
    }
  };
  worker.schedule(task, 5, TimeUnit.SECONDS);
  ⋮
}

Comments

यह मेरे लिए

— रननेबल

एक साइड नोट के रूप में: यह आपको बाद में कार्य को रद्द करने की अनुमति देता है , जो कुछ स्थितियों में सहायक हो सकता है। बस ScheduledFuture<?>द्वारा दिए गए संदर्भ को स्टोर worker.schedule()करें और इसकी cancel(boolean)विधि को कॉल करें ।

— डेनिस

मुझे लगता है कि यह उत्तर पुराना है। .Schedule किसी भी समय Runnable की विधि नहीं लगती है ...? : /

— बीट्री

@beetree यह एक तरीका है ScheduledExecutorService।

— एरिकसन

यह काम नहीं करता है यदि ui थ्रेड ऑब्जेक्ट शामिल हैं तो आपको runOnUIThread (new runnable () {run () ....}) को कॉल करना होगा; या रन के अंदर से हैंडलर ऑब्जेक्ट का उपयोग करके एक रननीय पोस्ट () {}

— जयंत अरोरा

Answer 4

5 सेकंड के बाद UI थ्रेड में कुछ निष्पादित करने के लिए:

new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something here
    }
}, 5000);

Comments

पुष्टि करें, लूपर को कॉल को रोकने के लिए और UI थ्रेड में पूरी चीज़ को रखने के लिए यह सबसे अच्छा समाधान है।

— तोबलीग

इसके लिए धन्यवाद, मुझे लूपर्स मुद्दों के साथ मदद मिली :)

— टिया

मैं मुख्य लूपर पर एक हैंडलर बनाने के बारे में सावधान रहूंगा, फिर इस सूत्र में कोई लंबे समय तक कार्य नहीं किया जाना चाहिए

— Shayan_Aryan

Answer 5

आप यूथ्रेड के अंदर हैंडलर का उपयोग कर सकते हैं:

runOnUiThread(new Runnable() {

    @Override
    public void run() {
         final Handler handler = new Handler();
         handler.postDelayed(new Runnable() {
           @Override
           public void run() {
               //add your code here
           }
         }, 1000);

    }
});

Answer 6

सभी महान उत्तरों के लिए धन्यवाद, मुझे एक समाधान मिला जो मेरी आवश्यकताओं के लिए सबसे अच्छा है।

Handler myHandler = new DoSomething();
Message m = new Message();
m.obj = c;//passing a parameter here
myHandler.sendMessageDelayed(m, 1000);

class DoSomething extends Handler {
    @Override
    public void handleMessage(Message msg) {
      MyObject o = (MyObject) msg.obj;
      //do something here
    }
}

Comments

क्या यह ठीक है अगर मैं किसी आइटम के क्लिक पर टच फीडबैक लेने के लिए इस दृष्टिकोण का उपयोग करता हूं .. view.setColor (some_color) और फिर x सेकंड के बाद हैंडलर में इस रंग को हटा दें ...?

— eRaisedToX

Answer 7

Kotlinऔर Javaकई तरीके

1. उपयोग करना Handler

Handler().postDelayed({
    TODO("Do something")
    }, 2000)

2. टाइमर का उपयोग करना

Timer().schedule(object : TimerTask() {
    override fun run() {
        TODO("Do something")
    }
}, 2000)

या उससे भी कम

Timer().schedule(timerTask {
    TODO("Do something")
}, 2000)

या सबसे छोटा होगा

Timer().schedule(2000) {
    TODO("Do something")
}

3. उपयोग करना Executors

Executors.newSingleThreadScheduledExecutor().schedule({
    TODO("Do something")
}, 2, TimeUnit.SECONDS)

जावा में

1. उपयोग करना Handler

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something
    }
}, 2000);

2. उपयोग करना Timer

new Timer().schedule(new TimerTask() {          
    @Override
    public void run() {
        // Do something
    }
}, 2000);

3. उपयोग करना ScheduledExecutorService

private static final ScheduledExecutorService worker = Executors.newSingleThreadScheduledExecutor();

Runnable runnable = new Runnable() {
  public void run() {
      // Do something
  }
  };
worker.schedule(runnable, 2, TimeUnit.SECONDS);

Comments

@JanRabe आपके सुझाव के लिए धन्यवाद। मैं इसका अनुमोदन करता हूं। हालांकि सवाल यह है How to call a method after a delay in Android। इसलिए मैंने उस पर ध्यान केंद्रित किया। मुद्दे पर। अन्यथा जावा लीक डेवलपर्स के लिए अलग से समझने का एक बड़ा विषय है।

— खेमराज

Answer 8

देखें यह डेमो:

import java.util.Timer;
import java.util.TimerTask;

class Test {
     public static void main( String [] args ) {
          int delay = 5000;// in ms 

          Timer timer = new Timer();

          timer.schedule( new TimerTask(){
             public void run() { 
                 System.out.println("Wait, what..:");
              }
           }, delay);

           System.out.println("Would it run?");
     }
}

Answer 9

यदि आपको हैंडलर का उपयोग करना है, लेकिन आप किसी अन्य थ्रेड में हैं, तो आप runonuithreadहैंडलर को UI थ्रेड में चलाने के लिए उपयोग कर सकते हैं । यह आपको कॉल करने के लिए कहे गए अपवादों से बचाएगाLooper.Prepare()

runOnUiThread(new Runnable() {
    @Override
    public void run() {
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //Do something after 1 second
            }
        }, 1000);
    }
});

देखने में काफी गन्दा लगता है, लेकिन यह एक तरीका है।

Comments

यह काम करता है, मैं बेवकूफ पोस्ट के कारण आपके पोस्ट को संपादित नहीं कर सकता क्योंकि न्यूनतम 6 वर्णों को संपादित करने के लिए नियम हैं, लेकिन 'नया हैंडलर' के बाद '' () गायब है, यह 'नया हैंडलर' () होना चाहिए

— जोनाथन मुलर

UI थ्रेड में सब कुछ रखने के बजाय, आप कर सकते हैं: नया हैंडलर (Looper.getMainLooper ())

— तोबलीग

Answer 10

मैं View.postDelayed()नीचे दी गई विधि, सरल कोड का उपयोग करना पसंद करता हूं :

mView.postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do something after 1000 ms
    }
}, 1000);

Comments

क्या यह स्वयं ui तत्व को फ्रीज नहीं करता है, क्योंकि यह दृश्य हैंडलर पर अनुसूचित होगा?

— जैकसोफ़

नहीं, पोस्ट किए गए कार्य को 1 सेकंड में निष्पादित किया जाएगा, लेकिन इस दूसरे UI थ्रेड के दौरान अन्य उपयोगी काम करता है

— demaksee

Answer 11

यहाँ मेरा सबसे छोटा समाधान है:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something after 100ms
    }
}, 100);

Answer 12

final Handler handler = new Handler(); 
Timer t = new Timer(); 
t.schedule(new TimerTask() { 
    public void run() { 
        handler.post(new Runnable() { 
            public void run() { 
                //DO SOME ACTIONS HERE , THIS ACTIONS WILL WILL EXECUTE AFTER 5 SECONDS...
            }
        }); 
    } 
}, 5000); 

Answer 13

यदि आप एंड्रॉइड स्टूडियो 3.0 और इसके बाद के संस्करण का उपयोग कर रहे हैं तो आप लैम्बडा एक्सप्रेशन का उपयोग कर सकते हैं। विधि callMyMethod()2 सेकंड के बाद कहा जाता है:

new Handler().postDelayed(() -> callMyMethod(), 2000);

इस मामले में आपको देरी से चलने योग्य उपयोग को रद्द करने की आवश्यकता है:

Handler handler = new Handler();
handler.postDelayed(() -> callMyMethod(), 2000);

// When you need to cancel all your posted runnables just use:
handler.removeCallbacksAndMessages(null);

Comments

हम इसे कैसे रद्द कर सकते हैं?

— दमिया

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

— टॉमडक

Answer 14

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

अन्य विकल्प, प्रतीक्षा () है; विधि, यह वर्तमान थ्रेड को निर्दिष्ट लंबाई के लिए ब्लॉक करेगा। यदि आप UI थ्रेड पर ऐसा करते हैं तो इससे आपका UI प्रतिक्रिया करना बंद कर देगा।

Comments

Thread.sleep () Object.wait () से बेहतर है। प्रतीक्षा का तात्पर्य है कि आप अधिसूचित होने की उम्मीद करते हैं और कुछ गतिविधि के आसपास सिंक्रनाइज़ कर रहे हैं। नींद इंगित करती है कि आप कुछ निर्दिष्ट समय के लिए कुछ नहीं करना चाहते हैं। यदि आप कार्रवाई को बाद के कुछ समय में अतुल्यकालिक रूप से चाहते हैं तो जाने का तरीका है।

— टिम बेंडर

यह सच है। यही कारण है कि मैंने इसे दूसरे विकल्प के रूप में सूचीबद्ध किया ;-)

— नैट

Answer 15

एक साधारण लाइन हैंडल पोस्ट देरी के लिए, आप निम्न कार्य कर सकते हैं:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do someting
    }
}, 3000);

आशा है कि ये आपकी मदद करेगा

Answer 16

आप सरल समाधान के लिए इसका उपयोग कर सकते हैं:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Write your code here
    }
}, 5000); //Timer is in ms here.

नीचे, एक और साफ उपयोगी समाधान हो सकता है:

new Handler().postDelayed(() -> 
{/*Do something here*/}, 
5000); //time in ms

Answer 17

आप नए शुरू किए गए लैम्ब्डा एक्सप्रेशंस का उपयोग करके इसे ज्यादा साफ कर सकते हैं:

new Handler().postDelayed(() -> {/*your code here*/}, time);

Answer 18

तो यहाँ पर विचार करने के लिए कुछ चीजें हैं क्योंकि इस बिल्ली की त्वचा के लिए बहुत सारे तरीके हैं। हालांकि उत्तर सभी को पहले से ही चुना और चुना गया है। मुझे लगता है कि यह महत्वपूर्ण है कि उचित कोडिंग दिशा-निर्देशों के साथ यह संशोधित हो जाए कि किसी को भी गलत दिशा में जाने से बचने के लिए "बहुमत चयनित सरल उत्तर" के कारण।

तो पहले आइए सरल पोस्ट विलंबित उत्तर पर चर्चा करते हैं जो इस थ्रेड में समग्र रूप से चयनित विजेता है।

कुछ बातों पर विचार करें। पोस्ट देरी के बाद, आप मेमोरी लीक, मृत वस्तुओं, जीवन चक्रों का सामना कर सकते हैं जो चले गए हैं, और बहुत कुछ। इसलिए इसे ठीक से संभालना भी महत्वपूर्ण है। आप इसे कुछ तरीकों से कर सकते हैं।

आधुनिक विकास के लिए, मैं कोटलिन में आपूर्ति करूँगा

यहां कॉलबैक पर UI थ्रेड का उपयोग करने का एक सरल उदाहरण है और पुष्टि करता है कि जब आप अपने कॉलबैक को हिट करते हैं तो आपकी गतिविधि अभी भी जीवित है और अच्छी तरह से है।

  Handler(Looper.getMainLooper()).postDelayed({
            if(activity != null && activity?.isFinishing == false){
                txtNewInfo.visibility = View.GONE
            }
        }, NEW_INFO_SHOW_TIMEOUT_MS)

हालांकि, यह अभी भी सही नहीं है क्योंकि यदि गतिविधि दूर हो गई है तो आपके कॉलबैक को हिट करने का कोई कारण नहीं है। इसलिए एक बेहतर तरीका यह होगा कि आप इसका संदर्भ रखें और इस तरह से कॉलबैक को हटा दें।

    private fun showFacebookStylePlus1NewsFeedOnPushReceived(){
        A35Log.v(TAG, "showFacebookStylePlus1NewsFeedOnPushReceived")
        if(activity != null && activity?.isFinishing == false){
            txtNewInfo.visibility = View.VISIBLE
            mHandler.postDelayed({
                if(activity != null && activity?.isFinishing == false){
                    txtNewInfo.visibility = View.GONE
                }
            }, NEW_INFO_SHOW_TIMEOUT_MS)
        }
    }

और निश्चित रूप से ऑनपॉज पर सफाई को संभालें ताकि यह कॉलबैक को हिट न करे।

    override fun onPause() {
        super.onPause()
        mHandler.removeCallbacks(null)
    }

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

   fun doActionAfterDelay() 
        launch(UI) {
            delay(MS_TO_DELAY)           
            actionToTake()
        }
    }

या यदि आप हमेशा उस तरीके से यूआई लॉन्च करना चाहते हैं जो आप कर सकते हैं:

  fun doActionAfterDelay() = launch(UI){ 
      delay(MS_TO_DELAY)           
      actionToTake()
  }

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

var mDelayedJob: Job? = null
fun doActionAfterDelay() 
   mDelayedJob = launch(UI) {
            try {
               delay(MS_TO_DELAY)           
               actionToTake()
            }catch(ex: JobCancellationException){
                showFancyToast("Delayed Job canceled", true, FancyToast.ERROR, "Delayed Job canceled: ${ex.message}")
            }
        }
   }
}

// संभाल सफाई

override fun onPause() {
   super.onPause()
   if(mDelayedJob != null && mDelayedJob!!.isActive) {
      A35Log.v(mClassTag, "canceling delayed job")
      mDelayedJob?.cancel() //this should throw CancelationException in coroutine, you can catch and handle appropriately
   }
}

यदि आप लॉन्च (यूआई) को विधि हस्ताक्षर में रखते हैं तो कोड की कॉलिंग लाइन में काम सौंपा जा सकता है।

इसलिए कहानी की नैतिकता आपके विलंबित कार्यों से सुरक्षित है, सुनिश्चित करें कि आप अपने कॉलबैक को हटा दें, या अपनी नौकरियों को रद्द कर दें और निश्चित रूप से पुष्टि करें कि आपके देरी कॉलबैक पूर्ण होने पर वस्तुओं को छूने के लिए आपके पास सही जीवन चक्र है। Coroutines रद्द करने योग्य कार्रवाई भी करता है।

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

   mLoadJob = launch(UI){
            try {
                //Applies timeout
                withTimeout(4000) {
                    //Moves to background thread
                    withContext(DefaultDispatcher) {
                        mDeviceModelList.addArrayList(SSDBHelper.getAllDevices())
                    }
                }

                //Continues after async with context above
                showFancyToast("Loading complete", true, FancyToast.SUCCESS)
            }catch(ex: JobCancellationException){
                showFancyToast("Save canceled", true, FancyToast.ERROR, "Save canceled: ${ex.message}")
            }catch (ex: TimeoutCancellationException) {
                showFancyToast("Timed out saving, please try again or press back", true, FancyToast.ERROR, "Timed out saving to database: ${ex.message}")
            }catch(ex: Exception){
                showFancyToast("Error saving to database, please try again or press back", true, FancyToast.ERROR, "Error saving to database: ${ex.message}")
            }
        }

Comments

कोई बात नहीं, राजीव, मैं इसे एक कदम आगे ले जाऊंगा और जिक्र करूंगा कि लाइव डेटा का उपयोग करने से कॉरपिन जीवन चक्र से अवगत हो सकते हैं और सफाई कॉल से बचने के लिए स्वयं को रद्द कर सकते हैं, लेकिन एक उत्तर में बहुत सारे सीखने वाले घटता को फेंकना नहीं चाहते;)

— सैम

Answer 19

मैंने इसे कॉल करने के लिए सरल विधि बनाई।

public static void CallWithDelay(long miliseconds, final Activity activity, final String methodName)
    {
        new Handler().postDelayed(new Runnable() {

            @Override
            public void run() {
                try {
                    Method method =  activity.getClass().getMethod(methodName);
                    method.invoke(activity);
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }, miliseconds);
    }

इसका उपयोग करने के लिए, बस कॉल करें: .CallWithDelay(5000, this, "DoSomething");

Comments

इस तरह के मूल कार्य के लिए चिंतन?

— मैक्स च

चूंकि प्रश्न विधि iOS के समान है performSelector। यह करने का सबसे अच्छा तरीका है।

— हेल्मीबी

Answer 20

एक काम के नीचे जब आप मिलते हैं,

java.lang.RuntimeException: हैंडलर को थ्रेड के अंदर नहीं बना सकते हैं जिसे Looper.prepare () नहीं कहा जाता है

final Handler handler = new Handler(Looper.getMainLooper());
handler.postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Answer 21

कोटलिन का उपयोग करके, हम निम्नलिखित कार्य करके प्राप्त कर सकते हैं

Handler().postDelayed({
    // do something after 1000ms 
}, 1000)

Answer 22

इसका उपयोग करना बहुत आसान है CountDownTimer। अधिक जानकारी के लिए https://developer.android.com/reference/android/os/CountDownTimer.html

import android.os.CountDownTimer;

// calls onTick every second, finishes after 3 seconds
new CountDownTimer(3000, 1000) { 

   public void onTick(long millisUntilFinished) {
      Log.d("log", millisUntilFinished / 1000);
   }

   public void onFinish() {
      // called after count down is finished
   } 
}.start();

Answer 23

यदि आप RxAndroid का उपयोग करते हैं तो थ्रेड और एरर हैंडलिंग बहुत आसान हो जाता है। निम्नलिखित कोड देरी के बाद निष्पादित करता है

   Observable.timer(delay, TimeUnit.SECONDS)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(aLong -> {
           // Execute code here
        }, Throwable::printStackTrace);

Answer 24

हर कोई एक नया runnable या संदेश पोस्ट करने से पहले हैंडलर को साफ करना भूल जाता है। दूसरे वे संभावित रूप से खराब व्यवहार का कारण बन सकते हैं।

handler.removeMessages(int what);
// Remove any pending posts of messages with code 'what' that are in the message queue.

handler.removeCallbacks(Runnable r)
// Remove any pending posts of Runnable r that are in the message queue.

Answer 25

यहां एक और पेचीदा तरीका है: यह अपवाद नहीं फेंकेगा जब रन करने योग्य यूआई तत्व बदल जाएंगे।

public class SimpleDelayAnimation extends Animation implements Animation.AnimationListener {

    Runnable callBack;

    public SimpleDelayAnimation(Runnable runnable, int delayTimeMilli) {
        setDuration(delayTimeMilli);
        callBack = runnable;
        setAnimationListener(this);
    }

    @Override
    public void onAnimationStart(Animation animation) {

    }

    @Override
    public void onAnimationEnd(Animation animation) {
        callBack.run();
    }

    @Override
    public void onAnimationRepeat(Animation animation) {

    }
}

आप इस तरह एनीमेशन को कॉल कर सकते हैं:

view.startAnimation(new SimpleDelayAnimation(delayRunnable, 500));

एनिमेशन किसी भी दृश्य से जुड़ सकता है।

Answer 26

यहाँ जवाब में कोटलिन आप आलसी, आलसी लोग हैं:

Handler().postDelayed({
//doSomethingHere()
}, 1000)

Answer 27

मुझे क्लीनर पसंद है: यहां मेरा कार्यान्वयन है, इनलाइन कोड आपके तरीके के अंदर उपयोग करने के लिए

new Handler().postDelayed(new Runnable() {
  @Override
  public void run() {
    //Do something after 100ms
  }
}, 100);

Answer 28

Android में एक उपयुक्त समाधान:

private static long SLEEP_TIME = 2 // for 2 second
.
.
MyLauncher launcher = new MyLauncher();
            launcher.start();
.
.
private class MyLauncher extends Thread {
        @Override
        /**
         * Sleep for 2 seconds as you can also change SLEEP_TIME 2 to any. 
         */
        public void run() {
            try {
                // Sleeping
                Thread.sleep(SLEEP_TIME * 1000);
            } catch (Exception e) {
                Log.e(TAG, e.getMessage());
            }
            //do something you want to do
           //And your code will be executed after 2 second
        }
    }

Answer 29

इसी तरह के समाधान लेकिन बहुत क्लीनर का उपयोग करने के लिए

इस फ़ंक्शन को कक्षा के बाहर लिखें

fun delay(duration: Long, `do`: () -> Unit) {

    Handler().postDelayed(`do`, duration)

}

उपयोग:

delay(5000) {
    //Do your work here
}

Comments

`क्या` करता है?

— स्किज़ो-ओज़स

बस एक नाम, वहाँ कुछ भी रखो। doएक इनबिल्ट विधि है, इसलिए हमें `चर नाम के रूप में उपयोग करने के लिए` का उपयोग करना है

— मनोहर रेड्डी

धन्यवाद, लेकिन इस चर नाम का उपयोग क्यों किया जाता है? मेरा मतलब है कि इसका क्या कार्य है।

— स्किज़ो-ओज़स

मैंने do3 सेकंड की देरी के बाद ऐसा सोचा था

— मनोहर रेड्डी

Answer 30

एंड्रॉइड में, हम किसी भी फ़ंक्शन के विलंब निष्पादन के लिए कोटलिन कोड नीचे लिख सकते हैं

class MainActivity : AppCompatActivity() {

private lateinit var handler: Handler

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    handler= Handler()
    handler.postDelayed({
        doSomething()
    },2000)
}

private fun doSomething() {
    Toast.makeText(this,"Hi! I am Toast Message",Toast.LENGTH_SHORT).show()
}
}