Editar a partir de 30.12.2015-o Guia final para download de imagens

---

última actualização importante: Mar 31 2016

---

pare de falar, dê-me o código!!

Salta para o fundo desta publicação, copia o BasicImageDownloader (versão javadoc aqui ) no seu projecto, implemente a interface OnImageLoaderListener e acabou.

Nota : embora BasicImageDownloader trate de possíveis erros e will evitar que o seu aplicativo de bater em caso de algo correr mal, ele não vai executar qualquer pós-processamento (por exemplo, redução de tamanho) no descarregamento Bitmaps.

---

Uma vez que este post recebeu muita atenção, eu decidi reformulá - lo completamente para evitar que as pessoas usem tecnologias obsoletas, más práticas de programação ou apenas fazer coisas tolas-como procurar "hacks" para executar a rede no fio principal ou aceitar todas as certs SSL.

Criei uma demo. o projeto chamado "Image Downloader" que demonstra como baixar (e salvar) uma imagem usando a minha própria implementação de download, o Android built-in DownloadManager, bem como algumas bibliotecas populares de código aberto. Poderá ver o código-fonte completo ou obter o projecto no GitHub .

Nota : ainda não ajustei a gestão da autorização para o SDK 23+ (Marshmallow), pelo que o projecto visa o SDK 22 (Chupa-Chupa).

Na minha conclusão no final deste post eu vou compartilhar minha humilde opinião sobre o caso de uso adequado para cada forma particular de download de imagem que eu mencionei.

Vamos começar com uma implementação própria (você pode encontrar o código no final do post). Em primeiro lugar, este é um básicoImageDownloader e é isso. Tudo o que faz é ligar-se ao url dado, ler os dados e tentar descodificá-lo como um Bitmap, accionando a interface OnImageLoaderListener callbacks quando apropriado. A vantagem desta abordagem - é simples e você tem uma visão clara do que está acontecendo. Uma boa maneira de ir se tudo o que você precisa é baixar/exibir e salvar algumas imagens, enquanto você não se importa com a manutenção de uma cache de memória/disco.

Nota: no caso de imagens grandes, pode ser necessário dimensioná-las. para baixo.

--

O Android download é uma forma de deixar o sistema lidar com o download para você. É realmente capaz de baixar qualquer tipo de arquivos, não apenas imagens. Você pode deixar seu download acontecer silenciosamente e invisível para o usuário, ou você pode permitir que o usuário veja o download na área de notificação. Você também pode registrar um BroadcastReceiver para ser notificado após o download estar completo. A configuração é bastante simples, consulte o projeto vinculado para o código de exemplo.

Usar o DownloadManager geralmente não é uma boa ideia se você também quiser mostrar a imagem, uma vez que você é necessário ler e descodificar o ficheiro gravado em vez de apenas configurar o Bitmap transferido para um ImageView. O DownloadManager também não fornece nenhuma API para que você possa acompanhar o progresso de download.

--

Agora a introdução das grandes coisas-as bibliotecas. Eles podem fazer muito mais do que apenas baixar e exibir imagens, incluindo: criar e gerenciar a cache de memória/disco, redimensionar imagens, transformá-las e muito mais.

Vou começar com Volley , um poderosa biblioteca criada pelo Google e coberta pela documentação oficial. Apesar de ser uma biblioteca de rede de propósito geral não especializada em imagens, Volley apresenta uma API bastante poderosa para gerenciar imagens.

Terá de implementar uma classe Singleton para gerir os pedidos de Volley e está pronto para ir.

Você pode querer substituir o seu ImageView com o Volley's NetworkImageView, por isso o download basicamente torna-se um único encarte:

((NetworkImageView) findViewById(R.id.myNIV)).setImageUrl(url, MySingleton.getInstance(this).getImageLoader());

Se precisar de mais controle, isto é o que parece criar um ImageRequest com Volley:

     ImageRequest imgRequest = new ImageRequest(url, new Response.Listener<Bitmap>() {
             @Override
             public void onResponse(Bitmap response) {
                    //do stuff
                }
            }, 0, 0, ImageView.ScaleType.CENTER_CROP, Bitmap.Config.ARGB_8888, 
             new Response.ErrorListener() {
             @Override
             public void onErrorResponse(VolleyError error) {
                   //do stuff
                }
            });

Vale a pena mencionar que a Volley apresenta um excelente mecanismo de manipulação de erros, fornecendo a classe VolleyError que o ajuda a determinar a causa exata de um erro. Se o seu aplicativo faz um monte de networking e gestão de imagens não é o seu principal propósito, em seguida, Volley-lo um ajuste perfeito para você.

--

Picasso é uma biblioteca bem conhecida que fará todo o carregamento de imagens. coisas para ti. Apenas mostrar uma imagem usando Picasso é tão simples como:

 Picasso.with(myContext)
       .load(url)
       .into(myImageView); 

Por padrão, Picasso gerencia o cache de disco / memória para que você não precisa se preocupar com isso. Para obter mais controlo, pode implementar a interface Target e usá - la para carregar a sua imagem-isto irá fornecer callbacks semelhantes ao exemplo do Volley. Veja exemplos no projecto de demonstração.

Picasso também permite que você aplique transformações na imagem baixada e existem ainda outras bibliotecas em torno disso estendem essas API. Também funciona muito bem em um RecyclerView/ListView/GridView.

--

Universal Image Loader é uma outra biblioteca muito popular que serve o propósito da Gestão de imagens. Ele usa seu próprio ImageLoader que (uma vez inicializado) tem uma instância global que pode ser usada para baixar imagens em uma única linha de código:

  ImageLoader.getInstance().displayImage(url, myImageView);

Se quiser acompanhar o progresso da transferência ou aceder à transferência Bitmap:

 ImageLoader.getInstance().displayImage(url, myImageView, opts, 
 new ImageLoadingListener() {
     @Override
     public void onLoadingStarted(String imageUri, View view) {
                     //do stuff
                }

      @Override
      public void onLoadingFailed(String imageUri, View view, FailReason failReason) {
                   //do stuff
                }

      @Override
      public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
                   //do stuff
                }

      @Override
      public void onLoadingCancelled(String imageUri, View view) {
                   //do stuff
                }
            }, new ImageLoadingProgressListener() {
      @Override
      public void onProgressUpdate(String imageUri, View view, int current, int total) {
                   //do stuff
                }
            });

O argumento neste exemplo é um objeto DisplayImageOptions. Consulte o projeto de demonstração para saber mais.

Similar ao Volley, o UIL fornece a classe FailReason que lhe permite verificar o que correu mal na falha de download. Por padrão, UIL mantém uma cache de memória / disco se você não diz explicitamente para não fazê-lo.

Nota : o autor mencionou que já não mantém o projeto a partir de 27 de Novembro de 2015. Mas uma vez que há muitos contribuintes, podemos esperar que o carregador de imagem Universal irá vive.

--

O Fresco do Facebook é a mais recente e (IMO) a biblioteca mais avançada que leva a gestão de imagens para um novo nível: de manterBitmaps fora do Monte java (antes do Chupa-Chupa) para suportar formatos animados e streaming JPEG progressivo .

Para saber mais sobre as ideias e técnicas por trás do Fresco, consulte este post.

O uso básico é bastante simples. Note que você vai precisar ligar para Fresco.initialize(Context); apenas uma vez, preferível na classe Application. Inicializar afrescos mais de uma vez pode levar a comportamentos imprevisíveis e erros de OOM.

O Fresco usa DraweeS para mostrar imagens, pode pensar neles como ImageView s:

    <com.facebook.drawee.view.SimpleDraweeView
    android:id="@+id/drawee"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    fresco:fadeDuration="500"
    fresco:actualImageScaleType="centerCrop"
    fresco:placeholderImage="@drawable/placeholder_grey"
    fresco:failureImage="@drawable/error_orange"
    fresco:placeholderImageScaleType="fitCenter"
    fresco:failureImageScaleType="centerInside"
    fresco:retryImageScaleType="centerCrop"
    fresco:progressBarImageScaleType="centerInside"
    fresco:progressBarAutoRotateInterval="1000"
    fresco:roundAsCircle="false" />

Como pode ver, muitas coisas (incluindo as opções de transformação) já estão definidas em XML, por isso tudo o que precisa de fazer para mostrar uma imagem é uma linha única:

 mDrawee.setImageURI(Uri.parse(url));

O Fresco fornece uma API de personalização alargada, que, em circunstâncias, pode ser bastante complexo e requer que o Utilizador leia cuidadosamente os documentos (sim, por vezes tem de RTFM).

Incluí exemplos de JPEG progressivos e imagens animadas no projecto de amostra.

---

Conclusão: "aprendi sobre as coisas boas, o que devo usar agora?"

Note-se que o seguinte texto reflecte a minha opinião pessoal e deve não ser tomado como postulado.

• se só for necessário transferir/gravar / mostrar algumas imagens, não planeie usá-las num Recycler-/Grid-/ListView e não precise de um monte de imagens para serem exibidas-ready, o BasicImageDownloader deve corresponder às suas necessidades.
• se a sua aplicação gravar imagens (ou outros ficheiros) como resultado de um utilizador ou de uma acção automatizada e não precisar que as imagens sejam mostradas com frequência, use o Android Telecarregador.
• no caso da sua aplicação fazer muita rede, transmite / recebe dados JSON, Funciona com imagens, mas esse não é o principal propósito da aplicação, vá com Volley.
• a sua aplicação está focada na imagem/mídia, gostaria de aplicar algumas transformações nas imagens e não se preocupar com a API complexa: use Picasso (Nota: não oferece nenhuma API para acompanhar o estado de download intermédio) ou Universal Image Loader
• se o seu aplicativo é tudo sobre Imagens, você precisa de funcionalidades avançadas, como a exibição de formatos animados e você está pronto para ler os documentos, vai com afresco.

No caso de não teres visto isso, o link do Github para o projecto de demonstração.

---

E aqui está o ... BasicImageDownloader.java

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.support.annotation.NonNull;
import android.util.Log;
import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashSet;
import java.util.Set;

public class BasicImageDownloader {

    private OnImageLoaderListener mImageLoaderListener;
    private Set<String> mUrlsInProgress = new HashSet<>();
    private final String TAG = this.getClass().getSimpleName();

    public BasicImageDownloader(@NonNull OnImageLoaderListener listener) {
        this.mImageLoaderListener = listener;
    }

    public interface OnImageLoaderListener {
        void onError(ImageError error);      
        void onProgressChange(int percent);
        void onComplete(Bitmap result);
    }


    public void download(@NonNull final String imageUrl, final boolean displayProgress) {
        if (mUrlsInProgress.contains(imageUrl)) {
            Log.w(TAG, "a download for this url is already running, " +
                    "no further download will be started");
            return;
        }

        new AsyncTask<Void, Integer, Bitmap>() {

            private ImageError error;

            @Override
            protected void onPreExecute() {
                mUrlsInProgress.add(imageUrl);
                Log.d(TAG, "starting download");
            }

            @Override
            protected void onCancelled() {
                mUrlsInProgress.remove(imageUrl);
                mImageLoaderListener.onError(error);
            }

            @Override
            protected void onProgressUpdate(Integer... values) {
                mImageLoaderListener.onProgressChange(values[0]);
            }

        @Override
        protected Bitmap doInBackground(Void... params) {
            Bitmap bitmap = null;
            HttpURLConnection connection = null;
            InputStream is = null;
            ByteArrayOutputStream out = null;
            try {
                connection = (HttpURLConnection) new URL(imageUrl).openConnection();
                if (displayProgress) {
                    connection.connect();
                    final int length = connection.getContentLength();
                    if (length <= 0) {
                        error = new ImageError("Invalid content length. The URL is probably not pointing to a file")
                                .setErrorCode(ImageError.ERROR_INVALID_FILE);
                        this.cancel(true);
                    }
                    is = new BufferedInputStream(connection.getInputStream(), 8192);
                    out = new ByteArrayOutputStream();
                    byte bytes[] = new byte[8192];
                    int count;
                    long read = 0;
                    while ((count = is.read(bytes)) != -1) {
                        read += count;
                        out.write(bytes, 0, count);
                        publishProgress((int) ((read * 100) / length));
                    }
                    bitmap = BitmapFactory.decodeByteArray(out.toByteArray(), 0, out.size());
                } else {
                    is = connection.getInputStream();
                    bitmap = BitmapFactory.decodeStream(is);
                }
            } catch (Throwable e) {
                if (!this.isCancelled()) {
                    error = new ImageError(e).setErrorCode(ImageError.ERROR_GENERAL_EXCEPTION);
                    this.cancel(true);
                }
            } finally {
                try {
                    if (connection != null)
                        connection.disconnect();
                    if (out != null) {
                        out.flush();
                        out.close();
                    }
                    if (is != null)
                        is.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return bitmap;
        }

            @Override
            protected void onPostExecute(Bitmap result) {
                if (result == null) {
                    Log.e(TAG, "factory returned a null result");
                    mImageLoaderListener.onError(new ImageError("downloaded file could not be decoded as bitmap")
                            .setErrorCode(ImageError.ERROR_DECODE_FAILED));
                } else {
                    Log.d(TAG, "download complete, " + result.getByteCount() +
                            " bytes transferred");
                    mImageLoaderListener.onComplete(result);
                }
                mUrlsInProgress.remove(imageUrl);
                System.gc();
            }
        }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
    }

    public interface OnBitmapSaveListener {
        void onBitmapSaved();
        void onBitmapSaveError(ImageError error);
    }


    public static void writeToDisk(@NonNull final File imageFile, @NonNull final Bitmap image,
                               @NonNull final OnBitmapSaveListener listener,
                               @NonNull final Bitmap.CompressFormat format, boolean shouldOverwrite) {

    if (imageFile.isDirectory()) {
        listener.onBitmapSaveError(new ImageError("the specified path points to a directory, " +
                "should be a file").setErrorCode(ImageError.ERROR_IS_DIRECTORY));
        return;
    }

    if (imageFile.exists()) {
        if (!shouldOverwrite) {
            listener.onBitmapSaveError(new ImageError("file already exists, " +
                    "write operation cancelled").setErrorCode(ImageError.ERROR_FILE_EXISTS));
            return;
        } else if (!imageFile.delete()) {
            listener.onBitmapSaveError(new ImageError("could not delete existing file, " +
                    "most likely the write permission was denied")
                    .setErrorCode(ImageError.ERROR_PERMISSION_DENIED));
            return;
        }
    }

    File parent = imageFile.getParentFile();
    if (!parent.exists() && !parent.mkdirs()) {
        listener.onBitmapSaveError(new ImageError("could not create parent directory")
                .setErrorCode(ImageError.ERROR_PERMISSION_DENIED));
        return;
    }

    try {
        if (!imageFile.createNewFile()) {
            listener.onBitmapSaveError(new ImageError("could not create file")
                    .setErrorCode(ImageError.ERROR_PERMISSION_DENIED));
            return;
        }
    } catch (IOException e) {
        listener.onBitmapSaveError(new ImageError(e).setErrorCode(ImageError.ERROR_GENERAL_EXCEPTION));
        return;
    }

    new AsyncTask<Void, Void, Void>() {

        private ImageError error;

        @Override
        protected Void doInBackground(Void... params) {
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(imageFile);
                image.compress(format, 100, fos);
            } catch (IOException e) {
                error = new ImageError(e).setErrorCode(ImageError.ERROR_GENERAL_EXCEPTION);
                this.cancel(true);
            } finally {
                if (fos != null) {
                    try {
                        fos.flush();
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return null;
        }

        @Override
        protected void onCancelled() {
            listener.onBitmapSaveError(error);
        }

        @Override
        protected void onPostExecute(Void result) {
            listener.onBitmapSaved();
        }
    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
  }

public static Bitmap readFromDisk(@NonNull File imageFile) {
    if (!imageFile.exists() || imageFile.isDirectory()) return null;
    return BitmapFactory.decodeFile(imageFile.getAbsolutePath());
}

public interface OnImageReadListener {
    void onImageRead(Bitmap bitmap);
    void onReadFailed();
}

public static void readFromDiskAsync(@NonNull File imageFile, @NonNull final OnImageReadListener listener) {
    new AsyncTask<String, Void, Bitmap>() {
        @Override
        protected Bitmap doInBackground(String... params) {
            return BitmapFactory.decodeFile(params[0]);
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            if (bitmap != null)
                listener.onImageRead(bitmap);
            else
                listener.onReadFailed();
        }
    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, imageFile.getAbsolutePath());
}

    public static final class ImageError extends Throwable {

        private int errorCode;
        public static final int ERROR_GENERAL_EXCEPTION = -1;
        public static final int ERROR_INVALID_FILE = 0;
        public static final int ERROR_DECODE_FAILED = 1;
        public static final int ERROR_FILE_EXISTS = 2;
        public static final int ERROR_PERMISSION_DENIED = 3;
        public static final int ERROR_IS_DIRECTORY = 4;


        public ImageError(@NonNull String message) {
            super(message);
        }

        public ImageError(@NonNull Throwable error) {
            super(error.getMessage(), error.getCause());
            this.setStackTrace(error.getStackTrace());
        }

        public ImageError setErrorCode(int code) {
            this.errorCode = code;
            return this;
        }

        public int getErrorCode() {
            return errorCode;
        }
      }
   }