Code Quality Rank: L2
Programming language: Java
Tags: Network     Image Loading    
Latest version: v2.0.0

ion alternatives and similar packages

Based on the "Image Loading" category

Do you think we are missing an alternative of ion or a related project?

Add another 'Image Loading' Package


Android Asynchronous Networking and Image Loading





The included documented ion-sample project includes some samples that demo common Android network operations:

  • Twitter Client Sample
    • Download JSON from a server (twitter feed)
    • Populate a ListView Adapter and fetch more data as you scroll to the end
    • Put images from a URLs into ImageViews (twitter profile pictures)
  • File Download with Progress Bar Sample
  • Get JSON and show images with the Image Search Sample

More Examples

Looking for more? Check out the examples below that demonstrate some other common scenarios. You can also take a look at 30+ ion unit tests in the ion-test.


.setCallback(new FutureCallback<JsonObject>() {
    public void onCompleted(Exception e, JsonObject result) {
        // do stuff with the result or error

Post JSON and read JSON

JsonObject json = new JsonObject();
json.addProperty("foo", "bar");

.setCallback(new FutureCallback<JsonObject>() {
    public void onCompleted(Exception e, JsonObject result) {
        // do stuff with the result or error

Post application/x-www-form-urlencoded and read a String

.setBodyParameter("goop", "noop")
.setBodyParameter("foo", "bar")

Post multipart/form-data and read JSON with an upload progress bar

.setMultipartParameter("goop", "noop")
.setMultipartFile("archive", "application/zip", new File("/sdcard/filename.zip"))

Download a File with a progress bar

// have a ProgressBar get updated automatically with the percent
// and a ProgressDialog
// can also use a custom callback
.progress(new ProgressCallback() {@Override
   public void onProgress(long downloaded, long total) {
       System.out.println("" + downloaded + " / " + total);
.write(new File("/sdcard/really-big-file.zip"))
.setCallback(new FutureCallback<File>() {
    public void onCompleted(Exception e, File file) {
        // download done...
        // do stuff with the File or error

Setting Headers

// set the header
.setHeader("foo", "bar")

Load an image into an ImageView

// This is the "long" way to do build an ImageView request... it allows you to set headers, etc.

// but for brevity, use the ImageView specific builder...

The Ion Image load API has the following features:

  • Disk and memory caching
  • Bitmaps are held via weak references so memory is managed very efficiently
  • ListView Adapter recycling support
  • Bitmap transformations via the .transform(Transform)
  • Animate loading and loaded ImageView states
  • DeepZoom for extremely large images


All operations return a custom Future that allows you to specify a callback that runs on completion.

public interface Future<T> extends Cancellable, java.util.concurrent.Future<T> {
     * Set a callback to be invoked when this Future completes.
     * @param callback
     * @return
    public Future<T> setCallback(FutureCallback<T> callback);

Future<String> string = Ion.with(context)

Future<JsonObject> json = Ion.with(context)

Future<File> file = Ion.with(context)
.write(new File("/sdcard/file.zip"));

Future<Bitmap> bitmap = Ion.with(context)

Cancelling Requests

Futures can be cancelled by calling .cancel():


Blocking on Requests

Though you should try to use callbacks for handling requests whenever possible, blocking on requests is possible too. All Futures have a Future.get() method that waits for the result of the request, by blocking if necessary.

JsonObject json = Ion.with(context)

Seamlessly use your own Java classes with Gson

public static class Tweet {
    public String id;
    public String text;
    public String photo;

public void getTweets() throws Exception {
    .as(new TypeToken<List<Tweet>>(){})
    .setCallback(new FutureCallback<List<Tweet>>() {
        public void onCompleted(Exception e, List<Tweet> tweets) {
          // chirp chirp


Wondering why your app is slow? Ion lets you do both global and request level logging.

To enable it globally:

Ion.getDefault(getContext()).configure().setLogging("MyLogs", Log.DEBUG);

Or to enable it on just a single request:

.setLogging("MyLogs", Log.DEBUG)

Log entries will look like this:

D/MyLogs(23153): (0 ms) http://example.com/thing.json: Executing request.
D/MyLogs(23153): (106 ms) http://example.com/thing.json: Connecting socket
D/MyLogs(23153): (2985 ms) http://example.com/thing.json: Response is not cacheable
D/MyLogs(23153): (3003 ms) http://example.com/thing.json: Connection successful

Request Groups

By default, Ion automatically places all requests into a group with all the other requests created by that Activity or Service. Using the cancelAll(Activity) call, all requests still pending can be easily cancelled:

Future<JsonObject> json1 = Ion.with(activity, "http://example.com/test.json").asJsonObject();
Future<JsonObject> json2 = Ion.with(activity, "http://example.com/test2.json").asJsonObject();

// later... in activity.onStop
protected void onStop() {

Ion also lets you tag your requests into groups to allow for easy cancellation of requests in that group later:

Object jsonGroup = new Object();
Object imageGroup = new Object();

Future<JsonObject> json1 = Ion.with(activity)
// tag in a custom group

Future<JsonObject> json2 = Ion.with(activity)
// use the same custom group as the other json request

Future<Bitmap> image1 = Ion.with(activity)
// for this image request, use a different group for images

Future<Bitmap> image2 = Ion.with(activity)
// same imageGroup as before

// later... to cancel only image downloads:

Proxy Servers (like Charles Proxy)

Proxy server settings can be enabled all Ion requests, or on a per request basis:

// proxy all requests
Ion.getDefault(context).configure().proxy("mycomputer", 8888);

// or... to proxy specific requests
.proxy("mycomputer", 8888)

Using Charles Proxy on your desktop computer in conjunction with request proxying will prove invaluable for debugging!


Viewing Received Headers

Ion operations return a ResponseFuture, which grant access to response properties via the Response object. The Response object contains the headers, as well as the result:

.setCallback(new FutureCallback<Response<String>>() {
    public void onCompleted(Exception e, Response<String> result) {
        // print the response code, ie, 200
        // print the String that was downloaded

Get Ion

   <version>(insert latest version)</version>
dependencies {
    compile 'com.koushikdutta.ion:ion:(insert latest version)'
Local Checkout (with AndroidAsync dependency)
git clone git://github.com/koush/AndroidAsync.git
git clone git://github.com/koush/ion.git
cd ion/ion
ant -Dsdk.dir=$ANDROID_HOME release install

Jars are at

  • ion/ion/bin/classes.jar
  • AndroidAsync/AndroidAsync/bin/classes.jar

Hack in Eclipse

git clone git://github.com/koush/AndroidAsync.git
git clone git://github.com/koush/ion.git
  • Import the project from AndroidAsync/AndroidAsync into your workspace
  • Import all the ion projects (ion/ion, ion/ion-sample) into your workspace.

Projects using ion

There's hundreds of apps using ion. Feel free to contact me or submit a pull request to add yours to this list.