Android Open Source - webimageloader Loader Manager

From Project

Back to project page webimageloader.

License

The source code is released under:

Apache License

If you think the Android project webimageloader listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.

Java Source Code

package com.webimageloader.loader;
//from  www  .j  av  a 2s  . co m
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import com.webimageloader.transformation.Transformation;

import android.graphics.Bitmap;

public class LoaderManager {
    private static final LoaderManager.Listener EMPTY_LISTENER = new LoaderManager.Listener() {
        @Override
        public void onLoaded(Bitmap b) {}

        @Override
        public void onError(Throwable t) {}

        @Override
        public void onProgress(float value) {}
    };
    
    private MemoryCache memoryCache;

    private DiskLoader diskLoader;
    private TransformingLoader transformingLoader;
    private MemoryLoader memoryLoader;

    private List<Loader> standardChain;
    private List<Loader> transformationChain;

    private PendingRequests pendingRequests;

    public interface Listener {
        void onLoaded(Bitmap b);
        void onError(Throwable t);
        void onProgress(float value);
    }

    public LoaderManager(MemoryCache memoryCache, DiskLoader diskLoader, NetworkLoader networkLoader) {
        this.memoryCache = memoryCache;
        this.diskLoader = diskLoader;

        transformingLoader = new TransformingLoader();
        if (memoryCache != null) {
            memoryLoader = new MemoryLoader(memoryCache);
        }

        // Create standard chain
        standardChain = new ArrayList<Loader>();
        add(standardChain, diskLoader);
        add(standardChain, networkLoader);

        // Create transformation chain
        transformationChain = new ArrayList<Loader>();
        add(transformationChain, diskLoader);
        add(transformationChain, transformingLoader);
        add(transformationChain, memoryLoader);
        add(transformationChain, diskLoader);
        add(transformationChain, networkLoader);

        // Ensure the chains are not modified and is safe to iterate
        // over in multiple threads
        standardChain = Collections.unmodifiableList(standardChain);
        transformationChain = Collections.unmodifiableList(transformationChain);

        pendingRequests = new PendingRequests(memoryCache);
    }

    public MemoryCache getMemoryCache() {
        return memoryCache;
    }

    public Bitmap load(Object tag, LoaderRequest request, Listener listener) {
        Bitmap b = pendingRequests.getBitmap(tag, request);
        if (b != null) {
            return b;
        }

        // Send an empty listener instead of null
        if (listener == null) {
            listener = EMPTY_LISTENER;
        }

        LoaderWork work = pendingRequests.addRequest(tag, request, listener);

        // A request is already pending, don't load anything
        if (work == null) {
            return null;
        }

        // Use different chains depending if we have a transformation or not
        Transformation t = request.getTransformation();
        List<Loader> chain = t == null ? standardChain : transformationChain;

        work.start(chain, request);

        return null;
    }

    public void cancel(Object tag) {
        pendingRequests.cancel(tag);
    }

    public void close() {
        if (diskLoader != null) {
            diskLoader.close();
        }
    }

    private static <T> void add(List<T> list, T item) {
        if (item != null) {
            list.add(item);
        }
    }
}

Java Source Code List