Code Quality Rank: L2
Programming language: Java
License: GNU General Public License v3.0 or later
Tags: Network     Image Loading    
Latest version: v2.0.0

ion alternatives and similar packages

Based on the "Image Loading" category.
Alternatively, view ion alternatives based on common mentions on social networks and blogs.

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.