So rufen Sie eine Methode nach einer Verzögerung in Android auf

769

Ich möchte die folgende Methode nach einer bestimmten Verzögerung aufrufen können. In Ziel c gab es so etwas wie:

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

Gibt es ein Äquivalent dieser Methode in Android mit Java? Zum Beispiel muss ich in der Lage sein, nach 5 Sekunden eine Methode aufzurufen.

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

Antworten:

1858

Kotlin

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


Java

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


Kontinuität
quelle
109
Diese Lösung ist nur für UI-Threads nützlich. Andernfalls müssen Sie auf einem normalen Thread einen Looper implementieren, der meiner Meinung nach nicht die beste Version ist
olivier_sdg
2
@olivier_sdg warum musst du looper implementieren?
Djechlin
37
@djechlin Ein Handler muss immer mit einem Looper verknüpft sein, der das von Ihnen gepostete Runnable () tatsächlich verarbeitet. Der UI-Thread wird bereits mit einem Looper geliefert, sodass Sie einfach einen neuen Handler () im UI-Thread erstellen und Runnables direkt darauf posten können. Diese Runnables werden im UI-Thread ausgeführt. Damit Runnables auf einem anderen Thread ausgeführt werden kann, müssen Sie einen neuen Thread erstellen, dann Looper.prepare (), einen neuen Handler () und dann Looper.loop (). Alle in diesem neuen Handler veröffentlichten Runnables werden in diesem neuen Thread ausgeführt. Wenn Sie dies alles nicht tun, löst post () eine Ausnahme aus.
Dororo
12
Im Fall , dass Sie, können Sie auch abbrechen , die Ausführung, solange die Runnable durch den Aufruf noch in der Nachrichten - Warteschlange sind removeCallbacks(Runnable r)auf dem Handler.
Dennis
9
sollteimport android.os.handler
KaKa
322

Ich konnte keine der anderen Antworten in meinem Fall verwenden. Ich habe stattdessen den nativen Java-Timer verwendet.

new Timer().schedule(new TimerTask() {          
    @Override
    public void run() {
        // this code will be executed after 2 seconds       
    }
}, 2000);
Jules Colle
quelle
43
Dies ist besser als diejenigen, die Handler verwenden, da es keine Looper-Probleme gibt, wenn der Handler nicht auf dem UI-Thread ausgeführt wird.
Ben H
32
Sie sollten einen Verweis auf Ihren Timer behalten, um ihn abzubrechen, wenn er nicht mehr benötigt wird, da laut Android-Dokument: "Wenn ein Timer nicht mehr benötigt wird, sollten Benutzer cancel () aufrufen, wodurch der Thread des Timers und andere Ressourcen freigegeben werden. Nicht explizit abgebrochene Timer können Ressourcen auf unbestimmte Zeit speichern. "
Pooks
14
Beachtung! Dies läuft nicht auf dem UI-Thread. Das Ausführen auf einem UI-Thread verursachte einen schwerwiegenden Fehler: android.view.ViewRootImpl $ CalledFromWrongThreadException: Nur der ursprüngliche Thread, der eine Ansichtshierarchie erstellt hat, kann seine Ansichten berühren.
Vovahost
13
@vovahost das ist nur, weil Sie UI-Komponenten innerhalb des Timer-Blocks aktualisieren
Tim
10
Beachten Sie, dass java.util.Timer (und TimerTask) in JDK 9 veraltet sind. TimerTask erstellt neue Threads für Aufgaben, die nicht sehr gut sind.
Varvara Kalinina
183

Hinweis: Diese Antwort wurde gegeben, als in der Frage Android nicht als Kontext angegeben wurde. Eine Antwort speziell für den Android-UI-Thread finden Sie hier.


Es sieht so aus, als ob die Mac OS-API den aktuellen Thread fortsetzen lässt und die asynchrone Ausführung der Aufgabe plant. In Java wird die entsprechende Funktion vom java.util.concurrentPaket bereitgestellt. Ich bin mir nicht sicher, welche Einschränkungen Android auferlegen könnte.

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

void someMethod() {
  
  Runnable task = new Runnable() {
    public void run() {
      /* Do something… */
    }
  };
  worker.schedule(task, 5, TimeUnit.SECONDS);
  
}
erickson
quelle
3
Dies nennt mich nie den Runnable
Supuhstar
14
Als Randnotiz: Auf diese Weise können Sie die Aufgabe auch später abbrechen , was in einigen Situationen hilfreich sein kann. Speichern Sie einfach einen Verweis auf das ScheduledFuture<?>zurückgegebene von worker.schedule()und rufen Sie dessen cancel(boolean)Methode auf.
Dennis
Ich denke, diese Antwort ist veraltet. .schedule scheint keine Runnable-Methode mehr zu sein ...? : /
Beetree
5
@beetree es ist eine Methode auf ScheduledExecutorService.
erickson
3
Dies funktioniert nicht, wenn UI-Thread-Objekte beteiligt sind. Sie müssen runOnUIThread (new runnable () {run () ....}) aufrufen. oder poste eine ausführbare Datei mit einem Handler-Objekt aus dem Lauf () {}
Jayant Arora
107

Für die Ausführung von etwas im UI-Thread nach 5 Sekunden:

new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something here
    }
}, 5000);
pomber
quelle
8
Bestätigen Sie, dass dies die beste Lösung ist, um den Aufruf von looper.prepare zu verhindern und das Ganze in den UI-Thread zu platzieren.
Tobliug
Danke dafür, hat mir bei Looper-Problemen geholfen :)
Tia
1
Ich würde vorsichtig sein, wenn ich einen Handler auf dem Hauptschleifer erstellen würde, dann sollte in diesem Thread keine Langzeitaufgabe erledigt werden
Shayan_Aryan
40

Sie können Handler in UIThread verwenden:

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

    }
});
Hossam Ghareeb
quelle
36

Vielen Dank für all die tollen Antworten. Ich habe eine Lösung gefunden, die meinen Anforderungen am besten entspricht.

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
    }
}
aryaxt
quelle
Ist es in Ordnung, wenn ich diesen Ansatz verwende, um beim Klicken auf ein Element ein Touch-Feedback zu erhalten .. view.setColor (some_color) und diese Farbe nach x Sekunden im Handler zu entfernen ...?
eRaisedToX
24

Kotlin& JavaViele Möglichkeiten

1. Verwenden von Handler

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

2. Verwenden von TimerTask

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

Oder noch kürzer

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

Oder am kürzesten wäre

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

3. Verwenden von Executors

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

In Java

1. Verwenden von Handler

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

2. Verwenden von Timer

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

3. Verwenden von ScheduledExecutorService

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

Runnable runnable = new Runnable() {
  public void run() {
      // Do something
  }
  };
worker.schedule(runnable, 2, TimeUnit.SECONDS);
Khemraj
quelle
1
@ JanRabe Danke für deinen Vorschlag. Ich schätze es. Die Frage ist jedoch How to call a method after a delay in Android. Darauf habe ich mich konzentriert. Auf den Punkt. Andernfalls ist Java-Lecks ein großes Thema, das Entwickler separat verstehen müssen.
Khemraj
20

Sehen Sie diese Demo:

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?");
     }
}
OscarRyz
quelle
20

Wenn Sie den Handler verwenden müssen, sich aber in einem anderen Thread befinden, können Sie runonuithreadden Handler im UI-Thread ausführen. Dies erspart Ihnen Ausnahmen, die beim Anruf ausgelöst werdenLooper.Prepare()

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

Sieht ziemlich chaotisch aus, aber das ist einer der Wege.

Anfänger
quelle
4
Dies funktioniert, ich kann Ihren Beitrag wegen dummer SO-Regeln mit mindestens 6 zu bearbeitenden Zeichen nicht bearbeiten, aber nach 'neuer Handler' fehlt '()', es sollte 'neuer Handler ()' sein
Jonathan Muller
2
Anstatt alles in den UI-Thread zu platzieren, können Sie Folgendes tun: neuer Handler (Looper.getMainLooper ())
Tobliug
17

Ich bevorzuge die View.postDelayed()Methode, einfachen Code unten:

mView.postDelayed(new Runnable() {
    @Override
    public void run() {
        // Do something after 1000 ms
    }
}, 1000);
codezjx
quelle
1
Friert es nicht das UI-Element selbst ein, weil es im Views-Handler geplant wird?
JacksOnF1re
1
Nein, die gepostete Aufgabe wird in 1 Sekunde ausgeführt, aber während dieses zweiten UI-Threads werden andere nützliche Arbeiten ausgeführt
demaksee
14

Hier ist meine kürzeste Lösung:

new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        //Do something after 100ms
    }
}, 100);
Alecs
quelle
10
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); 
Vishnu
quelle
10

Wenn Sie Android Studio 3.0 und höher verwenden, können Sie Lambda-Ausdrücke verwenden. Die Methode callMyMethod()wird nach 2 Sekunden aufgerufen:

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

Falls Sie die verzögerte Ausführung abbrechen müssen, verwenden Sie Folgendes:

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

// When you need to cancel all your posted runnables just use:
handler.removeCallbacksAndMessages(null);
vovahost
quelle
Wie können wir das abbrechen?
Damia Fuentes
Ich bin überrascht, wie viele hier gerne auf Kotlin umsteigen werden, aber Lambda Expressions, die Standard-Java sind, völlig ignorieren.
TomDK
6

Ich schlage den Timer vor , mit dem Sie eine Methode planen können, die in einem bestimmten Intervall aufgerufen werden soll. Dadurch wird Ihre Benutzeroberfläche nicht blockiert und Ihre App bleibt während der Ausführung der Methode reaktionsfähig.

Die andere Option ist wait (); Methode blockiert dies den aktuellen Thread für die angegebene Zeitdauer. Dies führt dazu, dass Ihre Benutzeroberfläche nicht mehr reagiert, wenn Sie dies im UI-Thread tun.

Nate
quelle
2
Thread.sleep () ist besser als Object.wait (). Warten bedeutet, dass Sie eine Benachrichtigung erwarten und sich um eine Aktivität synchronisieren. Schlaf zeigt an, dass Sie für eine bestimmte Zeit einfach nichts tun möchten. Der Timer ist der richtige Weg, wenn die Aktion zu einem späteren Zeitpunkt asynchron ausgeführt werden soll.
Tim Bender
1
Das ist wahr. Deshalb habe ich es als eine andere Option aufgeführt ;-)
Nate
6

Für eine Verzögerung bei der einfachen Zeilenbehandlung können Sie wie folgt vorgehen:

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

ich hoffe das hilft

MrG
quelle
5

Sie können dies für die einfachste Lösung verwenden:

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

Andernfalls kann unten eine andere saubere nützliche Lösung sein:

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

Sie können es viel sauberer machen, indem Sie die neu eingeführten Lambda-Ausdrücke verwenden:

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

Es gibt also ein paar Dinge zu beachten, da es so viele Möglichkeiten gibt, diese Katze zu häuten. Obwohl alle Antworten bereits ausgewählt und ausgewählt wurden. Ich denke, es ist wichtig, dass dies mit den richtigen Codierungsrichtlinien überprüft wird, um zu vermeiden, dass jemand in die falsche Richtung geht, nur weil "die Mehrheit die einfache Antwort ausgewählt hat".

Lassen Sie uns zunächst die einfache Antwort "Post Delayed" diskutieren, bei der es sich insgesamt um die vom Gewinner ausgewählte Antwort in diesem Thread handelt.

Ein paar Dinge zu beachten. Nach der Nachverzögerung können Speicherlecks, tote Objekte, verschwundene Lebenszyklen und mehr auftreten. Daher ist es auch wichtig, richtig damit umzugehen. Sie können dies auf verschiedene Arten tun.

Für die moderne Entwicklung werde ich in KOTLIN liefern

Hier ist ein einfaches Beispiel für die Verwendung des UI-Threads bei einem Rückruf und die Bestätigung, dass Ihre Aktivität noch aktiv ist, wenn Sie Ihren Rückruf ausführen.

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

Dies ist jedoch immer noch nicht perfekt, da es keinen Grund gibt, Ihren Rückruf zu tätigen, wenn die Aktivität abgebrochen wurde. Ein besserer Weg wäre es, einen Verweis darauf zu behalten und die Rückrufe wie diesen zu entfernen.

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

und natürlich die Bereinigung in der onPause durchführen, damit der Rückruf nicht getroffen wird.

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

Nachdem wir das Offensichtliche besprochen haben, sprechen wir über eine sauberere Option mit modernen Coroutinen und Kotlin :). Wenn Sie diese noch nicht verwenden, verpassen Sie sie wirklich.

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

oder wenn Sie mit dieser Methode immer einen UI-Start durchführen möchten, können Sie einfach Folgendes tun:

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

Natürlich müssen Sie genau wie beim PostDelayed sicherstellen, dass Sie mit dem Abbrechen umgehen, damit Sie entweder die Aktivitätsprüfungen nach dem Verspätungsaufruf durchführen oder sie in der onPause wie auf der anderen Route abbrechen können.

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

// Bereinigung behandeln

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

Wenn Sie den Start (UI) in die Methodensignatur einfügen, kann der Job in der aufrufenden Codezeile zugewiesen werden.

Die Moral der Geschichte ist es also, mit Ihren verspäteten Aktionen sicher zu sein, sicherzustellen, dass Sie Ihre Rückrufe entfernen oder Ihre Jobs stornieren, und natürlich zu bestätigen, dass Sie den richtigen Lebenszyklus haben, um Elemente Ihres verspäteten Rückrufs vollständig zu berühren. Die Coroutinen bieten auch stornierbare Aktionen an.

Es ist auch erwähnenswert, dass Sie normalerweise die verschiedenen Ausnahmen behandeln sollten, die mit Coroutinen einhergehen können. Zum Beispiel eine Stornierung, eine Ausnahme, eine Zeitüberschreitung, was auch immer Sie verwenden möchten. Hier ist ein fortgeschritteneres Beispiel, wenn Sie sich entscheiden, Coroutinen wirklich zu verwenden.

   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}")
            }
        }
Sam
quelle
1
Kein Problem, Rajiv, ich würde noch einen Schritt weiter gehen und erwähnen, dass die Coroutinen bei Verwendung von Live-Daten lebenszyklusbewusst und selbstaufhebend sein können, um die Bereinigungsaufrufe zu vermeiden, aber nicht zu viele Lernkurven in eine Antwort werfen möchten;)
Sam
3

Ich habe eine einfachere Methode erstellt, um dies aufzurufen.

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

Um es zu benutzen, rufen Sie einfach an: .CallWithDelay(5000, this, "DoSomething");

HelmiB
quelle
3
Reflexion für eine solche Grundaufgabe?
Max Ch
Da die Frage Methode ähnlich wie iOS aufzurufen performSelector. Dies ist der beste Weg.
HelmiB
3

Unten funktioniert man, wenn man bekommt,

java.lang.RuntimeException: Handler in Thread, der nicht Looper.prepare () aufgerufen hat, kann nicht erstellt werden

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

Mit Kotlin können wir Folgendes erreichen

Handler().postDelayed({
    // do something after 1000ms 
}, 1000)
Nikhil Katekhaye
quelle
2

Es ist sehr einfach mit dem CountDownTimer. Weitere Informationen finden Sie unter 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();
Abdul Rizwan
quelle
2

Wenn Sie RxAndroid verwenden, wird die Behandlung von Threads und Fehlern viel einfacher. Der folgende Code wird nach einer Verzögerung ausgeführt

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

Jeder scheint zu vergessen, den Handler zu bereinigen, bevor er eine neue ausführbare Datei oder Nachricht darauf veröffentlicht. Andernfalls könnten sie sich möglicherweise ansammeln und schlechtes Verhalten verursachen.

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.
Dan Alboteanu
quelle
1

Hier ist ein weiterer kniffliger Weg: Es wird keine Ausnahme ausgelöst, wenn die ausführbaren Elemente der Benutzeroberfläche geändert werden.

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

    }
}

Sie können die Animation folgendermaßen aufrufen:

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

Die Animation kann an jede Ansicht angehängt werden.

cdytoby
quelle
1

Hier ist die Antwort in Kotlin, ihr faulen, faulen Leute:

Handler().postDelayed({
//doSomethingHere()
}, 1000)
Daniel Wilson
quelle
1

Ich mag Dinge sauberer: Hier ist meine Implementierung, Inline-Code, der in Ihrer Methode verwendet werden kann

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

Eine geeignete Lösung für 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
        }
    }
Faakhir
quelle
0

Ähnliche Lösung, aber viel sauberer zu verwenden

Schreiben Sie diese Funktion außerhalb der Klasse

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

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

}

Verwendungszweck:

delay(5000) {
    //Do your work here
}
Manohar Reddy
quelle
Was macht das?
Skizo-ozᴉʞS
Nur ein Name, behalte alles dort. doist eine eingebaute Methode, daher müssen wir `verwenden, um sie als Variablennamen zu verwenden
Manohar Reddy
Danke, aber warum wird dieser Variablenname verwendet? Ich meine, was ist die Funktion davon.
Skizo-ozᴉʞS
1
Ich dachte doso nach einer Verzögerung von 3 Sekunden
Manohar Reddy
0

In Android können wir unten Kotlin-Code schreiben, um die Ausführung einer Funktion zu verzögern

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()
}
}
Ahasan
quelle