AndroidのListViewで画像を遅延読み込みする方法

ListView一部の画像とそれらの画像に関連付けられたキャプションを表示するためにを使用しています。インターネットから画像を取得しています。画像を遅延読み込みする方法はありますか？テキストが表示されている間、UIはブロックされず、画像がダウンロードされるときに表示されますか？

画像の総数は決まっていません。

これが、アプリが現在表示している画像を保持するために作成したものです。ここで使用されている「Log」オブジェクトは、Android内の最後のLogクラスのカスタムラッパーであることに注意してください。

package com.wilson.android.library;

/*
 Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
*/
import java.io.IOException;

public class DrawableManager {
    private final Map<String, Drawable> drawableMap;

    public DrawableManager() {
        drawableMap = new HashMap<String, Drawable>();
    }

    public Drawable fetchDrawable(String urlString) {
        if (drawableMap.containsKey(urlString)) {
            return drawableMap.get(urlString);
        }

        Log.d(this.getClass().getSimpleName(), "image url:" + urlString);
        try {
            InputStream is = fetch(urlString);
            Drawable drawable = Drawable.createFromStream(is, "src");


            if (drawable != null) {
                drawableMap.put(urlString, drawable);
                Log.d(this.getClass().getSimpleName(), "got a thumbnail drawable: " + drawable.getBounds() + ", "
                        + drawable.getIntrinsicHeight() + "," + drawable.getIntrinsicWidth() + ", "
                        + drawable.getMinimumHeight() + "," + drawable.getMinimumWidth());
            } else {
              Log.w(this.getClass().getSimpleName(), "could not get thumbnail");
            }

            return drawable;
        } catch (MalformedURLException e) {
            Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
            return null;
        } catch (IOException e) {
            Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
            return null;
        }
    }

    public void fetchDrawableOnThread(final String urlString, final ImageView imageView) {
        if (drawableMap.containsKey(urlString)) {
            imageView.setImageDrawable(drawableMap.get(urlString));
        }

        final Handler handler = new Handler() {
            @Override
            public void handleMessage(Message message) {
                imageView.setImageDrawable((Drawable) message.obj);
            }
        };

        Thread thread = new Thread() {
            @Override
            public void run() {
                //TODO : set imageView to a "pending" image
                Drawable drawable = fetchDrawable(urlString);
                Message message = handler.obtainMessage(1, drawable);
                handler.sendMessage(message);
            }
        };
        thread.start();
    }

    private InputStream fetch(String urlString) throws MalformedURLException, IOException {
        DefaultHttpClient httpClient = new DefaultHttpClient();
        HttpGet request = new HttpGet(urlString);
        HttpResponse response = httpClient.execute(request);
        return response.getEntity().getContent();
    }
}

画像付きの遅延リスト（GitHubにあります）の簡単なデモを作成しました。

基本的な使い方

ImageLoader imageLoader=new ImageLoader(context); ...
imageLoader.DisplayImage(url, imageView); 

AndroidManifest.xmlに次の権限を追加することを忘れないでください。

 <uses-permission android:name="android.permission.INTERNET"/>
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> Please

ImageLoaderのインスタンスを1つだけ作成し、アプリケーション全体で再利用します。このようにして、画像キャッシングははるかに効率的になります。

誰かに役立つかもしれません。バックグラウンドスレッドで画像をダウンロードします。画像はSDカードとメモリにキャッシュされています。キャッシュの実装は非常に単純で、デモには十分です。メモリの消費を減らすために、inSampleSizeで画像をデコードします。また、リサイクルされたビューを正しく処理しようとしています。

オープンソースの計測器Universal Image Loaderをお勧めします。もともとはFedor VlasovのプロジェクトLazyListに基づいており、それ以来大幅に改善されています。

• マルチスレッドイメージの読み込み
• ImageLoaderの構成を幅広く調整する可能性（スレッドエグゼキューター、ダウンローダー、デコーダー、メモリとディスクキャッシュ、画像オプションの表示など）
• メモリおよび/またはデバイスのファイルシステム（またはSDカード）での画像キャッシュの可能性
• ロードプロセスを「リッスン」する可能性
• 別々のオプションですべてのディスプレイ画像呼び出しをカスタマイズする可能性
• ウィジェットのサポート
• Android 2.0以降のサポート

パフォーマンスのためのマルチスレッド、Gilles Debunneによるチュートリアル。

これはAndroid開発者ブログからです。提案されたコードは以下を使用します：

• AsyncTasks。
• ハードな、限られたサイズFIFO cache。
• ソフトで簡単にgarbage collect編集できるキャッシュ。
• ダウンロード中のプレースホルダー Drawable。

更新：この回答は現在かなり効果がないことに注意してください。ガベージコレクターはSoftReferenceとWeakReferenceに対して積極的に動作するため、このコードは新しいアプリには適していません。 （代わりに、他の回答で提案されているUniversal Image Loaderのようなライブラリを試してください。）

コードについてはJamesに、SoftReferenceの使用を提案してくれたBao-Longに感謝します。JamesのコードにSoftReferenceの変更を実装しました。残念ながら、SoftReferencesを使用すると、画像のガベージコレクションが速すぎます。私の場合、リストのサイズが制限されており、画像が小さいため、SoftReferenceがなくても問題ありませんでした。

1年前のGoogleグループのSoftReferencesに関する議論があります：スレッドへのリンク。初期のガベージコレクションの解決策として、dalvik.system.VMRuntime.setMinimumHeapSize（）を使用してVMヒープサイズを手動で設定する可能性が示唆されていますが、あまり魅力的ではありません。

public DrawableManager() {
    drawableMap = new HashMap<String, SoftReference<Drawable>>();
}

public Drawable fetchDrawable(String urlString) {
    SoftReference<Drawable> drawableRef = drawableMap.get(urlString);
    if (drawableRef != null) {
        Drawable drawable = drawableRef.get();
        if (drawable != null)
            return drawable;
        // Reference has expired so remove the key from drawableMap
        drawableMap.remove(urlString);
    }

    if (Constants.LOGGING) Log.d(this.getClass().getSimpleName(), "image url:" + urlString);
    try {
        InputStream is = fetch(urlString);
        Drawable drawable = Drawable.createFromStream(is, "src");
        drawableRef = new SoftReference<Drawable>(drawable);
        drawableMap.put(urlString, drawableRef);
        if (Constants.LOGGING) Log.d(this.getClass().getSimpleName(), "got a thumbnail drawable: " + drawable.getBounds() + ", "
                + drawable.getIntrinsicHeight() + "," + drawable.getIntrinsicWidth() + ", "
                + drawable.getMinimumHeight() + "," + drawable.getMinimumWidth());
        return drawableRef.get();
    } catch (MalformedURLException e) {
        if (Constants.LOGGING) Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
        return null;
    } catch (IOException e) {
        if (Constants.LOGGING) Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
        return null;
    }
}

public void fetchDrawableOnThread(final String urlString, final ImageView imageView) {
    SoftReference<Drawable> drawableRef = drawableMap.get(urlString);
    if (drawableRef != null) {
        Drawable drawable = drawableRef.get();
        if (drawable != null) {
            imageView.setImageDrawable(drawableRef.get());
            return;
        }
        // Reference has expired so remove the key from drawableMap
        drawableMap.remove(urlString);
    }

    final Handler handler = new Handler() {
        @Override
        public void handleMessage(Message message) {
            imageView.setImageDrawable((Drawable) message.obj);
        }
    };

    Thread thread = new Thread() {
        @Override
        public void run() {
            //TODO : set imageView to a "pending" image
            Drawable drawable = fetchDrawable(urlString);
            Message message = handler.obtainMessage(1, drawable);
            handler.sendMessage(message);
        }
    };
    thread.start();
}

ピカソ

Jake WhartonのPicasso Libraryを使用してください。（Perfect ImageLoading LibraryはActionBarSherlockの開発者を形成しています）

Android用の強力な画像ダウンロードおよびキャッシュライブラリ。

画像は、Androidアプリケーションに待望のコンテキストと視覚的センスを追加します。Picassoを使用すると、多くの場合1行のコードで、アプリケーションに手間をかけずに画像を読み込むことができます。

Picasso.with(context).load("http://i.imgur.com/DvpvklR.png").into(imageView);

Androidでの画像読み込みの一般的な多くの落とし穴は、ピカソによって自動的に処理されます。

アダプターでのImageViewのリサイクルとダウンロードのキャンセルの処理。最小限のメモリ使用で複雑な画像変換。自動メモリとディスクキャッシュ。

ピカソジェイクウォートン図書館

グライド

Glideは、Android向けの高速で効率的なオープンソースのメディア管理フレームワークで、メディアのデコード、メモリとディスクのキャッシュ、リソースのプールをシンプルで使いやすいインターフェースにラップします。

Glideは、ビデオの静止画、画像、アニメーションGIFのフェッチ、デコード、表示をサポートしています。Glideには、開発者がほとんどすべてのネットワークスタックにプラグインできる柔軟なAPIが含まれています。デフォルトでは、GlideはカスタムのHttpUrlConnectionベースのスタックを使用しますが、代わりにGoogleのVolleyプロジェクトまたはSquareのOkHttpライブラリにプラグインするユーティリティライブラリも含まれています。

Glide.with(this).load("http://goo.gl/h8qOq7").into(imageView);

Glideの主な焦点は、あらゆる種類の画像のリストをできるだけスムーズかつ高速にスクロールすることですが、Glideは、リモート画像をフェッチ、サイズ変更、表示する必要があるほとんどすべての場合にも効果的です。

グライド画像読み込みライブラリ

Facebookによるフレスコ

フレスコは、Androidアプリケーションで画像を表示するための強力なシステムです。

Frescoが画像のロードと表示を処理するので、必要はありません。ネットワーク、ローカルストレージ、またはローカルリソースから画像を読み込み、画像が到着するまでプレースホルダーを表示します。キャッシュには2つのレベルがあります。1つはメモリに、もう1つは内部ストレージにあります。

フレスコGithub

Android 4.x以前では、Frescoは画像をAndroidメモリの特別な領域に配置します。これにより、アプリケーションの実行が速くなり、恐ろしいOutOfMemoryErrorが発生する頻度が大幅に減少します。

フレスコドキュメンテーション

高性能ローダー-ここで提案された方法を検討した後、いくつかの変更を加えてベンのソリューションを使用しました-

1. ドローアブルでの作業はビットマップでの作業よりも速いため、代わりにドローアブルを使用していることに気付きました

2. SoftReferenceの使用はすばらしいですが、キャッシュされた画像が頻繁に削除されるので、画像の参照を保持するリンクリストを追加して、事前定義されたサイズに達するまで画像が削除されないようにしました

3. InputStreamを開くには、java.net.URLConnectionを使用しました。これにより、Webキャッシュを使用できます（最初に応答キャッシュを設定する必要がありますが、それは別の話です）。

私のコード：

import java.util.Map; 
import java.util.HashMap; 
import java.util.LinkedList; 
import java.util.Collections; 
import java.util.WeakHashMap; 
import java.lang.ref.SoftReference; 
import java.util.concurrent.Executors; 
import java.util.concurrent.ExecutorService; 
import android.graphics.drawable.Drawable;
import android.widget.ImageView;
import android.os.Handler;
import android.os.Message;
import java.io.InputStream;
import java.net.MalformedURLException; 
import java.io.IOException; 
import java.net.URL;
import java.net.URLConnection;

public class DrawableBackgroundDownloader {    

private final Map<String, SoftReference<Drawable>> mCache = new HashMap<String, SoftReference<Drawable>>();   
private final LinkedList <Drawable> mChacheController = new LinkedList <Drawable> ();
private ExecutorService mThreadPool;  
private final Map<ImageView, String> mImageViews = Collections.synchronizedMap(new WeakHashMap<ImageView, String>());  

public static int MAX_CACHE_SIZE = 80; 
public int THREAD_POOL_SIZE = 3;

/**
 * Constructor
 */
public DrawableBackgroundDownloader() {  
    mThreadPool = Executors.newFixedThreadPool(THREAD_POOL_SIZE);  
}  


/**
 * Clears all instance data and stops running threads
 */
public void Reset() {
    ExecutorService oldThreadPool = mThreadPool;
    mThreadPool = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
    oldThreadPool.shutdownNow();

    mChacheController.clear();
    mCache.clear();
    mImageViews.clear();
}  

public void loadDrawable(final String url, final ImageView imageView,Drawable placeholder) {  
    mImageViews.put(imageView, url);  
    Drawable drawable = getDrawableFromCache(url);  

    // check in UI thread, so no concurrency issues  
    if (drawable != null) {  
        //Log.d(null, "Item loaded from mCache: " + url);  
        imageView.setImageDrawable(drawable);  
    } else {  
        imageView.setImageDrawable(placeholder);  
        queueJob(url, imageView, placeholder);  
    }  
} 


private Drawable getDrawableFromCache(String url) {  
    if (mCache.containsKey(url)) {  
        return mCache.get(url).get();  
    }  

    return null;  
}

private synchronized void putDrawableInCache(String url,Drawable drawable) {  
    int chacheControllerSize = mChacheController.size();
    if (chacheControllerSize > MAX_CACHE_SIZE) 
        mChacheController.subList(0, MAX_CACHE_SIZE/2).clear();

    mChacheController.addLast(drawable);
    mCache.put(url, new SoftReference<Drawable>(drawable));

}  

private void queueJob(final String url, final ImageView imageView,final Drawable placeholder) {  
    /* Create handler in UI thread. */  
    final Handler handler = new Handler() {  
        @Override  
        public void handleMessage(Message msg) {  
            String tag = mImageViews.get(imageView);  
            if (tag != null && tag.equals(url)) {
                if (imageView.isShown())
                    if (msg.obj != null) {
                        imageView.setImageDrawable((Drawable) msg.obj);  
                    } else {  
                        imageView.setImageDrawable(placeholder);  
                        //Log.d(null, "fail " + url);  
                    } 
            }  
        }  
    };  

    mThreadPool.submit(new Runnable() {  
        @Override  
        public void run() {  
            final Drawable bmp = downloadDrawable(url);
            // if the view is not visible anymore, the image will be ready for next time in cache
            if (imageView.isShown())
            {
                Message message = Message.obtain();  
                message.obj = bmp;
                //Log.d(null, "Item downloaded: " + url);  

                handler.sendMessage(message);
            }
        }  
    });  
}  



private Drawable downloadDrawable(String url) {  
    try {  
        InputStream is = getInputStream(url);

        Drawable drawable = Drawable.createFromStream(is, url);
        putDrawableInCache(url,drawable);  
        return drawable;  

    } catch (MalformedURLException e) {  
        e.printStackTrace();  
    } catch (IOException e) {  
        e.printStackTrace();  
    }  

    return null;  
}  


private InputStream getInputStream(String urlString) throws MalformedURLException, IOException {
    URL url = new URL(urlString);
    URLConnection connection;
    connection = url.openConnection();
    connection.setUseCaches(true); 
    connection.connect();
    InputStream response = connection.getInputStream();

    return response;
}
}

私はこのAndroidトレーニングを実施しましたが、メインのUIをブロックすることなく画像をダウンロードすることは素晴らしい仕事だと思います。また、キャッシュと多くの画像のスクロール処理も処理します。大きなビットマップを効率的にロードする

1. Picassoを使用すると、多くの場合1行のコードでアプリケーションに画像を簡単にロードできます。

Gradleを使用する：

implementation 'com.squareup.picasso:picasso:2.71828'

コードは1行だけです。

Picasso.get().load("http://i.imgur.com/DvpvklR.png").into(imageView);

2. Glideスムーズなスクロールに焦点を当てたAndroid用の画像読み込みおよびキャッシュライブラリ

Gradleを使用する：

repositories {
  mavenCentral() 
  google()
}

dependencies {
   implementation 'com.github.bumptech.glide:glide:4.7.1'
   annotationProcessor 'com.github.bumptech.glide:compiler:4.7.1'
}

//単純なビューの場合：

  Glide.with(this).load("http://i.imgur.com/DvpvklR.png").into(imageView);

3. フレスコ は、Androidアプリケーションで画像を表示するための強力なシステムです。フレスコは、画像のロードと表示を処理するので、あなたがする必要はありません。

フレスコ入門

リストビューで画像の遅延読み込みを行う方法を説明するチュートリアルを書きました。リサイクルと並行処理の問題について詳しく説明します。また、固定スレッドプールを使用して、多くのスレッドが生成されるのを防ぎます。

Listviewチュートリアルでの画像の遅延読み込み

私が行う方法は、バックグラウンドで画像をダウンロードするスレッドを起動し、各リスト項目のコールバックを渡すことです。画像のダウンロードが完了すると、リストアイテムのビューを更新するコールバックを呼び出します。

ただし、ビューをリサイクルしている場合、この方法はあまり機能しません。

もう1つ良い例として、XMLアダプターを追加したいと思います。これはGoogleで使用されているため、同じロジックを使用してOutOfMemoryエラーを回避しています。

基本的に、このImageDownloaderはあなたの答えです（ほとんどの要件をカバーしているため）。その中に実装できるものもあります。

これはAndroidに共通する問題であり、多くの人々によってさまざまな方法で解決されています。私の見解では、私が見た最良の解決策は、ピカソと呼ばれる比較的新しいライブラリです。ここにハイライトがあります：

• オープンソースですがJake Wharton、ActionBarSherlockが率いています名声にます。
• 1行のコードでネットワークリソースまたはアプリリソースから画像を非同期に読み込みます
• 自動 ListView検出
• ディスクとメモリの自動キャッシュ
• カスタム変換を行うことができます
• 多くの設定可能なオプション
• 超シンプルなAPI
• 頻繁に更新

私は新しいAndroid Volley LibraryのNetworkImageViewを使用していますがcom.android.volley.toolbox.NetworkImageView、かなりうまく機能しているようです。どうやら、これはGoogle Playや他の新しいGoogleアプリケーションで使用されているのと同じビューです。間違いなくチェックアウトする価値があります。

• Google I / O 2013ボレー画像キャッシュチュートリアル

• デベロッパーGoogleイベント

まあ、インターネットからの画像読み込み時間には多くの解決策があります。ライブラリAndroid-Queryを使用することもできます。それはあなたに必要なすべての活動を提供します。あなたが何をしたいかを確認し、ライブラリのwikiページを読んでください。そして、画像の読み込み制限を解決します。

これは私のコードです：

@Override
public View getView(int position, View convertView, ViewGroup parent) {
    View v = convertView;
    if (v == null) {
        LayoutInflater vi = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        v = vi.inflate(R.layout.row, null);
    }

    ImageView imageview = (ImageView) v.findViewById(R.id.icon);
    AQuery aq = new AQuery(convertView);

    String imageUrl = "http://www.vikispot.com/z/images/vikispot/android-w.png";

    aq.id(imageview).progress(this).image(imageUrl, true, true, 0, 0, new BitmapAjaxCallback() {
        @Override
        public void callback(String url, ImageView iv, Bitmap bm, AjaxStatus status) {
            iv.setImageBitmap(bm);
        }
    ));

    return v;
}

遅延読み込みの問題を解決する必要があります。

この問題はAndroid開発者の間で非常に人気があると思います。この問題を解決すると主張しているライブラリーはたくさんありますが、その一部しかマークされていないようです。AQueryはそのようなライブラリの1つですが、あらゆる面でほとんどのライブラリよりも優れており、試す価値があります。

このUniversal Loaderを試す必要があります。私は遅延読み込みで多くのRnDを実行した後にこれを使用しています。

ユニバーサルイメージローダー

特徴

• マルチスレッドイメージの読み込み（非同期または同期）
• ImageLoaderの構成の幅広いカスタマイズ（スレッドエグゼキューター、ダウンローダー、デコーダー、メモリとディスクキャッシュ、画像の表示オプションなど）
• すべての表示イメージ呼び出しの多くのカスタマイズオプション（スタブイメージ、キャッシュスイッチ、デコードオプション、ビットマップ処理と表示など）
• メモリおよび/またはディスク（デバイスのファイルシステムまたはSDカード）での画像のキャッシュ
• ロードプロセスのリスニング（ダウンロードの進行状況を含む）

Android 2.0以降のサポート

見ていShutterbugを、Applidiumの軽量SDWebImage（iOSの素敵なライブラリ）のAndroidへの移植。非同期キャッシュをサポートし、失敗したURLを保存し、同時実行性を適切に処理し、役立つサブクラスが含まれています。

プルリクエスト（およびバグレポート）も大歓迎です！

DroidPartsにはImageFetcherがあり、開始するためにゼロ構成が必要です。

• ディスクとメモリ内の最も最近使用された（LRU）キャッシュを使用します。
• 画像を効率的にデコードします。
• バックグラウンドスレッドでのビットマップの変更をサポートします。
• シンプルなクロスフェードがあります。
• 画像読み込み進捗コールバックがあります。

例としてDroidPartsGramのクローンを作成します。

画像の遅延読み込みに使用するライブラリーについて迷っている人のための簡単なヒント：

基本的な方法は4つあります。

1. DIY =>最善の解決策ではありませんが、いくつかの画像で、他のライブラリを使用する手間をかけずに移動したい場合

2. Volleyの遅延読み込みライブラリ=> androidの人から。それは素晴らしいですが、文書化が不十分であるため、使用するには問題があります。

3. ピカソ：機能するシンプルなソリューションです。持ち込みたい画像の正確なサイズを指定することもできます。非常に簡単に使用できますが、膨大な量の画像を処理する必要があるアプリでは、それほど「パフォーマンスがよくない」場合があります。

4. UIL：画像を遅延読み込みする最良の方法。あなたは画像をキャッシュすることができ（もちろんあなたは許可が必要です）、ローダーを一度初期化し、そしてあなたの仕事を終わらせます。これまでに見た中で最も成熟した非同期画像読み込みライブラリ。

Novodaには優れた遅延画像読み込みライブラリもあり、Songkick、Podio、SecretDJ、ImageSearchなどの多くのアプリがライブラリを使用しています。

彼らのライブラリはここ Githubでホストされており、かなり活発な課題トラッカーも持っています。彼らのプロジェクトもかなり活発で、この返信を書いている時点では300以上のコミットがあります。

LazyListの私のフォークを確認してください。基本的に、ImageViewの呼び出しを遅らせることでLazyListを改善し、2つのメソッドを作成します。

1. 「画像を読み込んでいます...」のようなものを配置する必要がある場合
2. ダウンロードした画像を表示する必要がある場合。

このオブジェクトにシングルトンを実装することにより、ImageLoaderも改善しました。

FacebookのようなShimmerレイアウトを表示したい場合は、公式Facebookライブラリがあります。FaceBookシマーAndroid

それはすべての面倒を見てくれます、あなたはあなたが望むデザインコードを入れ子式にきらめくフレームに置くだけです。これがサンプルコードです。

<com.facebook.shimmer.ShimmerFrameLayout
     android:id=“@+id/shimmer_view_container”
     android:layout_width=“wrap_content”
     android:layout_height="wrap_content"
     shimmer:duration="1000">

 <here will be your content to display />

</com.facebook.shimmer.ShimmerFrameLayout>

そして、これはそのためのJavaコードです。

ShimmerFrameLayout shimmerContainer = (ShimmerFrameLayout) findViewById(R.id.shimmer_view_container);
shimmerContainer.startShimmerAnimation();

この依存関係をgradleファイルに追加します。

implementation 'com.facebook.shimmer:shimmer:0.1.0@aar'

これはどのように見えるかです。

上記のコードにはすべて独自の価値がありますが、私の個人的な経験では、ピカソを試してみてください。

ピカソ は、この目的専用のライブラリです。実際には、キャッシュとその他すべてのネットワーク操作を自動的に管理します。プロジェクトにライブラリを追加し、コードを1行書くだけで、リモートURLから画像を読み込む必要があります。

こちらをご覧ください：http : //code.tutsplus.com/tutorials/android-sdk-working-with-picasso--cms-22149

グライドライブラリを使用します。それは私のために働いて、あなたのコードのためにも働きます。それはまた、画像だけでなくgifのためにも働きます。

ImageView imageView = (ImageView) findViewById(R.id.test_image); 
    GlideDrawableImageViewTarget imagePreview = new GlideDrawableImageViewTarget(imageView);
    Glide
            .with(this)
            .load(url)
            .listener(new RequestListener<String, GlideDrawable>() {
                @Override
                public boolean onException(Exception e, String model, Target<GlideDrawable> target, boolean isFirstResource) {                       
                    return false;
                }

                @Override
                public boolean onResourceReady(GlideDrawable resource, String model, Target<GlideDrawable> target, boolean isFromMemoryCache, boolean isFirstResource) {
                    return false;
                }
            })
            .into(imagePreview);
}

チャームのように機能する別の方法、Androidクエリをお勧めします。

ここからJARファイルをダウンロードできます。

AQuery androidAQuery = new AQuery(this);

例として：

androidAQuery.id(YOUR IMAGEVIEW).image(YOUR IMAGE TO LOAD, true, true, getDeviceWidth(), ANY DEFAULT IMAGE YOU WANT TO SHOW);

これは非常に高速で正確です。これを使用すると、ロード時のアニメーション、ビットマップの取得（必要な場合）など、多くの機能を見つけることができます。

与えるAqueryに試して。非同期で画像を読み込んでキャッシュする驚くほど簡単な方法があります。

URLImageViewHelperは、そのために役立つ素晴らしいライブラリです。

public class ImageDownloader {

Map<String, Bitmap> imageCache;

public ImageDownloader() {
    imageCache = new HashMap<String, Bitmap>();

}

// download function
public void download(String url, ImageView imageView) {
    if (cancelPotentialDownload(url, imageView)) {

        // Caching code right here
        String filename = String.valueOf(url.hashCode());
        File f = new File(getCacheDirectory(imageView.getContext()),
                filename);

        // Is the bitmap in our memory cache?
        Bitmap bitmap = null;

        bitmap = (Bitmap) imageCache.get(f.getPath());

        if (bitmap == null) {

            bitmap = BitmapFactory.decodeFile(f.getPath());

            if (bitmap != null) {
                imageCache.put(f.getPath(), bitmap);
            }

        }
        // No? download it
        if (bitmap == null) {
            try {
                BitmapDownloaderTask task = new BitmapDownloaderTask(
                        imageView);
                DownloadedDrawable downloadedDrawable = new DownloadedDrawable(
                        task);
                imageView.setImageDrawable(downloadedDrawable);
                task.execute(url);
            } catch (Exception e) {
                Log.e("Error==>", e.toString());
            }

        } else {
            // Yes? set the image
            imageView.setImageBitmap(bitmap);
        }
    }
}

// cancel a download (internal only)
private static boolean cancelPotentialDownload(String url,
        ImageView imageView) {
    BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);

    if (bitmapDownloaderTask != null) {
        String bitmapUrl = bitmapDownloaderTask.url;
        if ((bitmapUrl == null) || (!bitmapUrl.equals(url))) {
            bitmapDownloaderTask.cancel(true);
        } else {
            // The same URL is already being downloaded.
            return false;
        }
    }
    return true;
}

// gets an existing download if one exists for the imageview
private static BitmapDownloaderTask getBitmapDownloaderTask(
        ImageView imageView) {
    if (imageView != null) {
        Drawable drawable = imageView.getDrawable();
        if (drawable instanceof DownloadedDrawable) {
            DownloadedDrawable downloadedDrawable = (DownloadedDrawable) drawable;
            return downloadedDrawable.getBitmapDownloaderTask();
        }
    }
    return null;
}

// our caching functions
// Find the dir to save cached images
private static File getCacheDirectory(Context context) {
    String sdState = android.os.Environment.getExternalStorageState();
    File cacheDir;

    if (sdState.equals(android.os.Environment.MEDIA_MOUNTED)) {
        File sdDir = android.os.Environment.getExternalStorageDirectory();

        // TODO : Change your diretcory here
        cacheDir = new File(sdDir, "data/ToDo/images");
    } else
        cacheDir = context.getCacheDir();

    if (!cacheDir.exists())
        cacheDir.mkdirs();
    return cacheDir;
}

private void writeFile(Bitmap bmp, File f) {
    FileOutputStream out = null;

    try {
        out = new FileOutputStream(f);
        bmp.compress(Bitmap.CompressFormat.PNG, 80, out);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (out != null)
                out.close();
        } catch (Exception ex) {
        }
    }
}

// download asynctask
public class BitmapDownloaderTask extends AsyncTask<String, Void, Bitmap> {
    private String url;
    private final WeakReference<ImageView> imageViewReference;

    public BitmapDownloaderTask(ImageView imageView) {
        imageViewReference = new WeakReference<ImageView>(imageView);
    }

    @Override
    // Actual download method, run in the task thread
    protected Bitmap doInBackground(String... params) {
        // params comes from the execute() call: params[0] is the url.
        url = (String) params[0];
        return downloadBitmap(params[0]);
    }

    @Override
    // Once the image is downloaded, associates it to the imageView
    protected void onPostExecute(Bitmap bitmap) {
        if (isCancelled()) {
            bitmap = null;
        }

        if (imageViewReference != null) {
            ImageView imageView = imageViewReference.get();
            BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);
            // Change bitmap only if this process is still associated with
            // it
            if (this == bitmapDownloaderTask) {
                imageView.setImageBitmap(bitmap);

                // cache the image

                String filename = String.valueOf(url.hashCode());
                File f = new File(
                        getCacheDirectory(imageView.getContext()), filename);

                imageCache.put(f.getPath(), bitmap);

                writeFile(bitmap, f);
            }
        }
    }

}

static class DownloadedDrawable extends ColorDrawable {
    private final WeakReference<BitmapDownloaderTask> bitmapDownloaderTaskReference;

    public DownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask) {
        super(Color.WHITE);
        bitmapDownloaderTaskReference = new WeakReference<BitmapDownloaderTask>(
                bitmapDownloaderTask);
    }

    public BitmapDownloaderTask getBitmapDownloaderTask() {
        return bitmapDownloaderTaskReference.get();
    }
}

// the actual download code
static Bitmap downloadBitmap(String url) {
    HttpParams params = new BasicHttpParams();
    params.setParameter(CoreProtocolPNames.PROTOCOL_VERSION,
            HttpVersion.HTTP_1_1);
    HttpClient client = new DefaultHttpClient(params);
    final HttpGet getRequest = new HttpGet(url);

    try {
        HttpResponse response = client.execute(getRequest);
        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 {
                inputStream = entity.getContent();
                final Bitmap bitmap = BitmapFactory
                        .decodeStream(inputStream);
                return bitmap;
            } finally {
                if (inputStream != null) {
                    inputStream.close();
                }
                entity.consumeContent();
            }
        }
    } catch (Exception e) {
        // Could provide a more explicit error message for IOException or
        // IllegalStateException
        getRequest.abort();
        Log.w("ImageDownloader", "Error while retrieving bitmap from "
                + url + e.toString());
    } finally {
        if (client != null) {
            // client.close();
        }
    }
    return null;
 }
}

私にはこの問題があり、lruCacheを実装しました。API 12以上が必要か、互換性v4ライブラリを使用していると思います。lurCacheは高速メモリですが、予算もあるので、心配な場合はディスクキャッシュを使用できます...これはすべてビットマップのキャッシュで説明されていますます。

次に、このようなどこからでも呼び出すシングルトンである実装を提供します。

//Where the first is a string and the other is a imageview to load.

DownloadImageTask.getInstance().loadBitmap(avatarURL, iv_avatar);

キャッシュしてWebイメージを取得するときに、アダプターのgetViewで上記を呼び出す理想的なコードを次に示します。

public class DownloadImageTask {

    private LruCache<String, Bitmap> mMemoryCache;

    /* Create a singleton class to call this from multiple classes */

    private static DownloadImageTask instance = null;

    public static DownloadImageTask getInstance() {
        if (instance == null) {
            instance = new DownloadImageTask();
        }
        return instance;
    }

    //Lock the constructor from public instances
    private DownloadImageTask() {

        // Get max available VM memory, exceeding this amount will throw an
        // OutOfMemory exception. Stored in kilobytes as LruCache takes an
        // int in its constructor.
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

        // Use 1/8th of the available memory for this memory cache.
        final int cacheSize = maxMemory / 8;

        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                // The cache size will be measured in kilobytes rather than
                // number of items.
                return bitmap.getByteCount() / 1024;
            }
        };
    }

    public void loadBitmap(String avatarURL, ImageView imageView) {
        final String imageKey = String.valueOf(avatarURL);

        final Bitmap bitmap = getBitmapFromMemCache(imageKey);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
        } else {
            imageView.setImageResource(R.drawable.ic_launcher);

            new DownloadImageTaskViaWeb(imageView).execute(avatarURL);
        }
    }

    private void addBitmapToMemoryCache(String key, Bitmap bitmap) {
        if (getBitmapFromMemCache(key) == null) {
            mMemoryCache.put(key, bitmap);
        }
    }

    private Bitmap getBitmapFromMemCache(String key) {
        return mMemoryCache.get(key);
    }

    /* A background process that opens a http stream and decodes a web image. */

    class DownloadImageTaskViaWeb extends AsyncTask<String, Void, Bitmap> {
        ImageView bmImage;

        public DownloadImageTaskViaWeb(ImageView bmImage) {
            this.bmImage = bmImage;
        }

        protected Bitmap doInBackground(String... urls) {

            String urldisplay = urls[0];
            Bitmap mIcon = null;
            try {
                InputStream in = new java.net.URL(urldisplay).openStream();
                mIcon = BitmapFactory.decodeStream(in);

            } 
            catch (Exception e) {
                Log.e("Error", e.getMessage());
                e.printStackTrace();
            }

            addBitmapToMemoryCache(String.valueOf(urldisplay), mIcon);

            return mIcon;
        }

        /* After decoding we update the view on the main UI. */
        protected void onPostExecute(Bitmap result) {
            bmImage.setImageBitmap(result);
        }
    }
}