Wie man eine Methode alle X Sekunden ausführt

Question

Ich entwickle eine Android 2.3.3-Anwendung, und ich muss eine Methode jedes Mal ausführen X Sekunden .

Unter iOS habe ich NSTimer , aber bei Android weiß ich nicht, was ich verwenden soll.

Jemand hat mir empfohlen Handler ; ein anderer empfiehlt mir AlarmManager aber ich weiß nicht, welche Methode besser geeignet ist für NSTimer .

Dies ist der Code, den ich in Android implementieren möchte:

timer2 = [
    NSTimer scheduledTimerWithTimeInterval:(1.0f/20.0f)
    target:self
    selector:@selector(loopTask)
    userInfo:nil
    repeats:YES
];

timer1 = [
    NSTimer scheduledTimerWithTimeInterval:(1.0f/4.0f)
    target:self
    selector:@selector(isFree)
    userInfo:nil
    repeats:YES
];

Ich brauche etwas, das funktioniert wie NSTimer .

Was empfehlen Sie mir?

Answer 1

Welche Lösung Sie verwenden, hängt davon ab, wie lange Sie zwischen den einzelnen Ausführungsvorgängen Ihrer Funktion warten müssen.

Wenn Sie länger als 10 Minuten warten, würde ich vorschlagen, dass Sie AlarmManager .

// Some time when you want to run
Date when = new Date(System.currentTimeMillis());

try {
    Intent someIntent = new Intent(someContext, MyReceiver.class); // intent to be launched

    // Note: this could be getActivity if you want to launch an activity
    PendingIntent pendingIntent = PendingIntent.getBroadcast(
        context,
        0, // id (optional)
        someIntent, // intent to launch
        PendingIntent.FLAG_CANCEL_CURRENT // PendingIntent flag
    );

    AlarmManager alarms = (AlarmManager) context.getSystemService(
        Context.ALARM_SERVICE
    );

    alarms.setRepeating(
        AlarmManager.RTC_WAKEUP,
        when.getTime(),
        AlarmManager.INTERVAL_FIFTEEN_MINUTES,
        pendingIntent
    );
} catch(Exception e) {
    e.printStackTrace();
}

Sobald Sie die oben genannten Informationen gesendet haben Intent können Sie Ihre Intent durch die Einführung eines BroadcastReceiver . Beachten Sie, dass dies entweder in Ihrem Anwendungsmanifest oder über die context.registerReceiver(receiver, intentFilter); Methode. Für weitere Informationen über BroadcastReceiver entnehmen Sie bitte der offiziellen Dokumentation. .

public class MyReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent)
    {
        System.out.println("MyReceiver: here!") // Do your work here
    }
}

Wenn Sie kürzer als 10 Minuten warten, würde ich vorschlagen, eine Handler .

final Handler handler = new Handler();
final int delay = 1000; // 1000 milliseconds == 1 second

handler.postDelayed(new Runnable() {
    public void run() {
        System.out.println("myHandler: here!"); // Do your work here
        handler.postDelayed(this, delay);
    }
}, delay);

Answer 2

Timer für jede Sekunde verwenden...

new Timer().scheduleAtFixedRate(new TimerTask() {
    @Override
    public void run() {
        //your method
    }
}, 0, 1000);//put here time 1000 milliseconds=1 second

Answer 3

Sie können diesen Code ausprobieren, um den Handler alle 15 Sekunden über onResume() aufzurufen und ihn über onPause() anzuhalten, wenn die Aktivität nicht sichtbar ist.

Handler handler = new Handler();
Runnable runnable;
int delay = 15*1000; //Delay for 15 seconds.  One second = 1000 milliseconds.

@Override
protected void onResume() {
   //start handler as activity become visible

    handler.postDelayed( runnable = new Runnable() {
        public void run() {
            //do something

            handler.postDelayed(runnable, delay);
        }
    }, delay);

    super.onResume();
}

// If onPause() is not included the threads will double up when you 
// reload the activity 

@Override
protected void onPause() {
    handler.removeCallbacks(runnable); //stop handler when activity not visible
    super.onPause();
}

Answer 4

Wenn Sie mit RxJava vertraut sind, können Sie Observable.interval() verwenden, was sehr praktisch ist.

Observable.interval(60, TimeUnits.SECONDS)
          .flatMap(new Function<Long, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(@NonNull Long aLong) throws Exception {
                    return getDataObservable(); //Where you pull your data
                }
            });

Der Nachteil dabei ist, dass Sie Ihre Daten auf eine andere Art und Weise architektonisch abfragen müssen. Die reaktive Programmierung bietet jedoch eine Menge Vorteile:

1. Anstatt Ihre Daten über einen Rückruf zu steuern, erstellen Sie einen Datenstrom, den Sie abonnieren. Auf diese Weise werden die Logik für die Datenabfrage und die Logik für das Auffüllen der Benutzeroberfläche mit Ihren Daten voneinander getrennt, so dass Sie Ihren Code für die Datenquelle und Ihren Code für die Benutzeroberfläche nicht vermischen.

2. Mit RxAndroid können Sie Threads in nur 2 Codezeilen behandeln.

   Observable.interval(60, TimeUnits.SECONDS)
         .flatMap(...) // polling data code
         .subscribeOn(Schedulers.newThread()) // poll data on a background thread
         .observeOn(AndroidSchedulers.mainThread()) // populate UI on main thread
         .subscribe(...); // your UI code

Bitte schauen Sie sich RxJava an. Es hat eine hohe Lernkurve, aber es wird den Umgang mit asynchronen Aufrufen in Android so viel einfacher und sauberer.

Answer 5

Mit Kotlin können wir jetzt eine generische Funktion für diese Aufgabe erstellen!

object RepeatHelper {
    fun repeatDelayed(delay: Long, todo: () -> Unit) {
        val handler = Handler()
        handler.postDelayed(object : Runnable {
            override fun run() {
                todo()
                handler.postDelayed(this, delay)
            }
        }, delay)
    }
}

Und zu verwenden, einfach tun:

val delay = 1000L
RepeatHelper.repeatDelayed(delay) {
    myRepeatedFunction()
}