Come posso eseguire il codice su un thread in background su Android?

Question

Desidero che alcuni codici vengano eseguiti in background continuamente. Non voglio farlo in un servizio. C'è un altro modo possibile?

Ho provato a chiamare la classe Thread nel mio Activity ma il mio Activity rimane sullo sfondo per qualche tempo e poi si ferma. Anche la classe Thread smette di funzionare.

class testThread implements Runnable 
    { 
     @Override 
     public void run() 
     { 
      File file = new File(Environment.getExternalStorageDirectory(),"/BPCLTracker/gpsdata.txt"); 
      int i=0; 

     RandomAccessFile in = null; 

     try 
     { 
      in = new RandomAccessFile(file, "rw"); 


     } 
     catch (FileNotFoundException e) 
     { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (IOException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
     //String line =null; 
     while (true) 
     { 
      HttpEntity entity=null; 
      try 
      { 
       if (isInternetOn()) 
       { 
         while ((line = in.readLine()) != null) 
         { 

          HttpClient client = new DefaultHttpClient(); 
          String url = "some url"; 
          HttpPost request = new HttpPost(url); 
          StringEntity se = new StringEntity(line); 
          se.setContentEncoding("UTF-8"); 
          se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json")); 
          entity = se; 
          request.setEntity(entity); 
          HttpResponse response = client.execute(request); 
          entity = response.getEntity(); 
          i++; 
         } 
         if((line = in.readLine()) == null && entity!=null) 
         { 
          file.delete(); 
          testThread t = new testThread(); 
          Thread t1 = new Thread(t); 
          t1.start(); 
         } 


       }// end of if 
       else 
       { 
        Thread.sleep(60000); 

       } // end of else 
      }// end of try 
      catch (NullPointerException e1) 
      { 
       e1.printStackTrace(); 
      } 
      catch (InterruptedException e2) 
      { 
       e2.printStackTrace(); 
      } 
      catch (IOException e1) 
      { 
       // TODO Auto-generated catch block 
       e1.printStackTrace(); 
      } 
     }// end of while 
    }// end of run 

Answer 1

Voglio un po 'di codice per l'esecuzione in background continuo. Non voglio farlo in un servizio. C'è un altro modo possibile?

Molto probabilmente mechanizm che stai cercando è AsyncTask. Progettato direttamente per l'esecuzione di processi in background su thread in background. Inoltre, il suo vantaggio principale è che offre alcuni metodi che funzionano sul thread Main (UI) e rendono possibile aggiornare l'interfaccia utente se si desidera informare l'utente di alcuni progressi nell'attività o aggiornare l'interfaccia utente con i dati recuperati dal processo in background.

Se non sai come iniziare qui è bel tutorial:

• Understanding AsyncTask – Once and Forever

Nota: Inoltre v'è la possibilità di utilizzare IntentService con ResultReceiver che funziona pure.

Answer 2

Per i processi in background a lungo termine, i thread non sono ottimali con Android. Tuttavia, ecco il codice e fallo a tuo rischio ...

Ricorda che il servizio o il thread verranno eseguiti in background ma il nostro compito deve fare il trigger (chiamare ancora e ancora) per ottenere gli aggiornamenti, cioè una volta che l'attività è completato abbiamo bisogno di richiamare la funzione per il prossimo aggiornamento.

Timer (trigger periodico), allarme (trigger a base di tempo), trasmissione (trigger base eventi), la ricorsione sveglierà le nostre funzioni.

public static boolean isRecursionEnable = false; 

void runInBackground() { 
    if (isRecursionEnable) 
     return; // Handle not to start multiple parallel threads 

    isRecursionEnable = true; // on exception on thread make it true again 
    new Thread(new Runnable() { 
     @Override 
     public void run() { 
      // DO your work here 
      // get the data 
      if (activity_is_not_in_background) { 
       runOnUiThread(new Runnable() { 
        @Override 
        public void run() { 
         //uddate UI 
         runInBackground(); 
        } 
       }); 
      } else { 
       runInBackground(); 
      } 
     } 
    }).start(); 
} 

Answer 3

Un'alternativa a AsyncTask è robospice. https://github.com/octo-online/robospice.

Alcune delle funzionalità di robospice.

1.esecuisce le richieste di rete in modo asincrono (in un background AndroidService) (es: richieste REST utilizzando Spring Android) .notifica l'app, sul thread dell'interfaccia utente, quando il risultato è pronto.

2.è fortemente digitato! Esegui le tue richieste usando i POJO e ottieni POJO come risultati delle richieste.

3. non applicare alcun vincolo né sui POJO utilizzati per le richieste né sulle classi di attività utilizzate nei progetti.

4.cache risultati (in Json sia con Jackson e Gson, o Xml, o file di testo flat, o file binari, anche utilizzando ORM Lite).

5.notifies vostre attività (o di qualsiasi altro contesto) del risultato della richiesta di rete se e solo se sono ancora vivi

6.nessuna perdita di memoria, come Android Loader, a differenza di Android AsyncTasks notifica le attività sul loro thread UI.

7. utilizza un modello di gestione delle eccezioni semplice ma affidabile.

Campioni con cui iniziare. https://github.com/octo-online/RoboSpice-samples.

Un campione di robospice allo https://play.google.com/store/apps/details?id=com.octo.android.robospice.motivations&feature=search_result.

Answer 4

SE è necessario:

1. eseguire codice su uno sfondo Discussione

2. eseguire codice che NON toccare/aggiornare l'interfaccia utente

3. execute (short) il codice che si terrà al massimo qualche secondo per completare

THEN utilizzare il seguente modello pulito ed efficiente che utilizza AsyncTask:

AsyncTask.execute(new Runnable() { 
    @Override 
    public void run() { 
     //TODO your background code 
    } 
}); 

Answer 5

class Background implements Runnable { 
    private CountDownLatch latch = new CountDownLatch(1); 
    private Handler handler; 

    Background() { 
     Thread thread = new Thread(this); 
     thread.start(); 
     try { 
      latch.await(); 
     } catch (InterruptedException e) { 
      /// e.printStackTrace(); 
     } 
    } 

    @Override 
    public void run() { 
     Looper.prepare(); 
     handler = new Handler(); 
     latch.countDown(); 
     Looper.loop(); 
    } 

    public Handler getHandler() { 
     return handler; 
    } 
}