Cómo ejecutar un método cada X segundos

Question

Estoy desarrollando una aplicación Android 2.3.3 y necesito ejecutar un método cada X segundos.

En iOS, tengo NSTimer, pero en Android no sé qué usar.

Alguien me ha recomendado Handler; otra me recomienda AlarmManager pero no sé qué método se ajusta mejor con NSTimer.

Este es el código que desea implementar en Android:

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

necesito algo lo que funciona como NSTimer.

¿Qué me recomiendas?

Answer 1

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

Si es => 10 minutos → Me gustaría ir con Alarm 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(); 
} 

Y luego recibe estas transmisiones a través del receptor de difusión. Tenga en cuenta que será necesario registrar el éter en el manifiesto de su aplicación o mediante el método context.registerReceiver(receiver,filter);. Para obtener más información sobre los receptores de difusión, consulte los documentos oficiales. Broadcast Receiver.

public class MyReceiver extends BroadcastReceiver{ 

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

Si es = < 10 minutos → Me gustaría ir con un Handler.

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

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

Answer 2

Uso del temporizador para cada segundo ...

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

Answer 3

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

Handler h = new Handler(); 
    int delay = 15*1000; //1 second=1000 milisecond, 15*1000=15seconds 
    Runnable runnable; 

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

     h.postDelayed(new Runnable() { 
      public void run() { 
       //do something 

       runnable=this; 

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

     super.onResume(); 
    } 

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

Answer 4

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

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

El inconveniente de esto es que tiene que arquitecto sondear 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 mediante una devolución de llamada, crea una secuencia de datos a los que se suscribe. Esto separa la preocupación de la lógica de "datos de sondeo" y la lógica de "llenar UI con sus datos" para que no mezcle su código de "fuente de datos" y su código de UI.

2. Con RxAndroid, puede manejar hilos en solo 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 gran curva de aprendizaje, pero hará que manejar llamadas asíncronas en Android sea mucho más fácil y más limpio.

Answer 5

Aquí he utilizado un hilo en onCreate() una actividad repeatly, temporizador no permite que todo lo que en algunos casos la rosca es la solución

 Thread t = new Thread() { 
     @Override 
     public void run() { 
      while (!isInterrupted()) { 
       try { 
        Thread.sleep(10000); //1000ms = 1 sec 
        runOnUiThread(new Runnable() { 
         @Override 
         public void run() { 

          SharedPreferences mPrefs = getSharedPreferences("sam", MODE_PRIVATE); 
          Gson gson = new Gson(); 
          String json = mPrefs.getString("chat_list", ""); 
          GelenMesajlar model = gson.fromJson(json, GelenMesajlar.class); 
          String sam = ""; 

          ChatAdapter adapter = new ChatAdapter(Chat.this, model.getData()); 
          listview.setAdapter(adapter); 
          // listview.setStackFromBottom(true); 
          // Util.showMessage(Chat.this,"Merhabalar"); 
         } 
        }); 

       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
      } 
     } 
    }; 

    t.start(); 

En caso de que tuviera que puede ser excavado por las

@Override 
protected void onDestroy() { 
    super.onDestroy(); 
    Thread.interrupted(); 
    //t.interrupted(); 
}