Comment faire pour exécuter une méthode, toutes les X secondes

Cela dépend vraiment de combien de temps d'intervalle, vous devez exécuter la fonction.

Si c'est => 10 minutes → je voudrais aller avec Alarme Manager.

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

Et puis vous recevez ces émissions par le biais de récepteur de radiodiffusion. Notez que ce besoin d'être inscrit à l'éther dans votre manifeste de l'application ou via context.registerReceiver(receiver,filter); méthode Pour plus d'informations sur les Récepteurs de Radiodiffusion, veuillez consulter officiel Docs. Récepteur De Radiodiffusion.

public class MyReceiver extends BroadcastReceiver{

    @Override
    public void onReceive(Context context, Intent intent) 
    {
         //do stuffs
    }
}

Si c'est =< 10minutes → je voudrais aller avec un Gestionnaire.

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

handler.postDelayed(new Runnable(){
    public void run(){
        //do something
        handler.postDelayed(this, delay);
    }
}, delay);

Vous pouvez s'il vous plaît essayez ce code à l'appel du gestionnaire toutes les 15 secondes par onResume() et l'arrêter lorsque l'activité n'est pas visible, via onPause().

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

    new CountDownTimer(120000, 1000) {

        public void onTick(long millisUntilFinished) {
            txtcounter.setText(" " + millisUntilFinished / 1000);

        }

        public void onFinish() {

            txtcounter.setText(" TimeOut  ");
            Main2Activity.ShowPayment = false;
            EventBus.getDefault().post("go-main");

        }

    }.start();

Avec Kotlin, nous pouvons maintenant faire une fonction générique pour cette!

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

Et à utiliser, il suffit de faire:

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