Lazy načítání obrázků v ListView

hlasů
1k

Já používám ListViewpro zobrazení nějaké obrázky a popisky spojené s těmito obrazy. Jsem dostat obrázky z internetu. Existuje způsob, jak líný zatížení obrazy, takže zatímco textové informace, UI není uzamčené a obrázky jsou zobrazeny jako oni jsou staženy?

Celkový počet snímků není stanovena.

Položena 12/02/2009 v 16:59
zdroj uživatelem
V jiných jazycích...                            


39 odpovědí

hlasů
999

Tady je to, co jsem vytvořil pro uložení obrázků, které má aplikace je v současné době zobrazování. Vezměte prosím na vědomí, že „Log“ objekt v provozu zde je mým zvykem obal kolem konečné třídy Log uvnitř Android.

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();
    }
}
Odpovězeno 18/02/2009 v 04:56
zdroj uživatelem

hlasů
979

Udělal jsem jednoduchý demo líné seznamu (umístěné na GitHub) s obrazy. To může být užitečné pro někoho. Stáhne obrázky v pozadí závit na. Snímky jsou ukládány do mezipaměti na SD kartu a do paměti. Implementace mezipaměti je velmi jednoduchá a je jen dost pro demo. I dekódovat obraz s inSampleSize snížit spotřebu paměti. Snažím se také správně zpracovat recyklovaných názory.

alt text

Odpovězeno 18/06/2010 v 09:04
zdroj uživatelem

hlasů
526

Doporučuji open source nástroj Universal Image Loader . Je původně založený na Fedora Vlasova projektu LazyList a byl výrazně zlepšila od té doby.

  • Vícevláknové image loading
  • Možnost konfigurace širokým rozsahem ladění ImageLoader je (závit exekutory, downlaoder, dekodéru, paměti a vyrovnávací paměti disku, možnosti zobrazení obrazu, a další)
  • Možnost obrazové mezipaměti v paměti a / nebo na soubor sysytem (nebo SD karty) zařízení
  • Proces načítání možnost „naslouchat“
  • Možnost přizpůsobit každý zobrazení obrazu hovor s oddělenými možností
  • Widget podpora
  • Androidu 2.0+ podpora

Odpovězeno 19/12/2011 v 14:53
zdroj uživatelem

hlasů
146

Multithreading pro výkon , návod Gillese Debunne.

To je z Android Developers Blog. Navrhovaná kód používá:

  • AsyncTasks,
  • Tvrdý, omezená velikost, FIFO cache.
  • Měkká, snadno garbage collected mezipaměti.
  • Zástupný symbol Drawable , zatímco vy stáhnout.

zadejte popis obrázku zde

Odpovězeno 12/08/2010 v 12:07
zdroj uživatelem

hlasů
101

Aktualizace: Všimněte si, že tato odpověď je teď docela neúčinné. Garbage collector působí agresivně na SoftReference a WeakReference, takže tento kód není vhodný pro nové aplikace. (Místo toho, zkuste knihovny jako Universal Image Loader je navrženo v další odpovědi.)

Díky James k zadání kódu, a Bao-Long pro návrh využití SoftReference. realizován jsem SoftReference změny na Jamesův kódu. Bohužel SoftReferences způsobil mé obrazy být uvolněna příliš rychle. V mém případě to bylo v pořádku, aniž by SoftReference věci, protože moje velikost seznamu je omezená a moje obrazy jsou malé.

Tam je diskuse před rokem, pokud jde o SoftReferences na Google skupin: odkaz na závit . Jako řešení pro sběr příliš časné odpadků, které naznačují možnost ručního nastavení velikosti VM haldy pomocí dalvik.system.VMRuntime.setMinimumHeapSize (), která není příliš atraktivní pro mě.

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();
}
Odpovězeno 05/05/2010 v 14:16
zdroj uživatelem

hlasů
83

Picasso

Použijte Picassovo knihovna Jake Wharton je. (A Perfect ImageLoading knihovna tvoří developer ActionBarSherlock)

Výkonný image stahování a ukládání do mezipaměti knihoven pro Android.

Snímky přidat tolik potřebný kontext a vizuální smysl pro aplikace Android. Picasso umožňuje bezproblémové obrazu zatížení ve vaší aplikaci, často v jednom řádku kódu!

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

Mnoho běžných úskalí snímku naložení na Android jsou zpracovávány automaticky Picasso:

Manipulace recyklace ImageView a zrušení stahování v adaptéru. Komplexní transformace obrazu s minimálním využití paměti. Automatická paměť a diskové cache.

Picasso Jake Wharton knihovna

Klouzat

Glide je rychlý a účinný rámec open source správu médií pro Android, která obaluje mediální dekódování, paměť a diskové mezipaměti a zdroj sdružování do jednoduché a snadno použitelné rozhraní.

Glide podporuje načítání, dekódování a zobrazování statických záběrů videa, obrázky a animované obrázky ve formátu GIF. Glide obsahuje pružný API, které umožňuje vývojářům zapojit do téměř libovolného síťového stacku. Ve výchozím Glide používá svazek založený vlastní HttpUrlConnection, ale zahrnuje také užitkové knihovny zapojit do projektu Google volejbal nebo knihovny OkHttp Square místo.

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

Glide primární důraz je kladen na to, aby rolování jakékoliv seznamu snímků jsou hladké a rychle, jak je to možné, ale Glide je účinný i při téměř každém případě, kde je třeba vyzvednout, změna velikosti a zobrazení vzdálený obrázek.

Glide Image Loading Library

Freska Facebook

Freska je výkonný systém pro zobrazování obrázků v aplikacích pro Android.

Fresco se stará o image nakládání a displejem, takže si nemusíte. To bude načíst obrázky ze sítě, místní úložiště nebo místních zdrojů, a zobrazí zástupný znak, dokud je tady obraz. To má dvě úrovně vyrovnávací paměti; jeden v paměti a další v interním úložišti.

Fresco Github

V Android 4.x a nižší, Fresco klade obrazy ve speciální oblasti paměti Android. To umožňuje vaše aplikace běžet rychleji - a trpí obávaný OutOfMemoryError mnohem méně často.

Fresco Dokumentace

Odpovězeno 04/04/2014 v 13:35
zdroj uživatelem

hlasů
77

Vysoký výkon nakladač - poté, co zkoumal metody zde navrhl jsem Benův řešení s některými změnami -

  1. Zjistil jsem, že práce s obrazovkami je rychlejší než s rastry, takže jsem používá obrazovkami místo

  2. Používání SoftReference je skvělé, ale to dělá cache obrazu, které mají být smazány příliš často, takže jsem přidal spojový seznam, který drží obrázky odkazy, brání obrazu, které mají být odstraněny, až do dosažení předem definované velikosti

  3. Chcete-li otevřít InputStream jsem použil java.net.URLConnection který mi umožňuje používat webové mezipaměti (je třeba nastavit cache odpovědi jako první, ale to je jiný příběh)

Můj kód:

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;
}
}
Odpovězeno 22/10/2011 v 17:44
zdroj uživatelem

hlasů
74

Sledoval jsem tento Android Školení a myslím, že to dělá vynikající práci při stahování obrázků, aniž by blokoval hlavní UI. Pracuje také s mezipaměti a zabývá procházení mnoha obrázků: Vkládání velké rastry efektivně

Odpovězeno 28/12/2012 v 00:27
zdroj uživatelem

hlasů
54

1. Picasso umožňuje bezproblémové obrazu zatížení ve vaší aplikaci, často v jednom řádku kódu!

Použít Gradle:

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

Jen jeden řádek kódu!

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

Mnoho běžných úskalí snímku naložení na Android jsou zpracovávány automaticky Picasso

  • Manipulace recyklace ImageView a stahování rušením v adaptéru.
  • Komplexní transformace obrazu s minimálním využití paměti.
  • Automatická paměť a diskové cache.

zadejte popis obrázku zde

2. Glide loading image a caching knihovna pro Android se zaměřil na plynulé posouvání

Použít Gradle:

repositories {
  mavenCentral() // jcenter() works as well because it pulls from Maven Central
}

dependencies {
  compile 'com.github.bumptech.glide:glide:3.7.0'
  compile 'com.android.support:support-v4:19.1.0'
}

// Pro jednoduchý pohled:

@Override public void onCreate(Bundle savedInstanceState) {
  ...
  ImageView imageView = (ImageView) findViewById(R.id.my_image_view);

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

// Pro jednoduchý seznamu obrázků:

 @Override public View getView(int position, View recycled, ViewGroup container) {
      final ImageView myImageView;
      if (recycled == null) {
        myImageView = (ImageView) inflater.inflate(R.layout.my_image_view, container, false);
      } else {
        myImageView = (ImageView) recycled;
      }

      String url = myUrls.get(position);

      Glide
        .with(myFragment)
        .load(url)
        .centerCrop()
        .placeholder(R.drawable.loading_spinner)
        .crossFade()
        .into(myImageView);

      return myImageView;
}
Odpovězeno 22/05/2014 v 07:00
zdroj uživatelem

hlasů
49

Napsal jsem návod, který vysvětluje, jak to udělat opožděného načítání obrázků v ListView. Jdu do nějakého detailu o problematiku recyklace a souběžnosti. Já také použít pevnou nit bazénu, aby se zabránilo tření hodně nití.

Lazy načítání obrázků v Listview Tutorial

Odpovězeno 27/08/2011 v 13:54
zdroj uživatelem

hlasů
37

Jak jsem to udělat, je tím, že vypustí nit stahovat obrázky na pozadí a předat to zpětné volání pro každou položku seznamu. Je-li snímek dokončení stahování volá zpětné volání které aktualizuje zobrazení pro položku seznamu.

Tato metoda nefunguje dobře, když jste recyklaci pohledy nicméně.

Odpovězeno 12/02/2009 v 21:07
zdroj uživatelem

hlasů
29

Jen chci přidat ještě jeden dobrý příklad, XML adaptéry . Jak je to používá Google a já jsem také používat stejnou logiku, aby se zabránilo OutOfMemory chybu.

V podstatě to ImageDownloader je vaše odpověď (protože pokrývá většinu vašich požadavků). Někteří také můžete implementovat v tom.

Odpovězeno 14/12/2011 v 11:57
zdroj uživatelem

hlasů
26

Byl jsem s použitím NetworkImageView z nové Android Volley knihovny com.android.volley.toolbox.NetworkImageView, a zdá se, že pracuje velmi dobře. Zdá se, že se jedná o stejný pohled, který se používá v Google Play a dalších nových aplikací Google. Rozhodně stojí mimo kontrolu.

Odpovězeno 13/06/2013 v 16:17
zdroj uživatelem

hlasů
25

Jedná se o běžný problém v systému Android, který byl řešen v mnoha ohledech mnoho lidí. Podle mého názoru je nejlepším řešením jsem viděl je relativně nová knihovna s názvem Picasso . Zde jsou hlavní:

  • Open source, ale v čele se Jake Whartonz ActionBarSherlock slávy.
  • Asynchronně načítat obrázky ze sítě nebo aplikací zdrojů se jeden řádek kódu
  • Automatická ListViewdetekce
  • Automatická disk a paměť cache
  • Může udělat vlastní transformací
  • Spousta konfigurovatelných
  • Super jednoduché API
  • často aktualizovány
Odpovězeno 16/10/2013 v 00:22
zdroj uživatelem

hlasů
22

No image doba načítání z internetu má mnoho řešení. Můžete také použít knihovnu Android Query . To vám poskytne veškerou potřebnou činnost. Ujistěte se, že to, co chcete dělat a číst stránku knihovny wiki. A řešit omezení obrazu nakládání.

To je můj kód:

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

Mělo by to být řešení vašeho líné načítání problém.

Odpovězeno 12/02/2013 v 08:10
zdroj uživatelem

hlasů
22

Myslím, že tato otázka je velmi populární mezi vývojáři se systémem Android, a existuje spousta takových knihoven, která tvrdí, že řešení tohoto problému, ale jen málo z nich se zdá být na značce. AQuery je jedna taková knihovna, ale je to lepší než většina z nich ve všech aspektech a stojí za vyzkoušení pro.

Odpovězeno 11/12/2012 v 19:33
zdroj uživatelem

hlasů
18

Podívejte se na Shutterbug , Applidium je lehký SDWebImage (pěkná knihovna na iOS) port pro Android. Podporuje asynchronní ukládání do mezipaměti, obchody selhal adresy, zpracovává souběžnost dobře a užitečné podtřídy jsou zahrnuty.

Tahat požadavky (a hlášení chyb) jsou vítány, taky!

Odpovězeno 16/10/2012 v 13:43
zdroj uživatelem

hlasů
16

Musíte se snažit to Universal Loader je nejlepší. Já používám tento poté, co udělal mnoho RND na líné načítání.

Universal Loader Image

Funkce

  • Vícevláknové obraz zatížení (asynchronní nebo synchronizace)
  • Široké přizpůsobení konfigurace ImageLoader je (závit exekutoři, downloader, dekodér, paměť a diskové mezipaměti, možnosti zobrazení obrazu, atd.)
  • Mnoho možnosti přizpůsobení pro každé zobrazení obrazu hovoru (stub obrázky, caching přepínačů, možnosti dekódování, zpracování a zobrazení Bitmap, atd.)
  • Obraz cache paměti a / nebo na disku (zařízení se systémem souborů nebo SD karta)
  • Poslech proces (včetně stahování probíhá) loading

Androidu 2.0+ podpora

zadejte popis obrázku zde

Odpovězeno 05/02/2015 v 12:45
zdroj uživatelem

hlasů
15

DroidPartsImageFetcher která vyžaduje nulovou konfiguraci, abyste mohli začít.

  • Používá disk a do paměti nejméně naposledy použité vyrovnávací paměti (HŽP).
  • Účinně dekóduje obrázky.
  • Podporuje modifikující bitmapy v pozadí nití.
  • Má jednoduché prolnutí.
  • Má pokroku image nakládání zpětné volání.

Clone DroidPartsGram pro příklad:

Zadejte popis obrázku zde

Odpovězeno 06/05/2013 v 10:48
zdroj uživatelem

hlasů
14

Jen rychlý tip pro někoho, kdo je v nerozhodnosti ohledně toho, co knihovna použít pro líné načítání obrázků:

Existují čtyři základní způsoby.

  1. DIY => Není to nejlepší řešení, ale za pár obrázků a chcete jít bez potíží používat ostatní knihovny, pokud

  2. Volley je Lazy Loading library => Z kluků na android. Je to pěkné a všechno, ale je špatně zdokumentován, a proto je problém použít.

  3. Picasso: Jednoduché řešení, které prostě funguje, můžete si dokonce určit přesnou velikost obrázku, který chcete přinést Je velmi jednoduchý na používání, ale nemusí být velmi „výkonnější“ pro aplikace, které se musí vypořádat s Humongous množství obrazů..

  4. UIL: Nejlepší způsob, jak líných obrazů zatížení. Můžete mezipaměti obrázky (budete potřebovat svolení samozřejmě), inicializovat nakladač jednou, pak si svou práci. Nejzralejší asynchronní obraz při načítání knihovny, které jsem kdy viděl tak daleko.

Odpovězeno 03/08/2014 v 13:19
zdroj uživatelem

hlasů
14

Novoda má také velký líný jako nakládací knihovnu a mnoho aplikací, jako je Songkick, Podio, SecretDJ a ImageSearch využívat jejich knihovnu.

Jejich knihovna je umístěn zde na GitHub a mají dost aktivní otázek tracker stejně. Jejich projekt se zdá být docela aktivní i s více než 300 + dopustí v době psaní této odpovědi.

Odpovězeno 12/01/2013 v 12:00
zdroj uživatelem

hlasů
12

Zkontrolovat mé vidlici LazyList . V podstatě jsem se zlepšit LazyList zpožděním zastávek ImageView a vytvořit dvě metody:

  1. Když budete muset dát něco jako „Načítání snímku ...“
  2. Když budete muset prokázat stažený obraz.

Také jsem se zlepšil ImageLoader zavedením singleton v tomto objektu.

Odpovězeno 13/02/2013 v 00:46
zdroj uživatelem

hlasů
9

Všechny výše uvedené číslo má svou vlastní hodnotu, ale s mou osobní zkušenost jen zkusit s Picassem.

Picasso je knihovna speciálně pro tento účel, in-skutečnosti bude řídit vyrovnávací paměť a všechny ostatní síťové operace automatically.You bude muset přidat knihovnu do svého projektu a jen napsat jediný řádek kódu načíst obrázek ze vzdáleného URL.

Naleznete zde: http://code.tutsplus.com/tutorials/android-sdk-working-with-picasso--cms-22149

Odpovězeno 09/07/2015 v 16:16
zdroj uživatelem

hlasů
7

URLImageViewHelper je úžasná knihovna, která vám pomůže udělat.

Odpovězeno 27/01/2014 v 06:33
zdroj uživatelem

hlasů
7

Dej Aquery zkusit. Má úžasně jednoduché metody načíst a mezipaměti obrázků asynchronně.

Odpovězeno 16/12/2013 v 14:04
zdroj uživatelem

hlasů
7

Mohu doporučit jiný způsob, který funguje jako kouzlo: Android dotaz.

Zde si můžete stáhnout tento JAR soubor ze zde

AQuery androidAQuery = new AQuery(this);

Jako příklad:

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

Je to velmi rychlé a přesné, a to za použití najdete mnoho dalších funkcí, jako je animace při načítání, dostat bitmapu (v případě potřeby), atd.

Odpovězeno 29/07/2013 v 08:06
zdroj uživatelem

hlasů
4

Pomocí knihovny sestupové. Podařilo se mi to a bude pracovat pro váš kód too.It pracuje pro oba obrazy, stejně jako obrázky ve formátu GIF taky.

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);
}
Odpovězeno 16/03/2017 v 10:11
zdroj uživatelem

hlasů
4

Můžete zkusit Aquery Android knihovna pro líné načítání obrazu a ListView ... Níže uvedený kód může vám pomoci ..... stáhnout knihovnu odtud .

AQuery aq = new AQuery(mContext);
aq.id(R.id.image1).image("http://data.whicdn.com/images/63995806/original.jpg");
Odpovězeno 03/09/2013 v 13:41
zdroj uživatelem

hlasů
4

Měl jsem tento problém a realizovány lruCache. Věřím, že budete potřebovat API 12 nebo vyšší nebo pomocí knihovny Kompatibilita v4. lurCache je rychlá paměť, ale má také rozpočet, takže pokud máte obavy o tom, můžete použít diskcache ... To vše je popsáno v Caching bitmapy .

Budu nyní poskytují svou realizaci, který je ojedinělým Volám odkudkoliv takto:

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

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

Zde je ideální kódu do mezipaměti a při načítání webových obraz a pak zavolat výše getView z adaptéru:

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);
        }
    }
}
Odpovězeno 21/07/2013 v 18:51
zdroj uživatelem

hlasů
4
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;
 }
}
Odpovězeno 18/07/2013 v 08:16
zdroj uživatelem

hlasů
3

Některé odpovědi jsou již bylo zmíněno pomocí různých grafických knihoven, jako je Universal Image Loader a androidimageloader atd Jedná se o starou quesion, ale pro každého, kdo stále hledá něco takového existuje několik takových knihoven na snímku nakládky / cache.

Odpovězeno 08/06/2014 v 10:04
zdroj uživatelem

hlasů
3

Používám droidQuery . Existují dva mechanismy pro načítání obrázku z URL. První (zkratka) je jednoduše:

$.with(myView).image(url);

To může být přidán do ArrayAdapter‚s getView(...)metodou velmi snadno.


Způsob latinkou dá mnohem větší kontrolu a má možnosti zde není ani projednána (jako cacheing a zpětná volání), ale základní implementace, která určuje velikost výstupu jako 200px x 200px lze nalézt zde:

$.ajax(new AjaxOptions().url(url)
    .type("GET")
    .dataType("image")
    .imageWidth(200).imageHeight(200)
    .success(new Function() {
        @Override
        public void invoke($ droidQuery, Object... params) {
            myImageView.setImageBitmap((Bitmap) params[0]);
        }
    })
    .error(new Function() {
        @Override
        public void invoke($ droidQuery, Object... params) {
            AjaxError e = (AjaxError) params[0];
            Log.e("$", "Error " + e.status + ": " + e.error);
        }
    })
);
Odpovězeno 16/08/2013 v 21:06
zdroj uživatelem

hlasů
2

Chcete-li zobrazit Shimmer rozvržení jako Facebook je oficiální facebok knihovna za to. FaceBook Shimmer Android

To se stará o všechno, jen musíte dát požadovanou konstrukční kód vnořené způsobem leskem rámu. Zde je ukázkový kód.

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

A tady je java kód pro něj.

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

Přidat tuto závislost v gradle souboru.

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

Zde je, jak to vypadá.screenshot Shimmer Android

Odpovězeno 26/02/2018 v 05:02
zdroj uživatelem

hlasů
2

Dalším způsobem, jak to udělat, je prostřednictvím adaptéru ve vlákně v getView metoda ():

Thread pics_thread = new Thread(new Runnable() {
    @Override
    public void run() {
        Bitmap bitmap = getPicture(url);
        if(bitmap != null) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    holder.imageview.setImageBitmap(bitmap);            
                    adapter.notifyDataSetChanged();
                }                       
            });             
        }       
    }                       
});

pics_thread.start();

Samozřejmě, měli byste vždy mezipaměti své obrázky, aby se zabránilo další operace, byste mohli dát své obrázky do HashMap pole, zkontrolujte, zda existuje obraz v poli, ne-li, postupuje se závitem anebo nahrát obrázek z vás HashMap pole. Také zkontrolujte vždy, že nejste netěsní paměti, bitmapy a obrazovkami jsou často těžké na paměti. Je jen na vás, optimalizovat svůj kód.

Odpovězeno 21/06/2014 v 09:55
zdroj uživatelem

hlasů
1

Můžete použít některé knihovny třetích stran, jako Piccasonebo Volleypro efektivní líné načítání. Můžete si také vytvořit vlastní realizací níže

  1. Implementovat kód pro stažení obrázku z URL

  2. Implementovat mezipaměti mechanismus pro ukládání a načítání snímku (Use LruCacheof android pro ukládání do mezipaměti)

Odpovězeno 19/01/2016 v 09:59
zdroj uživatelem

hlasů
1

použijte níže třídy stáhnout a nahrát obrázky do listview.It ukládá každých snímků najednou stažení. Také načte obrazy reklamní líný zatížení.

package com.fudiyoxpress.images;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Handler;
import android.widget.ImageView;

import com.fudiyoxpress.R;
import com.fudiyoxpress.config.Config;
import com.fudiyoxpress.twitter.ScaleBitmap;

public class ImageLoader {

    // Initialize MemoryCache
    MemoryCache memoryCache = new MemoryCache();

    FileCache fileCache;

    Context C;

    // Create Map (collection) to store image and image url in key value pair
    private Map<ImageView, String> imageViews = Collections
            .synchronizedMap(new WeakHashMap<ImageView, String>());
    ExecutorService executorService;

    // handler to display images in UI thread
    Handler handler = new Handler();

    public ImageLoader(Context context) {

        C = context;
        fileCache = new FileCache(context);

        // Creates a thread pool that reuses a fixed number of
        // threads operating off a shared unbounded queue.
        executorService = Executors.newFixedThreadPool(5);

    }

    // default image show in list (Before online image download)
    final int stub_id = R.drawable.restlogoplaceholder;

    public void DisplayImage(String url, ImageView imageView, Context context,
            boolean header_flag) {

        Bitmap largeIcon = BitmapFactory.decodeResource(context.getResources(),
                R.drawable.restlogoplaceholder);
        header_flag = false;
        // Store image and url in Map
        imageViews.put(imageView, url);

        // Check image is stored in MemoryCache Map or not (see
        // MemoryCache.java)
        Bitmap bitmap = memoryCache.get(url);

        if (bitmap != null) {
            // if image is stored in MemoryCache Map then
            // Show image in listview row
            Bitmap b = ScaleBitmap
                    .getScaledBitmap(context, bitmap, header_flag);
            imageView.setImageBitmap(b);

        } else {
            // queue Photo to download from url
            queuePhoto(url, imageView, header_flag);

            // Before downloading image show default image
            imageView.setImageBitmap(ScaleBitmap.getScaledBitmap(context,
                    largeIcon, header_flag));

        }
    }



    private void queuePhoto(String url, ImageView imageView, boolean header_flag) {
        // Store image and url in PhotoToLoad object
        PhotoToLoad p = new PhotoToLoad(url, imageView, header_flag);

        // pass PhotoToLoad object to PhotosLoader runnable class
        // and submit PhotosLoader runnable to executers to run runnable
        // Submits a PhotosLoader runnable task for execution

        executorService.submit(new PhotosLoader(p));
    }

    // Task for the queue
    private class PhotoToLoad {
        public String url;
        public ImageView imageView;
        public boolean b;

        public PhotoToLoad(String u, ImageView i, boolean header_flag) {
            url = u;
            imageView = i;
            b = header_flag;
        }
    }

    class PhotosLoader implements Runnable {
        PhotoToLoad photoToLoad;

        PhotosLoader(PhotoToLoad photoToLoad) {
            this.photoToLoad = photoToLoad;
        }

        @Override
        public void run() {
            try {
                // Check if image already downloaded
                if (imageViewReused(photoToLoad))
                    return;
                // download image from web url
                Bitmap bmp = getBitmap(photoToLoad.url);

                // set image data in Memory Cache
                memoryCache.put(photoToLoad.url, bmp);

                if (imageViewReused(photoToLoad))
                    return;

                // Get bitmap to display
                BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);

                // Causes the Runnable bd (BitmapDisplayer) to be added to the
                // message queue.
                // The runnable will be run on the thread to which this handler
                // is attached.
                // BitmapDisplayer run method will call
                handler.post(bd);

            } catch (Throwable th) {
                // th.printStackTrace();
            }
        }
    }

    private Bitmap getBitmap(String url) {
        File f = fileCache.getFile(url);

        // from SD cache
        // CHECK : if trying to decode file which not exist in cache return null
        Bitmap b = decodeFile(f);
        if (b != null)
            return b;

        // Download image file from web
        try {

            // // download the image
            Bitmap bitmap = null;

            URL imageURL = null;
            try {

                imageURL = new URL(Config.WEB_URL + "/ServeBlob?id=" + url);

                HttpURLConnection connection = (HttpURLConnection) imageURL
                        .openConnection();
                connection.setDoInput(true);
                connection.connect();
                // if(!(new File(imageURL.toString())).exists())
                // {
                // imageURL=new URL("");
                // }
                InputStream inputStream = connection.getInputStream();

                // Constructs a new FileOutputStream that writes to
                // file
                // if file not exist then it will create file
                OutputStream os = new FileOutputStream(f);

                // See Utils class CopyStream method
                // It will each pixel from input stream and
                // write pixels to output stream (file)
                Utils.CopyStream(inputStream, os);

                os.close();

                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inSampleSize = 8;

                bitmap = BitmapFactory.decodeStream(inputStream, null, options);

            } catch (IOException e) {

                // e.printStackTrace();
            }

            // Now file created and going to resize file with defined height
            // Decodes image and scales it to reduce memory consumption
            bitmap = decodeFile(f);

            return bitmap;

        } catch (Throwable ex) {
            ex.printStackTrace();
            if (ex instanceof OutOfMemoryError)
                memoryCache.clear();
            return null;
        }
    }

    // Decodes image and scales it to reduce memory consumption
    private Bitmap decodeFile(File f) {

        try {

            // Decode image size
            BitmapFactory.Options o = new BitmapFactory.Options();
            o.inJustDecodeBounds = true;
            FileInputStream stream1 = new FileInputStream(f);
            BitmapFactory.decodeStream(stream1, null, o);
            stream1.close();

            // Find the correct scale value. It should be the power of 2.

            // Set width/height of recreated image
            final int REQUIRED_SIZE = 85;

            int width_tmp = o.outWidth, height_tmp = o.outHeight;
            int scale = 1;
            while (true) {
                if (width_tmp / 2 < REQUIRED_SIZE
                        || height_tmp / 2 < REQUIRED_SIZE)
                    break;
                width_tmp /= 2;
                height_tmp /= 2;
                scale *= 2;
            }

            // decode with current scale values
            BitmapFactory.Options o2 = new BitmapFactory.Options();
            o2.inSampleSize = scale;
            FileInputStream stream2 = new FileInputStream(f);
            Bitmap bitmap = BitmapFactory.decodeStream(stream2, null, o2);
            stream2.close();
            return bitmap;

        } catch (FileNotFoundException e) {
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    boolean imageViewReused(PhotoToLoad photoToLoad) {

        String tag = imageViews.get(photoToLoad.imageView);
        // Check url is already exist in imageViews MAP
        if (tag == null || !tag.equals(photoToLoad.url))
            return true;
        return false;
    }

    // Used to display bitmap in the UI thread
    class BitmapDisplayer implements Runnable {
        Bitmap bitmap;
        PhotoToLoad photoToLoad;

        public BitmapDisplayer(Bitmap b, PhotoToLoad p) {
            bitmap = b;
            photoToLoad = p;
        }

        public void run() {
            if (imageViewReused(photoToLoad))
                return;

            // Show bitmap on UI
            if (bitmap != null) {
                photoToLoad.imageView.setImageBitmap(ScaleBitmap
                        .getScaledBitmap(C, bitmap, photoToLoad.b));
            } else {

            }
            // photoToLoad.imageView.setImageResource(stub_id);

        }
    }

    public void clearCache() {
        // Clear cache directory downloaded images and stored data in maps
        memoryCache.clear();
        fileCache.clear();
    }

}




package com.fudiyoxpress.images;

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import android.graphics.Bitmap;
import android.util.Log;

public class MemoryCache {

    private static final String TAG = "MemoryCache";

    //Last argument true for LRU ordering
    private Map<String, Bitmap> cache = Collections.synchronizedMap(
            new LinkedHashMap<String, Bitmap>(10,1.5f,true));

   //current allocated size
    private long size=0; 

    //max memory cache folder used to download images in bytes
    private long limit = 1000000; 

    public MemoryCache(){

        //use 25% of available heap size
        setLimit(Runtime.getRuntime().maxMemory()/4);
    }

    public void setLimit(long new_limit){

        limit=new_limit;
        Log.i(TAG, "MemoryCache will use up to "+limit/1024./1024.+"MB");
    }

    public Bitmap get(String id){
        try{
            if(!cache.containsKey(id))
                return null;
            //NullPointerException sometimes happen here http://code.google.com/p/osmdroid/issues/detail?id=78 
            return cache.get(id);
        }catch(NullPointerException ex){
            ex.printStackTrace();
            return null;
        }
    }

    public void put(String id, Bitmap bitmap){
        try{
            if(cache.containsKey(id))
                size-=getSizeInBytes(cache.get(id));
            cache.put(id, bitmap);
            size+=getSizeInBytes(bitmap);
            checkSize();
        }catch(Throwable th){
            th.printStackTrace();
        }
    }

    private void checkSize() {
        Log.i(TAG, "cache size="+size+" length="+cache.size());
        if(size>limit){
            Iterator<Entry<String, Bitmap>> iter=cache.entrySet().iterator();//least recently accessed item will be the first one iterated  
            while(iter.hasNext()){
                Entry<String, Bitmap> entry=iter.next();
                size-=getSizeInBytes(entry.getValue());
                iter.remove();
                if(size<=limit)
                    break;
            }
            Log.i(TAG, "Clean cache. New size "+cache.size());
        }
    }

    public void clear() {
        try{
            //NullPointerException sometimes happen here http://code.google.com/p/osmdroid/issues/detail?id=78 
            cache.clear();
            size=0;
        }catch(NullPointerException ex){
            ex.printStackTrace();
        }
    }

    long getSizeInBytes(Bitmap bitmap) {
        if(bitmap==null)
            return 0;
        return bitmap.getRowBytes() * bitmap.getHeight();
    }
}




package com.fudiyoxpress.images;

import java.io.InputStream;
import java.io.OutputStream;

public class Utils {
    public static void CopyStream(InputStream is, OutputStream os)
    {
        final int buffer_size=1024;
        try
        {

            byte[] bytes=new byte[buffer_size];
            for(;;)
            {
              //Read byte from input stream

              int count=is.read(bytes, 0, buffer_size);
              if(count==-1)
                  break;

              //Write byte from output stream
              os.write(bytes, 0, count);
            }
        }
        catch(Exception ex){}
    }
}
Odpovězeno 03/12/2015 v 09:01
zdroj uživatelem

hlasů
1

Našel jsem Glide jako lepší variantu než Picasso. Byl jsem pomocí Picasso nahrát kolem 32představy o velikosti kolem 200-500KBsebe a já jsem byl vždy dostat OOM. Ale Glidevyřešil své všechny OOMproblémy.

Odpovězeno 03/12/2015 v 06:46
zdroj uživatelem

hlasů
0

Můžete použít GreenDroid je AsyncImageView. Stačí zavolat setUrl a myslím, že by to mohlo pomoci udělat věc, kterou Wnt dělat a viz odkaz níže uvedených:

link pro greenDroid je asyncimageview

Odpovězeno 06/04/2019 v 08:25
zdroj uživatelem

hlasů
-1

Kromě načtení cache dat asynchronně, může požadovat, aby mezipaměť UI

S výjimkou údajů o naložení viditelné položky bude pravděpodobně vyžadovat načtení dat položce approximity viditelné

Příklad: Předpokládejme, že viditelné položky ListView je [6,7,8,9,10], může se požadovat, aby zatížení [6,7,8,9,10] a pre-zatížení na položku [1, 2, 3, 4 , 5] a [11, 12, 13, 14, 15], protože uživatel pravděpodobně přejděte na pre-stránky nebo po stránce

Odpovězeno 14/06/2016 v 15:49
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more