Comment puis-je exécuter du code sur un fil d'arrière-plan sur Android?

Je veux que du code s'exécute en arrière-plan en continu. Je ne veux pas le faire dans un service. Y a-t-il un autre moyen possible?

J'ai essayé d'appeler la Threadclasse dans mon Activitymais mon Activityreste en arrière-plan pendant un certain temps, puis il s'arrête. La Threadclasse cesse également de fonctionner.

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


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

                } 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

    }

Si tu as besoin de:

1. exécuter du code sur un thread d'arrière-plan

2. exécuter du code qui NE touche PAS / ne met pas à jour l'interface utilisateur

3. exécuter un code (court) qui prendra au plus quelques secondes pour se terminer

ALORS utilisez le modèle propre et efficace suivant qui utilise AsyncTask:

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

Rappelez-vous Running Background, Running continuellement sont deux tâches différentes.

Pour les processus d'arrière-plan à long terme, les threads ne sont pas optimaux avec Android. Cependant, voici le code et faites-le à vos risques et périls ...

N'oubliez pas que le service ou le thread s'exécutera en arrière-plan, mais notre tâche doit déclencher (appeler encore et encore) pour obtenir les mises à jour, c'est-à-dire qu'une fois la tâche terminée, nous devons rappeler la fonction pour la prochaine mise à jour.

Timer (déclenchement périodique), alarme (déclenchement de base de temps), diffusion (déclenchement de base d'événement), la récursivité réveillera nos fonctions.

public static boolean isRecursionEnable = true;

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

    // isRecursionEnable = false; when u want to stop
    // 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() {
                        // update UI
                        runInBackground();
                    }
                });
            } else {
                runInBackground();
            }
        }
    }).start();
}

Utilisation du service: Si vous lancez un service, il démarrera, il exécutera la tâche et se terminera de lui-même. après l'exécution de la tâche. résilié peut également être causé par une exception, ou l'utilisateur l'a tué manuellement à partir des paramètres. START_STICKY (Sticky Service) est l'option donnée par Android selon laquelle le service redémarrera lui-même si le service est interrompu.

Rappelez-vous la différence de question entre le multitraitement et le multithreading? Le service est un processus d'arrière-plan (tout comme l'activité sans interface utilisateur), de la même manière que vous lancez le thread dans l'activité pour éviter la charge sur le thread principal (thread d'activité), de la même manière que vous devez lancer des threads (ou des tâches asynchrones) sur le service pour éviter la charge sur le service.

En une seule instruction, si vous souhaitez exécuter une tâche en arrière-plan, vous devez lancer un StickyService et exécuter le thread dans le service sur la base des événements.

Je veux que du code s'exécute en arrière-plan en continu. Je ne veux pas le faire dans un service. Y a-t-il un autre moyen possible?

Le mécanisme le plus probable que vous recherchez est AsyncTask. Il est directement désigné pour effectuer le processus d'arrière-plan sur le fil d'arrière-plan. Son principal avantage est également qu'il offre quelques méthodes qui s'exécutent sur le fil principal (UI) et permettent de mettre à jour votre interface utilisateur si vous souhaitez annoncer à l'utilisateur la progression de la tâche ou mettre à jour l'interface utilisateur avec des données récupérées à partir du processus d'arrière-plan.

Si vous ne savez pas par où commencer, voici un joli tutoriel:

• Comprendre AsyncTask - Une fois et pour toujours

Remarque: il est également possible d'utiliser IntentServiceavec ResultReceivercela fonctionne également.

Simple 3-Liner

Une façon simple de faire cela que j'ai trouvée dans un commentaire de @awardak dans la réponse de Brandon Rude :

new Thread( new Runnable() { @Override public void run() { 
  // Run whatever background code you want here.
} } ).start();

Je ne sais pas si, ni comment, c'est mieux que d'utiliser, AsyncTask.executemais cela semble fonctionner pour nous. Tout commentaire sur la différence serait apprécié.

Merci, @awardak !

Une alternative à AsyncTask est robospice. https://github.com/octo-online/robospice .

Certaines des fonctionnalités de robospice.

1. exécute de manière asynchrone (dans un AndroidService en arrière-plan) des requêtes réseau (ex: requêtes REST à l'aide de Spring Android) .notifiez votre application, sur le thread de l'interface utilisateur, lorsque le résultat est prêt.

2. est fortement typé! Vous faites vos demandes à l'aide de POJO et vous obtenez des POJO comme résultats de demande.

3. n'appliquez aucune contrainte ni aux POJO utilisés pour les requêtes, ni aux classes d'activité que vous utilisez dans vos projets.

4. met en cache les résultats (dans Json avec Jackson et Gson, ou Xml, ou des fichiers texte plats, ou des fichiers binaires, même en utilisant ORM Lite).

5. notifie vos activités (ou tout autre contexte) du résultat de la requête réseau si et seulement si elles sont toujours actives

6.pas de fuite de mémoire du tout, comme les chargeurs Android, contrairement à Android AsyncTasks notifie vos activités sur leur fil d'interface utilisateur.

7. utilise un modèle de gestion des exceptions simple mais robuste.

Des échantillons pour commencer. https://github.com/octo-online/RoboSpice-samples .

Un échantillon de robospice sur https://play.google.com/store/apps/details?id=com.octo.android.robospice.motivations&feature=search_result .

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

Si vous avez besoin d'exécuter un thread predioticly avec différents codes, voici un exemple:

Auditeur:

public interface ESLThreadListener {

    public List onBackground();

    public void onPostExecute(List list);

}

Classe de fil

public class ESLThread extends AsyncTask<Void, Void, List> {


    private ESLThreadListener mListener;

    public ESLThread() {

        if(mListener != null){

            mListener.onBackground();
        }
    }

    @Override
    protected List doInBackground(Void... params) {

        if(mListener != null){

            List list = mListener.onBackground();

            return list;
        }

        return null;
    }

    @Override
    protected void onPostExecute(List t) {
        if(mListener != null){

            if ( t != null) {
                mListener.onPostExecute(t);
            }
        }

    }


    public void setListener(ESLThreadListener mListener){

        this.mListener = mListener;
    }
}

Exécutez différents codes:

  ESLThread thread = new ESLThread();
                        thread.setListener(new ESLThreadListener() {
                            @Override
                            public List onBackground() {
                                List<EntityShoppingListItems>  data = RoomDB.getDatabase(context).sliDAO().getSL(fId);

                                return data;

                            }

                            @Override
                            public void onPostExecute(List t) {

                                List<EntityShoppingListItems> data = (List<EntityShoppingListItems>)t;
                                adapter.setList(data);
                            }
                        });

                        thread.execute();