कोटलिन में देरी के बाद एक फ़ंक्शन को कैसे कॉल करें?

Question

शीर्षक के रूप में, देरी के बाद एक फ़ंक्शन को कॉल करने का कोई तरीका है (उदाहरण के लिए 1 सेकंड) Kotlin?

Answer 1

आप अनुसूची का उपयोग कर सकते हैं

inline fun Timer.schedule(
    delay: Long, 
    crossinline action: TimerTask.() -> Unit
): TimerTask (source)

उदाहरण (धन्यवाद @Nguyen मिन्ह बिन्ह - इसे यहाँ पाया गया: http://jamie.mccrindle.org/2013/02/exploring-kotlin-standard-library-part-3.html )

import java.util.Timer
import kotlin.concurrent.schedule

Timer("SettingUp", false).schedule(500) { 
   doSomething()
}

Comments

धन्यवाद! सुपर आसान है। यहां एक उदाहरण मिला जामई .ccrindle.org Timer("SettingUp", false).schedule(500) { doSomething() }

— गुयेन मिन्ह

यह संकलित करता है, यदि आप इन दो आयातों को जोड़ते हैं: java.util.Timer और आयात kotlin.concurrent.schedule आयात

— करें

@ माटियास एलोरियागा, मेरे लिए, इसे एक नई ब्रांड फ़ाइल में संकलित करना, यहां तक ​​कि आयात को जोड़ना भी नहीं है। कस्टमाइज़र ने कहा

— सल्फेन

आपको इसे किसी फ़ाइल पर रखने की आवश्यकता नहीं है, यह विधि stdlib का हिस्सा है, उत्तर की पहली पंक्ति में लिंक का अनुसरण करें,

— Matias Elorriaga

मैंने मूल रूप से सोचा था कि यह आयात करने के बाद भी संकलित नहीं होगा kotlin.concurrent.schedule, क्योंकि कोटलिन ने केवल एक हस्ताक्षर बेमेल की शिकायत की थी, लेकिन तब मुझे एहसास हुआ कि मैं एक लॉन्ग के बजाय एक इंट पास करने की कोशिश कर रहा था। इसे ठीक करने के बाद संकलित किया गया।

— जो लैप

Answer 2

उपयोग करने का एक विकल्प भी है Handler -> postDelayed

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

Comments

कृपया यह जोड़ें कि यह केवल एंड्रॉइड पर उपलब्ध है, क्योंकि प्रश्न सामान्य कोटलिन विधि के लिए पूछता है (हालांकि इसमें एंड्रॉइड टैग है)

— योव स्टर्नबर्ग

यह आपकी तरफ से रचनात्मक नहीं है। परिणामस्वरूप जब उपयोगकर्ता Android टैग खोजेंगे तो सोच सकते हैं कि यह गलत उत्तर है।

— बोगदान उस्त्यक

Android के लिए, टाइमर की तुलना में हैंडलर का उपयोग करना बेहतर है: stackoverflow.com/questions/20330355/timertask-or-handler

— woprandi

मुझे लगता है, आपको गतिविधि / विखंडन खत्म होने के बाद हैंडलर निकालने के लिए एक कोड जोड़ना चाहिए।

— कूलमाइंड

यदि आप ऐसा करने का इरादा रखते हैं तो यह UI थ्रेड पर नहीं चलेगा।

— AndroidDev

Answer 3

कई तरीकों से

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

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

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

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)

Comments

और आपको क्या लगता है कि यहां सबसे अच्छा समाधान है?

— तमीम अताफी

संभवतः एक हैंडलर का उपयोग करने वाला पहला। देखें stackoverflow.com/a/40339630/1159930

— Markymark

Answer 4

आपको निम्नलिखित दो पुस्तकालय आयात करने होंगे:

import java.util.*
import kotlin.concurrent.schedule

और इसके बाद इसे इस तरह से उपयोग करें:

Timer().schedule(10000){
    //do something
}

Answer 5

आप launchएक coroutine कर सकते हैं , delayयह और फिर फ़ंक्शन को कॉल करता है:

 /*GlobalScope.*/launch {
   delay(1000)
   yourFn()
 }

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

Comments

धन्यवाद! अजीब बात है, कि

— कोरटाइन का

@coolMind वे कुछ महीनों से स्थिर हैं, इसलिए वे काफी नए हैं ...

— जोनास विल्म्स

हां, अक्टूबर-नवंबर से, लेकिन पहले से मौजूद था।

— कूलमाइंड

Answer 6

val timer = Timer()
timer.schedule(timerTask { nextScreen() }, 3000)

Comments

क्या आप मुझे समझा सकते हैं कि मुझे सिर्फ ब्रेसिज़ के बजाय "टाइमरटैस्क" लिखने की आवश्यकता क्यों है?

— ह्यूगो पासोस

मुझे लगता है तुम करोगे। Timer.schedule()उम्मीद है TimerTaskकि यह पहली दलील है। kotlin.concurrent.timerTask()एक TimerTaskउदाहरण में दिए गए लंबो को लपेटता है । यहाँ देखें: kotlinlang.org/api/latest/jvm/stdlib/kotlin.concurrent/…

— Blieque

साथ ही, दिए गए उदाहरण को एक पंक्ति में संघनित किया जा सकता है यदि Timerवस्तु का उपयोग एक से अधिक बार नहीं किया जा रहा है, जैसे Timer().schedule(timerTask { ... }, 3000)। एक अधिक कोटलिन के अनुकूल विकल्प भी उपलब्ध है; देखें जोंग्यूअर का जवाब

— ब्लेक

Answer 7

3 सेकंड के बाद एक टोस्ट दिखाने के लिए एक सरल उदाहरण :

fun onBtnClick() {
    val handler = Handler()
    handler.postDelayed({ showToast() }, 3000)
}

fun showToast(){
    Toast.makeText(context, "Its toast!", Toast.LENGTH_SHORT).show()
}

Comments

क्या मैं कॉल रद्द कर सकता हूं?

— एडुआर्डो ओलिवरोस

Answer 8

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

एक वर्ग बनाएं जिसका नाम है Run:

class Run {
    companion object {
        fun after(delay: Long, process: () -> Unit) {
            Handler().postDelayed({
                process()
            }, delay)
        }
    }
}

और इस तरह का उपयोग करें:

Run.after(1000, {
    // print something useful etc.
})

Comments

आप इसे विस्तार के रूप में सरल बना सकते हैं

— व्लाद

@ ऑग्लकैन, अधिक कोटलीन लैम्डा Run.after(1000) { toRun() }। क्या मैं सही हूं

— बिनेबिन

Answer 9

मैंने सिंगलथ्रेड का उपयोग करने की सिफारिश की है क्योंकि आपको इसे उपयोग करने के बाद मारना नहीं है। साथ ही, " स्टॉप ()" विधि को कोटलिन भाषा में चित्रित किया गया है।

private fun mDoThisJob(){

    Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate({
        //TODO: You can write your periodical job here..!

    }, 1, 1, TimeUnit.SECONDS)
}

इसके अलावा, आप इसे समय-समय पर नौकरी के लिए उपयोग कर सकते हैं। यह बहुत उपयोगी है। यदि आप प्रत्येक सेकंड के लिए नौकरी करना चाहते हैं, तो आप इसे निर्धारित कर सकते हैं क्योंकि इसके पैरामीटर:

Executors.newSingleThreadScheduledExecutor ()। ScheduleAtFixedRate (Runnable कमांड, लॉन्ग इनिशियलडेल, लॉन्ग पीरियड, TimeUnit यूनिट);

टाइम यूनिट मान इस प्रकार हैं: नैनोस्कॉन्स, माइक्रोसेन्स, मिल्सनोड्स, SECONDS, मिनट, हॉर्स, दिवस।

@canerkaseler