Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.koushikdutta.ion;
  
  import  android.content.Context;
  import  android.util.Log;
  import  android.widget.ImageView;
  import  com.koushikdutta.async.AsyncServer;
  import  com.koushikdutta.async.future.Future;
  import  com.koushikdutta.async.http.AsyncHttpClient;
  import  com.koushikdutta.async.http.ResponseCacheMiddleware;
 
 import java.io.File;
 import java.util.List;
Created by koush on 5/21/13.
 
 public class Ion {
    
Get the default Ion object instance and being building a request

Parameters:
context
Returns:
 
     public static IonLoadRequestBuilder with(Context context) {
         return getDefault(context).build(context);
     }

    
Get the default Ion instance

Parameters:
context
Returns:
 
     public static Ion getDefault(Context context) {
         if ( == null)
              = new Ion(context);
         return ;
     }

    
Create a ImageView bitmap request builder

Parameters:
imageView
Returns:
 
     public static IonMutableBitmapRequestPostLoadBuilder with(ImageView imageView) {
         Ion ion = getDefault(imageView.getContext());
         return new IonRequestBuilder(imageView.getContext(), ion).withImageView(imageView);
     }

    
Create a builder that can be used to build an network request

Parameters:
context
Returns:
 
     public IonLoadRequestBuilder build(Context context) {
         return new IonRequestBuilder(contextthis);
     }

    
Create a builder that can be used to build an network request

Parameters:
imageView
Returns:
 
     public IonMutableBitmapRequestPostLoadBuilder build(ImageView imageView) {
         return new IonRequestBuilder(imageView.getContext(), this).withImageView(imageView);
     }

    
Cancel all pending requests associated with the request group

Parameters:
group
 
     public void cancelAll(Object group) {
         FutureSet members;
         synchronized (this) {
             members = .remove(group);
         }
 
         if (members == null)
             return;
 
         for (Future futuremembers.keySet()) {
             if (future != null)
                 future.cancel();
         }
     }
 
     void addFutureInFlight(Future futureObject group) {
         if (group == null || future == null || future.isDone() || future.isCancelled())
             return;
 
         FutureSet members;
         synchronized (this) {
             members = .get(group);
            if (members == null) {
                members = new FutureSet();
                .put(groupmembers);
            }
        }
        members.put(futuretrue);
    }

    
Cancel all pending requests
    public void cancelAll() {
        ArrayList<Objectgroups;
        synchronized (this) {
            groups = new ArrayList<Object>(.keySet());
        }
        for (Object groupgroups)
            cancelAll(group);
    }

    
Cancel all pending requests associated with the given context

Parameters:
context
    public void cancelAll(Context context) {
        cancelAll((Object)context);
    }
    public int getPendingRequestCount(Object group) {
        synchronized (this) {
            FutureSet members = .get(group);
            if (members == null)
                return 0;
            int ret = 0;
            for (Future futuremembers.keySet()) {
                if (!future.isCancelled() && !future.isDone())
                    ret++;
            }
            return ret;
        }
    }
    public void dump() {
        Log.i("Groups: " + .size());
        for (FutureSet futures.values()) {
            Log.i("Group size: " + futures.size());
            for (Future futurefutures.keySet()) {
                Log.i("" + (future.isDone() || future.isCancelled()));
            }
        }
        .getServer().dump();
    }
    static class FutureSet extends WeakHashMap<Future, Boolean> {
    }

    
Get the application Context object in use by this Ion instance

Returns:
    public Context getContext() {
        return ;
    }

    
Return the bitmap cache used by this Ion instance

Returns:
    public IonBitmapCache getBitmapCache() {
        return ;
    }
    // maintain a list of futures that are in being processed, allow for bulk cancellation
    ResponseCacheMiddleware responseCache;
    AsyncHttpClient httpClient;
    Context context;
    private Ion(Context context) {
         = new AsyncHttpClient(new AsyncServer());
        this. = context = context.getApplicationContext();
        try {
             = ResponseCacheMiddleware.addCache(new File(context.getCacheDir(), "ion"), 10L * 1024L * 1024L);
        }
        catch (Exception e) {
            IonLog.w("unable to set up response cache"e);
        }
        .insertMiddleware( = new CookieMiddleware(context));
         = new IonBitmapCache(this);
        configure()
        .addLoader(new HttpLoader())
        .addLoader(new ContentLoader())
        .addLoader(new FileLoader());
    }
        return ;
    }
    public AsyncHttpClient getHttpClient() {
        return ;
    }
    public class Config {
        ArrayList<Loaderloaders = new ArrayList<Loader>();
        public Config addLoader(int indexLoader loader) {
            .add(indexloader);
            return this;
        }
        public Config insertLoader(Loader loader) {
            .add(0, loader);
            return this;
        }
        public Config addLoader(Loader loader) {
            .add(loader);
            return this;
        }
        public List<LoadergetLoaders() {
            return ;
        }
    }
    String LOGTAG;
    int logLevel;
    public void setLogging(String logtagint logLevel) {
         = logtag;
        this. = logLevel;
    }
    Config config = new Config();
    public Config configure() {
        return ;
    }
    // map an ImageView to the url being downloaded for it.
    // but don't hold references to the ImageView...
    WeakHashMap<ImageView, StringpendingViews = new WeakHashMap<ImageView, String>();
    // track the downloads and transforms that are pending.
    // but don't maintain a reference.
    // The reference stays alive because the reference chain looks as follows:
    // AsyncServer -> AsyncHttpClient -> IonRequestBuilder.execute future ->
    // bitmap decode future -> transform future -> drawable future ->
    // asBitmap/intoImageView future
    // Thus, the reference to the future will exist, so long as it is reachable
    // by a callback; ie, it was not cancelled.
    private static Ion instance;
New to GrepCode? Check out our FAQ X