Cómo ejecutar un método cada X segundos

Esto realmente depende de cuánto tiempo aparte de que necesita para ejecutar la función.

Si es => 10 minutos → yo iría con el Administrador de alarmas.

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

Y luego recibirá estas transmisiones a través de receptor de difusión. Tenga en cuenta que esto tendrá que ser registrado ether en su manifiesto de aplicación o vía context.registerReceiver(receiver,filter); Para obtener más información sobre los receptores de emisión, consulte los documentos oficiales. Receptor de radiodifusión .

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

Si es = <10 minutos → yo iría con un manejador.

 Handler handler = new Handler(); int delay = 1000; //milliseconds handler.postDelayed(new Runnable(){ public void run(){ //do something handler.postDelayed(this, delay); } }, delay); 

Utilice el temporizador por cada segundo …

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

Intente este código para llamar al manejador cada 15 segundos y detenerlo cuando la actividad no sea visible

  Handler h = new Handler(); int delay = 15000; //15 seconds Runnable runnable; @Override protected void onStart() { //start handler as activity become visible h.postDelayed(new Runnable() { public void run() { //do something runnable=this; h.postDelayed(runnable, delay); } }, delay); super.onStart(); } @Override protected void onPause() { h.removeCallbacks(runnable); //stop handler when activity not visible super.onPause(); } 

Si está familiarizado con RxJava, puede utilizar Observable.interval (), que es bastante ordenado.

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

La desventaja de esto es que usted tiene que el arquitecto de sondeo sus datos de una manera diferente. Sin embargo, hay muchos beneficios para la forma de programación reactiva:

1. En lugar de controlar sus datos a través de una devolución de llamada, crea una secuencia de datos a la que se suscribe. Esto separa la preocupación de la lógica de "datos de sondeo" y la lógica de "rellenar la interfaz de usuario con los datos" para que no mezcle su código de "fuente de datos" y su código de interfaz de usuario.

2. Con RxAndroid, puede manejar subprocesos en sólo 2 líneas de código.

    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 

Por favor, echa un vistazo a RxJava. Tiene una alta curva de aprendizaje pero hará que el manejo de llamadas asíncronas en Android sea mucho más fácil y más limpio.