Android Télécharger l'image en utilisant AsyncTask dans Android


Exemple

Ce tutoriel explique comment télécharger Image en utilisant AsyncTask dans Android. L'exemple ci-dessous télécharge l'image tout en affichant la barre de progression pendant le téléchargement.

Comprendre Android AsyncTask

La tâche asynchrone vous permet d’implémenter MultiThreading sans que les mains soient sales dans les threads. AsyncTask permet une utilisation correcte et facile du thread de l'interface utilisateur. Il permet d'effectuer des opérations en arrière-plan et de transmettre les résultats sur le thread d'interface utilisateur. Si vous faites quelque chose d'isolement lié à l'interface utilisateur, par exemple en téléchargeant des données pour les présenter dans une liste, utilisez AsyncTask.

  • AsyncTasks devrait idéalement être utilisé pour des opérations courtes (quelques secondes au maximum).
  • Une tâche asynchrone est définie par 3 types génériques, appelés Params, Progress et Result, et 4 étapes, appelées onPreExecute() , doInBackground() , onProgressUpdate() et onPostExecute() .
  • Dans onPreExecute() vous pouvez définir du code, qui doit être exécuté avant le traitement en arrière-plan.
  • doInBackground a un code qui doit être exécuté en arrière-plan, ici dans doInBackground() nous pouvons envoyer des résultats à plusieurs fois au thread d'événement par la méthode publishProgress ().
  • onProgressUpdate() méthode onProgressUpdate() reçoit les mises à jour de progression de la méthode doInBackground() , publiée via la méthode publishProgress() . Cette méthode peut utiliser cette mise à jour pour mettre à jour le thread d'événement.
  • onPostExecute() méthode onPostExecute() gère les résultats renvoyés par la méthode doInBackground() .
  • Les types génériques utilisés sont
    • Params, le type des paramètres envoyés à la tâche lors de l'exécution
    • Progress, le type des unités de progression publiées lors du calcul en arrière-plan.
    • Résultat, le type du résultat du calcul en arrière-plan.
  • Si une tâche asynchrone n'utilise aucun type, elle peut alors être marquée comme type d'annulation.
  • Une tâche asynchrone en cours d'exécution peut être annulée en appelant la méthode cancel(boolean) .

Téléchargement d'image en utilisant Android AsyncTask

votre mise en page .xml

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

<Button
    android:id="@+id/downloadButton"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="Click Here to Download" />

<ImageView
    android:id="@+id/imageView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:contentDescription="Your image will appear here" />

</LinearLayout>

classe .java

package com.javatechig.droid;

import java.io.InputStream;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import android.app.Activity;
import android.app.ProgressDialog;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;

public class ImageDownladerActivity extends Activity {

    private ImageView downloadedImg;
    private ProgressDialog simpleWaitDialog;
    private String downloadUrl = "http://www.9ori.com/store/media/images/8ab579a656.jpg";

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.asynch);
        Button imageDownloaderBtn = (Button) findViewById(R.id.downloadButton);

        downloadedImg = (ImageView) findViewById(R.id.imageView);

        imageDownloaderBtn.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                new ImageDownloader().execute(downloadUrl);
            }

        });
    }

    private class ImageDownloader extends AsyncTask {

        @Override
        protected Bitmap doInBackground(String... param) {
            // TODO Auto-generated method stub
            return downloadBitmap(param[0]);
        }

        @Override
        protected void onPreExecute() {
            Log.i("Async-Example", "onPreExecute Called");
            simpleWaitDialog = ProgressDialog.show(ImageDownladerActivity.this,
                    "Wait", "Downloading Image");

        }

        @Override
        protected void onPostExecute(Bitmap result) {
            Log.i("Async-Example", "onPostExecute Called");
            downloadedImg.setImageBitmap(result);
            simpleWaitDialog.dismiss();

        }

        private Bitmap downloadBitmap(String url) {
            // initilize the default HTTP client object
            final DefaultHttpClient client = new DefaultHttpClient();

            //forming a HttpGet request 
            final HttpGet getRequest = new HttpGet(url);
            try {

                HttpResponse response = client.execute(getRequest);

                //check 200 OK for success
                final int statusCode = response.getStatusLine().getStatusCode();

                if (statusCode != HttpStatus.SC_OK) {
                    Log.w("ImageDownloader", "Error " + statusCode + 
                            " while retrieving bitmap from " + url);
                    return null;

                }

                final HttpEntity entity = response.getEntity();
                if (entity != null) {
                    InputStream inputStream = null;
                    try {
                        // getting contents from the stream 
                        inputStream = entity.getContent();

                        // decoding stream data back into image Bitmap that android understands
                        final Bitmap bitmap = BitmapFactory.decodeStream(inputStream);

                        return bitmap;
                    } finally {
                        if (inputStream != null) {
                            inputStream.close();
                        }
                        entity.consumeContent();
                    }
                }
            } catch (Exception e) {
                // You Could provide a more explicit error message for IOException
                getRequest.abort();
                Log.e("ImageDownloader", "Something went wrong while" +
                        " retrieving bitmap from " + url + e.toString());
            } 

            return null;
        }
    }
}

Comme il n'y a actuellement aucun champ de commentaire pour les exemples (ou que je ne l'ai pas trouvé ou que je n'ai pas l'autorisation de le faire), voici quelques commentaires à ce sujet:

C'est un bon exemple de ce que l'on peut faire avec AsyncTask.

Cependant, l'exemple a actuellement des problèmes avec

  • fuites de mémoire possibles
  • crash de l'application en cas de rotation de l'écran peu avant la fin de la tâche asynchrone.

Pour plus de détails voir: