Android'de ListView'da görüntüleri nasıl tembel olarak yükleyebilirim?

Ben kullanıyorum ListViewbu görüntülerle ilgili bazı görüntülerin ve başlıkları görüntüleme. Görüntüleri internetten alıyorum. Metinleri görüntülerken, kullanıcı arayüzü engellenmez ve resimler indirildikçe görüntülenirken görüntüleri tembel olarak yüklemenin bir yolu var mı?

Toplam görüntü sayısı sabit değildir.

Uygulamamın şu anda görüntülediği resimleri tutmak için oluşturduğum şey. Burada kullanılan "Log" nesnesinin Android içindeki son Log sınıfının etrafındaki özel paketleyicim olduğunu lütfen unutmayın.

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

Görüntülerle tembel bir listenin (GitHub'da) basit bir demosunu yaptım .

Temel Kullanım

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

AndroidManifest.xml'nize aşağıdaki izinleri eklemeyi unutmayın:

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

yalnızca bir ImageLoader örneği oluşturun ve uygulamanızın her yerinde yeniden kullanın. Bu şekilde görüntü önbelleklemesi çok daha verimli olacaktır.

Birisi için yararlı olabilir. Arka plan iş parçacığındaki görüntüleri indirir. Görüntüler bir SD kartta ve bellekte önbelleğe alınıyor. Önbellek uygulaması çok basittir ve demo için yeterlidir. Bellek tüketimini azaltmak için inSampleSize ile görüntüleri çözerim. Ayrıca geri dönüştürülmüş görünümleri doğru şekilde ele almaya çalışıyorum.

Açık kaynaklı enstrüman Universal Image Loader'ı öneririm . Başlangıçta Fedor Vlasov'un LazyList projesine dayanıyor ve o zamandan beri büyük ölçüde geliştirildi.

• Çok iş parçacıklı görüntü yükleme
• Geniş ayarlama ImageLoader yapılandırması (iş parçacığı yürütücüler, indirme, kod çözücü, bellek ve disk önbelleği, ekran görüntü seçenekleri ve diğerleri)
• Bellekte ve / veya cihazın dosya sisteminde (veya SD kartında) görüntü önbellekleme olasılığı
• Yükleme işlemini "dinleme" imkanı
• Her ekran görüntüsü çağrısını ayrı seçeneklerle özelleştirme imkanı
• Widget desteği
• Android 2.0+ desteği

Performans için Multithreading , Gilles Debunne tarafından bir eğitim.

Bu Android Geliştiricileri Blogu'ndan. Önerilen kod şunları kullanır:

• AsyncTasks.
• Sert, sınırlı bir boyut FIFO cache,.
• Yumuşak, kolay garbage collectokunan bir önbellek.
• İndirirken bir yer tutucuDrawable .

Güncelleme: Bu cevabın şimdi oldukça etkisiz olduğunu unutmayın. Çöp Toplayıcı SoftReference ve WeakReference üzerinde agresif bir şekilde çalışır, bu nedenle bu kod yeni uygulamalar için uygun DEĞİLDİR. (Bunun yerine, diğer yanıtlarda önerilen Universal Image Loader gibi kitaplıkları deneyin .)

Kod için James'e ve SoftReference kullanma önerisi için Bao-Long'a teşekkürler. James'in kodunda SoftReference değişikliklerini uyguladım. Ne yazık ki SoftReferences görüntülerimin çok hızlı bir şekilde çöp toplanmasına neden oldu. Benim durumumda, SoftReference materyalleri olmadan iyiydi, çünkü liste boyutum sınırlı ve resimlerim küçük.

Bir yıl önce google gruplarındaki SoftReferences ile ilgili bir tartışma var: link to thread . Çok erken çöp toplama için bir çözüm olarak, VM yığın boyutunu manuel olarak benim için çok çekici olmayan dalvik.system.VMRuntime.setMinimumHeapSize () kullanarak ayarlama olasılığını öneriyorlar.

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

Picasso

Jake Wharton'un Picasso Kütüphanesini kullanın. (Mükemmel bir ImageLoading Kütüphanesi, ActionBarSherlock geliştiricisini oluşturur)

Android için güçlü bir görüntü indirme ve önbellek kütüphanesi.

Görüntüler, Android uygulamalarına çok ihtiyaç duyulan bağlam ve görsel yetenek katıyor. Picasso, uygulamanızda sorunsuz bir şekilde resim yüklemeye olanak tanır - genellikle tek bir kod satırında!

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

Android'de resim yüklemenin birçok yaygın tuzağı Picasso tarafından otomatik olarak ele alınır:

Bir bağdaştırıcıda ImageView geri dönüşüm ve indirme iptalini kullanma. Minimum bellek kullanımı ile karmaşık görüntü dönüşümleri. Otomatik bellek ve disk önbellekleme.

Picasso Jake Wharton Kütüphanesi

yarı ünlü

Glide, Android için medya kod çözme, bellek ve disk önbellekleme ve kaynak havuzlamayı basit ve kullanımı kolay bir arayüze saran hızlı ve verimli bir açık kaynaklı medya yönetim çerçevesidir.

Glide, video görüntüleri, görüntüler ve animasyonlu GIF'lerin getirilmesini, kodunun çözülmesini ve görüntülenmesini destekler. Glide, geliştiricilerin neredeyse tüm ağ yığınlarına bağlanmasına izin veren esnek bir API içerir. Glide varsayılan olarak özel bir HttpUrlConnection tabanlı yığın kullanır, ancak bunun yerine Google'ın Volley projesine veya Square'in OkHttp kütüphanesine takılan yardımcı program kitaplıkları da içerir.

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

Glide'ın ana odağı, herhangi bir görüntü listesini kaydırmayı olabildiğince pürüzsüz ve hızlı hale getirmektir, ancak Glide, uzak bir görüntüyü getirmeniz, yeniden boyutlandırmanız ve görüntülemeniz gereken hemen hemen her durumda etkilidir.

Glide Görüntü Yükleme Kütüphanesi

Facebook tarafından Fresk

Fresco, Android uygulamalarında görüntüleri görüntülemek için güçlü bir sistemdir.

Fresco, görüntü yükleme ve görüntüleme işlemlerini halleder, böylece zorunda kalmazsınız. Ağdan, yerel depodan veya yerel kaynaklardan görüntü yükler ve görüntü gelene kadar bir yer tutucu görüntüler. İki önbellek seviyesi vardır; biri bellekte, diğeri dahili depolamada.

Fresco Github

Android 4.x ve önceki sürümlerde, Fresco görüntüleri Android belleğinin özel bir bölgesine yerleştirir. Bu, uygulamanızın daha hızlı çalışmasını sağlar ve korkunç OutOfMemoryError'ı daha az sıklıkta çeker.

Fresco Belgeleri

Yüksek performanslı yükleyici - burada önerilen yöntemleri inceledikten sonra Ben'in çözümünü bazı değişikliklerle kullandım -

1. Çekmecelerle çalışmanın bitmap'lerden daha hızlı olduğunu fark ettim, bunun yerine çekmeceleri kullandım

2. SoftReference kullanmak harika, ancak önbelleğe alınan görüntünün çok sık silinmesini sağlıyor, bu yüzden önceden tanımlanmış bir boyuta ulaşana kadar görüntünün silinmesini önleyerek görüntü referanslarını tutan bir Bağlantılı liste ekledim

3. InputStream'i açmak için web önbelleğini kullanmama izin veren java.net.URLConnection kullandım (önce bir yanıt önbelleği ayarlamanız gerekir, ancak bu başka bir hikaye)

Kodum:

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

Bu Android Eğitimini takip ettim ve ana kullanıcı arayüzünü engellemeden resimleri indirmede mükemmel bir iş çıkardığını düşünüyorum. Ayrıca önbellekleme ve birçok görüntüde kaydırma ile başa çıkma işlemlerini gerçekleştirir: Büyük Bitmap'leri Verimli Yükleme

1. Picasso , uygulamanızda sorunsuz bir şekilde resim yüklemeye izin verir - genellikle bir kod satırında!

Gradle kullanın:

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

Sadece bir satır kod!

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

2. Glide Düzgün kaydırmaya odaklanan Android için bir görüntü yükleme ve önbellek kütüphanesi

Gradle kullanın:

repositories {
  mavenCentral() 
  google()
}

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

// Basit bir görünüm için:

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

3. fresk , Android uygulamalarında görüntüleri görüntülemek için güçlü bir sistemdir.

Fresk ile Başlarken

Liste görünümünde görüntülerin tembel olarak nasıl yükleneceğini açıklayan bir eğitici yazdım. Geri dönüşüm ve eşzamanlılık konularında biraz ayrıntıya giriyorum. Ayrıca bir çok iş parçacığının ortaya çıkmasını önlemek için sabit bir iş parçacığı havuzu kullanıyorum.

Listview Eğitiminde görüntülerin tembel yüklenmesi

Bunu yapmanın yolu, arka planda görüntüleri indirmek ve her liste öğesi için bir geri arama vermek için bir iş parçacığı başlatmaktır. Bir resim indirmeyi tamamladığında, liste öğesinin görünümünü güncelleyen geri aramayı çağırır.

Ancak görünümleri geri dönüştürürken bu yöntem çok işe yaramaz.

Sadece bir tane daha iyi örnek, XML Adaptörleri eklemek istiyorum . Google tarafından kullanıldığından ve ben de OutOfMemory hatasını önlemek için aynı mantığı kullanıyorum.

Temel olarak bu ImageDownloader cevabınızdır (gereksinimlerinizin çoğunu karşıladığı için). Bazıları da bunu uygulayabilirsiniz.

Bu, Android'de birçok kişi tarafından birçok şekilde çözülen yaygın bir sorundur. Bence gördüğüm en iyi çözüm, Picasso adında nispeten yeni bir kütüphane . İşte önemli noktalar:

• Açık kaynak, ancak tarafından başkanlığında Jake Whartonbir ActionBarSherlock ün.
• Tek bir kod satırı ile ağ veya uygulama kaynaklarından eşzamansız olarak resim yükleyin
• Otomatik ListViewalgılama
• Otomatik disk ve bellek önbellekleme
• Özel dönüşümler yapabilir
• Birçok yapılandırılabilir seçenek
• Süper basit API
• Sık güncellenen

Yeni Android Voleybolu Kütüphanesi'nden NetworkImageView kullanıyorum com.android.volley.toolbox.NetworkImageViewve oldukça iyi çalışıyor gibi görünüyor. Görünüşe göre, bu, Google Play ve diğer yeni Google uygulamalarında kullanılan görünümle aynıdır . Kesinlikle kontrol etmeye değer.

• Google I / O 2013 voleybolu görüntü önbellek eğitimi

• Geliştiriciler Google etkinlikleri

İnternetten görüntü yükleme süresinin birçok çözümü var. Android-Query kitaplığını da kullanabilirsiniz . Size gerekli tüm aktiviteyi verecektir. Ne yapmak istediğinizden emin olun ve kütüphane wiki sayfasını okuyun. Ve resim yükleme kısıtlamasını çözün.

Bu benim kodum:

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

Tembel yükleme probleminizi çözmelisiniz.

Bu sorunun Android geliştiricileri arasında çok popüler olduğunu düşünüyorum ve bu sorunu çözdüğünü iddia eden çok sayıda kütüphane var, ancak bunlardan sadece birkaçı markette görünüyor. AQuery böyle bir kütüphanedir, ancak her yönüyle çoğundan daha iyidir ve denemeye değer.

Bu Evrensel Yükleyicinin en iyisi olduğunu denemelisiniz. Ben tembel yükleme üzerinde birçok RnD yaptıktan sonra kullanıyorum.

Evrensel Görüntü Yükleyici

Özellikleri

• Çok iş parçacıklı görüntü yükleme (zaman uyumsuzluk veya senkronizasyon)
• ImageLoader yapılandırmasının geniş çapta özelleştirilmesi (iş parçacığı yürütücüleri, indirici, kod çözücü, bellek ve disk önbelleği, ekran görüntüsü seçenekleri vb.)
• Her görüntülü arama için birçok özelleştirme seçeneği (saplama görüntüleri, önbellek anahtarı, kod çözme seçenekleri, Bitmap işleme ve görüntüleme vb.)
• Bellekte ve / veya diskte görüntü önbelleğe alma (cihazın dosya sistemi veya SD kartı)
• Dinleme yükleme işlemi (indirme işlemi dahil)

Android 2.0+ desteği

Applidium'un hafif SDWebImage (iOS'ta güzel bir kütüphane) bağlantı noktası olan Shutterbug'a bir göz atın . Eşzamansız önbelleğe almayı destekler, başarısız URL'leri depolar, eşzamanlılığı iyi işler ve yardımcı alt sınıflar dahildir.

Çekme istekleri (ve hata raporları) da kabul edilir!

DroidParts , başlamak için sıfır yapılandırma gerektiren ImageFetcher'a sahiptir .

• Disk ve bellek içi En Son Kullanılan (LRU) önbellek kullanır.
• Görüntüleri verimli bir şekilde çözer.
• Arka plan iş parçacığında bitmap'lerin değiştirilmesini destekler.
• Basit çapraz geçişe sahiptir.
• Görüntü yükleme ilerleme geri çağrısı var.

Klon DroidPartsGram bir örnek için:

Tembel yükleme görüntüleri için hangi kütüphanenin kullanılacağı konusunda kararsız olan biri için hızlı bir ipucu:

Dört temel yol vardır.

1. DIY => En iyi çözüm değil, birkaç görüntü için ve başka kütüphaneleri kullanma zahmeti olmadan gitmek istiyorsanız

2. Volley'nin Tembel Yükleme kütüphanesi => Android çocuklar. Güzel ve her şey ama kötü belgelenmiş ve bu nedenle kullanmak için bir sorun.

3. Picasso: Sadece işe yarayan basit bir çözüm, getirmek istediğiniz görüntü boyutunu bile belirtebilirsiniz. Kullanımı çok basittir, ancak çok sayıda görüntü ile uğraşmak zorunda olan uygulamalar için çok "performans" olmayabilir.

4. UIL: Görüntüleri tembel olarak yüklemenin en iyi yolu. Görüntüleri önbelleğe alabilir (elbette izne ihtiyacınız vardır), yükleyiciyi bir kez başlatabilir, sonra işinizi yapabilirsiniz. Şimdiye kadar gördüğüm en olgun asenkron görüntü yükleme kütüphanesi.

Novoda ayrıca harika bir tembel resim yükleme kütüphanesine sahiptir ve Songkick, Podio, SecretDJ ve ImageSearch gibi birçok uygulama kütüphanelerini kullanır.

Kütüphaneleri burada Github'da barındırılıyor ve oldukça aktif bir sorun izleyicisine sahipler . Projeleri de oldukça aktif görünüyor, bu cevabı yazarken 300'den fazla taahhüt var.

LazyList çatalımı kontrol et . Temel olarak, ImageView çağrısını geciktirerek LazyList'i geliştiriyorum ve iki yöntem oluşturuyorum:

1. "Resim yükleniyor ..." gibi bir şey koymanız gerektiğinde
2. İndirilen resmi göstermeniz gerektiğinde.

Ben de bir uygulayarak ImageLoader geliştirilmiş singleton bu nesnede.

Shimmer düzenini Facebook gibi göstermek istiyorsanız bunun için resmi bir facebook kütüphanesi var. FaceBook Shimmer Android

Her şeyi halleder, sadece istediğiniz tasarım kodunu pırıltılı çerçeveye iç içe yerleştirmeniz gerekir. İşte bir örnek kod.

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

Ve işte bunun için java kodu.

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

Gradle dosyanıza bu bağımlılığı ekleyin.

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

İşte böyle görünüyor.

Yukarıdaki tüm kodlar kendi değer var ama benim kişisel deneyim ile sadece Picasso ile deneyin.

Picasso özellikle bu amaç için bir kütüphanedir, aslında önbelleği ve diğer tüm ağ işlemlerini otomatik olarak yönetecektir.Projenize kitaplık eklemeniz ve uzak URL'den resim yüklemek için tek bir kod satırı yazmanız gerekecektir.

Lütfen burayı ziyaret edin: http://code.tutsplus.com/tutorials/android-sdk-working-with-picasso--cms-22149

Kayma kitaplığını kullanın. Benim için çalıştı ve kodunuz için de çalışacak. Hem görüntüler hem de gifler için çalışır.

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

Bir cazibe gibi çalışan farklı bir yol önerebilirim: Android Sorgu.

Bunu indirebilirsiniz JAR dosyayı buraya

AQuery androidAQuery = new AQuery(this);

Örnek olarak:

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

Çok hızlı ve doğru ve bunu yüklerken animasyon, bitmap (gerekirse), vb. Gibi birçok özellik bulabilirsiniz.

Ver Aquery bir deneyin. Görüntüleri eşzamansız olarak yüklemek ve önbelleğe almak için inanılmaz basit yöntemlere sahiptir.

URLImageViewHelper bunu yapmanıza yardımcı olan harika bir kütüphanedir.

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

Bu sorunu yaşadım ve lruCache'i uyguladım. API 12 ve üstü sürümlere ihtiyacınız olduğunu veya uyumluluk v4 kütüphanesini kullandığınızı düşünüyorum. lurCache hızlı bir bellektir, ancak bir bütçesi de vardır, bu yüzden bir disk önbellek kullanabileceğinizden endişe ediyorsanız ... Hepsi Bitmap'leri Önbelleğe Alma'da açıklanır .

Şimdi böyle bir yerden çağırdığım tek bir uygulama olan uygulamanızı sağlayacağım :

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

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

Web görüntüsünü alırken bir bağdaştırıcının getView öğesinde önbelleğe almak ve ardından yukarıdaki kodu çağırmak için ideal kod şunlardır:

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