Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.webimageloader.loader;
  
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
 
 
 
 public class PendingRequests {
     private static final String TAG = "PendingRequests";
 
     private MemoryCache memoryCache;
 
     // Don't remove tags at all, this means both of these should be weakhashmaps
     //
     private Map<ObjectPendingListenerspendingTags;
 
     public PendingRequests(MemoryCache memoryCache) {
         this. = memoryCache;
 
         // Use WeakHashMap to ensure tags can be GC'd
          = new WeakHashMap<ObjectPendingListeners>();
          = new HashMap<LoaderRequestPendingListeners>();
     }
 
     public synchronized Bitmap getBitmap(Object tagLoaderRequest request) {
         if ( != null) {
             MemoryCache.Entry entry = .get(request);
             if (entry != null) {
                 // We got this bitmap, cancel old pending work
                 cancelPotentialWork(tag);
                 return entry.bitmap;
             }
         }
 
         return null;
     }
 
     public synchronized LoaderWork addRequest(Object tagfinal LoaderRequest requestLoaderManager.Listener listener) {
         if (tag != null && stillPending(tagrequest)) {
             return null;
         }
 
         if (tag != null) {
             cancelPotentialWork(tag);
         }
 
         PendingListeners listeners = .get(request);
         LoaderWork work = null;
 
         if (listeners == null) {
             work = new LoaderWork(new RequestListener(request), new ImageLoader.ProgressListener() {
                 @Override
                 public void onProgress(float value) {
                     publishProgress(requestvalue);
                 }
             });
 
             listeners = new PendingListeners(requesttaglistenerwork);
             .put(requestlisteners);
         } else {
             if (.) Log.v("Reusing request: " + request);
             listeners.add(taglistener);
         }
 
         if (tag != null) {
             .put(taglisteners);
         }
 
         return work;
     }
 
     public synchronized void cancel(Object tag) {
         cancelPotentialWork(tag);
     }
 
     protected synchronized void publishProgress(LoaderRequest requestfloat value) {
         PendingListeners listeners = .get(request);
         if (listeners != null) {
             listeners.publishProgress(value);
         }
     }
 
     protected synchronized void deliverResult(LoaderRequest requestBitmap bMetadata metadata) {
         PendingListeners listeners = removeRequest(request);
         if (listeners != null) {
             saveToMemoryCache(requestbmetadata);
            listeners.deliverResult(b);
        }
    }
    protected synchronized void deliverError(LoaderRequest requestThrowable t) {
        PendingListeners listeners = removeRequest(request);
        if (listeners != null) {
            listeners.deliverError(t);
        }
    }
    private PendingListeners removeRequest(LoaderRequest request) {
        PendingListeners listeners = .remove(request);
        if (listeners == null) {
            if (.) Log.v("Request no longer pending: " + request);
        } else {
            .keySet().removeAll(listeners.getTags());
        }
        return listeners;
    }
    private void cancelPotentialWork(Object tag) {
        PendingListeners listeners = .remove(tag);
        if (listeners == null) {
            return;
        }
        listeners.remove(tag);
        if (listeners.isEmpty()) {
            LoaderRequest request = listeners.getRequest();
            .remove(request);
            listeners.cancel();
        }
    }
    private void saveToMemoryCache(LoaderRequest requestBitmap bMetadata metadata) {
        if ( != null) {
            .put(requestbmetadata);
        }
    }
    private boolean stillPending(Object tagLoaderRequest request) {
        PendingListeners listeners = .get(tag);
        return listeners != null && request.equals(listeners.getRequest());
     }
    private class RequestListener implements Loader.Listener {
        private LoaderRequest request;
        public RequestListener(LoaderRequest request) {
            this. = request;
        }
        @Override
        public void onStreamLoaded(InputSupplier inputMetadata metadata) {
            try {
                InputStream is = input.getInput();
                
                try {
                    Bitmap b = BitmapUtils.decodeStream(is);
                    
                    onBitmapLoaded(bmetadata);
                } finally {
                    is.close();
                }
            } catch (IOException e) {
                onError(e);
            }
        }
        @Override
        public void onBitmapLoaded(Bitmap bMetadata metadata) {
            deliverResult(bmetadata);
        }
        @Override
        public void onNotModified(Metadata metadata) {
            // Nothing changed, we don't need to notify any listeners
            .updateMetadata(metadata);
        }
        @Override
        public void onError(Throwable t) {
            deliverError(t);
        }
    }
    private static class PendingListeners {
        private LoaderRequest request;
        private Map<ObjectLoaderManager.Listenerlisteners;
        private List<LoaderManager.ListenerextraListeners;
        private LoaderWork work;
        public PendingListeners(LoaderRequest requestObject tagLoaderManager.Listener listenerLoaderWork work) {
            this. = request;
            this. = work;
            // Use a WeakHashMap to ensure tags can be GC'd, also use 1 a initial
            // capacity as we expect a low number of listeners per request
             = new WeakHashMap<ObjectLoaderManager.Listener>(1);
             = new ArrayList<LoaderManager.Listener>(1);
            add(taglistener);
        }
        public void add(Object tagLoaderManager.Listener listener) {
            if (tag == null) {
                .add(listener);
            } else {
                .put(taglistener);
            }
        }
        public void remove(Object tag) {
            .remove(tag);
        }
        public boolean isEmpty() {
            return .isEmpty() && .isEmpty();
        }
        public void cancel() {
            .cancel();
        }
        public LoaderRequest getRequest() {
            return ;
        }
        public Set<ObjectgetTags() {
            return .keySet();
        }
        public void publishProgress(float value) {
            for (LoaderManager.Listener listener : .values()) {
                listener.onProgress(value);
            }
            for (LoaderManager.Listener listener : ) {
                listener.onProgress(value);
            }
        }
        public void deliverResult(Bitmap b) {
            for (LoaderManager.Listener listener : .values()) {
                listener.onLoaded(b);
            }
            for (LoaderManager.Listener listener : ) {
                listener.onLoaded(b);
            }
        }
        public void deliverError(Throwable t) {
            for (LoaderManager.Listener listener : .values()) {
                listener.onError(t);
            }
            for (LoaderManager.Listener listener : ) {
                listener.onError(t);
            }
        }
    }
New to GrepCode? Check out our FAQ X