Comment exécuter du code dans le fil d'UI Android ASYNC?

Chaque fois que vous travaillez avec un thread séparé qui n'est pas votre fil d'interface utilisateur, le meilleur moyen est d'utiliser le gestionnaire. Chaque fois que vous souhaitez intimer l'utilisateur à partir de votre thread, supposons une progression puis envoyez un message au gestionnaire. Handler intérieur Vous pouvez gérer un message et écrire un extrait de code pour changer quoi que ce soit sur l'interface utilisateur. C'est la voie préférée pour Android. Voir ces link1 , link2 & link3

the Article de filetage indolore à partir des ressources du développeur Android fournit différentes alternatives en fonction de la version SDK spécifique.

Vous utilisez cet asyntasque comme une classe intérieure de votre activité. En arrière-plan, effectuez la tâche de consommation de temps que vous souhaitez effectuer et ensuite sur la postexecute, vous pouvez afficher le message texte. Appelez ceci à partir de votre activité principale

initTask = new InitTask();
initTask.execute(this);


 protected class InitTask extends AsyncTask<Context, Integer, String> {     
        @Override
        protected String doInBackground(Context... params) {
            // Do the time comsuming task here 
            return "COMPLETE!";
        }

        // -- gets called just before thread begins
        @Override
        protected void onPreExecute() {         
            super.onPreExecute();

        }

        // -- called from the publish progress
        // -- notice that the datatype of the second param gets passed to this
        // method
        @Override
        protected void onProgressUpdate(Integer... values) {

        }

        // -- called if the cancel button is pressed
        @Override
        protected void onCancelled() {
            super.onCancelled();            
        }

        // -- called as soon as doInBackground method completes
        // -- notice that the third param gets passed to this method
        @Override
        protected void onPostExecute(String result) {
            super.onPostExecute(result);
            // Show the toast message here
        }
    }

Utilisez un gestionnaire:

static final int SHOW_TOAST = 0;
public static void showWaitingDialog(final Activity parent, final Runnable runnable, String msg) {

    if (StringUtils.isEmpty(msg)) {
        msg = "processing...";
    }

    final ProgressDialog waitingDialog = ProgressDialog.show(parent, "Please Wait...", msg, true);

    // execute in a new thread instead of UI thread
    ThreadPoolUtil.execute(new Runnable() {

        public void run() {
            try {
                // some time-consume operation
                runnable.run();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                waitingDialog.dismiss();
            }
           handler.sendMessage(handler.obtainMessage(SHOW_TOAST));

        }

    });

}

public Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case SHOW_TOAST:
                //Toast here
                break;
        }
    }
};

Vous pouvez utiliser AsynccTask comme ceci.

Pour appeler asynctacterie p>

nouvel getasyncccTask (). Exécuter (""); code> p>

et voici la classe pour obtenir des résultats. P >

class getAsynctask extends AsyncTask<String, Long, Integer> {

    protected void onPreExecute() {
        super.onPreExecute();
        loading = ProgressDialog.show(Pass.this, null, "Please wait...");
    }
    protected Integer doInBackground(String... params) {
        try {
            // do your coding
            return null;
        } catch (Exception e) {
            return null;
        }

    }

    protected void onPostExecute(Integer result) {
        super.onPostExecute(result);
        try {
            if (loading != null && loading.isShowing())
                loading.dismiss();
        } catch (Throwable t) {
            Log.v("this is praki", "loading.dismiss() problem", t);
        }
    }
}

Il y a plusieurs façons de faire cela,

• AsynccTask -

  ASYNCTASTASK permet une utilisation appropriée et facile du fil de l'interface utilisateur. Cette classe permet d'effectuer des opérations de fond et de publier des résultats sur l'interface utilisateur Fil sans avoir à manipuler des fils et / ou des gestionnaires. Exemple d'utilisation de l'asyncctage

  • Service -

    Un service est un composant d'application représentant soit un le désir de l'application d'effectuer une opération plus longue sans être interagir avec l'utilisateur ou pour fournir des fonctionnalités pour d'autres Applications à utiliser. Exemple d'utilisation du service.

    • usermentservice -

      Intitifservice est une classe de base pour les services qui gèrent asynchrones Demandes (exprimées comme intention) sur demande. Les clients envoient des demandes à travers les appels de startService (intention); Le service est commencé au besoin, gère chaque intention à son tour en utilisant un fil de travail et s'arrête elle-même quand il manque de travail. Exemple d'utilisation d'utilservice.