This library requires Android API level 8 (Android 2.2) as minimum, and targets the Android API level 17.

You need to include in your destination project:

ImageViewEx is an extended ImageView that supports some additional methods for your every-day life.

The best thing about ImageViewEx is its automatic handling of animated GIF images starting from a simple byte[].

As mentioned earlier, you may not want to animate some GIF under some conditions.

So we've provided you with a conditional method that gets triggered just before each animation begins, boolean canAnimate(). This method should be overridden by your custom implementation. By default, it always returns true. This method decides whether animations can be started for this instance of ImageViewEx.

If you don't want to have another class extending ImageViewEx and your canAnimate() returns the same value throughout your application, you can use the following

	ImageViewNext.setCanAlwaysAnimate(false);

to specify you never want to animate GIFs. If you don't set any value to setCanAlwaysAnimate, it defaults to true. The result you get by setting the value to false is that it will stop all animations, no matter what canAnimate() returns.

You can check the current behavior by calling the static boolean getCanAlwaysAnimate() method.

You can set a specific density to simulate for every instance of ImageViewEx by using the following methods:

• static void setClassLevelDensity(int classLevelDensity) to set a specific density for every image
• static void removeClassLevelDensity() to remove the class-level customization
• static boolean isClassLevelDensitySet(), checks if a class-level density has been set
• static int getClassLevelDensity(), gets the set class-level density, or null if none has been set

You can even set a density for just one of your ImageViewExs:

• void setDensity(int fixedDensity), to set the density for a particular instance of ImageViewEx
• int getDensity(), gets the set density for a particular instance of ImageViewEx (an instance-level density has higher priority over a class-level density)
• void dontOverrideDensity(), restores the regular density of the ImageViewEx

ImageViewEx is, after all, a regular ImageView, so you can go ahead and use its regular methods:

• void setImageResource(int resId)
• void setImageDrawable(Drawable drawable)
• void setImageBitmap(Bitmap bm)
• and so on.

ImageViewExService is used by ImageViewNext, an extension of ImageViewEx that handles downloading, displaying and caching of images (and animated GIFs, of course).

ImageViewNext extends ImageViewEx, thus supporting all of its methods, plus some more.

ImageViewNext uses ImageViewExService and some DataDroid Operations to retrieve images from a two-level cache and the internet and set them into your ImageViewNext.

ImageViewNext takes care of instantiating the cache to some default values, which can be overridden/read by using the following static methods (pretty self-explanatory, read the JavaDoc for more information about them):

• getMemCache()
• getDiskCache()
• getMemCacheSize()
• setMemCacheSize(int memCacheSize)
• getAppVersion()
• setAppVersion(int appVersion)
• getDiskCacheSize()
• setDiskCacheSize(int diskCacheSize)

ImageViewNext supports loading and error Drawables:

• static void setClassLoadingDrawable(int classLoadingDrawableResId) sets a Drawable for every instance of ImageViewNext from the resources to be displayed (and animated, if it's an AnimatedDrawable) as soon as the caching tells us there's no in-memory reference for the asked resource. If you have enabled a disk cache, this Drawable will be set before fetching the disk memory.
• void setLoadingDrawable(Drawable loadingDrawable) sets a Drawable for the current instance of ImageViewNext from the resources to be displayed (and animated, if it's an AnimatedDrawable) as soon as the caching tells us there's no in-memory reference for the asked resource. If you have enabled a disk cache, this Drawable will be set before fetching the disk memory.
• static void setClassErrorDrawable(int classErrorDrawableResId) sets a Drawable for every instance of ImageViewNext from the resources to be displayed (and animated, if it's an AnimatedDrawable) as soon as the RemoteLoader returns an error, not being able to retrieve the image.
• void setErrorDrawable(Drawable errorDrawable) sets a Drawable for the current instance of of ImageViewNext from the resources to be displayed (and animated, if it's an AnimatedDrawable) as soon as the RemoteLoader returns an error, not being able to retrieve the image.
• Drawable getLoadingDrawable() returns the Drawable to be displayed while waiting for long-running operations.
• Drawable getErrorDrawable() returns the Drawable to be displayed in case of an error.

In order to get images from the Internet, simply call setUrl(String url) to start retrieving an image from the internet or the caches.

ImageViewNext can be overridden in order to do some custom operations in the following methods:

• void onMemCacheHit(byte[] image) is called as soon as there's a memory cache hit for the requested URL
• void onMemCacheMiss() is called as soon as there's a memory cache miss for the requested URL
• void onDiskCacheHit(byte[] image) is called as soon as there's a disk cache hit for the requested URL
• void onDiskCacheMiss() is called as soon as there's a disk cache miss for the requested URL
• void onNetworkHit(byte[] image) is called as soon as there's a network hit for the requested URL
• void onNetworkMiss() is called as soon as there's a network miss for the requested URL
• void onMiss() is called when an error occurs or the resource can't be found anywhere
• void onSuccess(byte[] image) is automatically called after the image has been retrieved

You should not worry about setting images, as this is handled by ImageViewNext itself , which by defaults sets the loading image when there's a memory miss (on onMemCacheMiss()), an error one in case of error (onMiss()) and the retrieved image in case of success (onSuccess(byte[] image)).

If you override ImageViewNext, always call the default implementation of these methods.

By default, starting from version 2.2.0, each ImageViewNext will listen to network availability changes and automatically retry and get the image from the Internet, if and only if the same instance failed to do so in the previous attempt.

If you want to override the default behavior you can use:

• setClassAutoRetryFromNetwork(boolean classAutoRetryFromNetwork) to set a class-level behavior
• setAutoRetryFromNetwork(boolean autoRetryFromNetwork) to set an instance-specific behavior

To know what the current settings are in regards to auto retry, use:

• isClassAutoRetryFromNetwork() to get the class-level setting
• isAutoRetryFromNetwork() to retrieve the instance-specific setting

Remember: the instance-specific setting has an higher priority than the class-level setting.

You can set the maximum number of concurrent threads; threads are used to retrieve an image, given its URL, from the memory cache, the disk cache or the network.

Use ImageViewNext.setMaximumNumberOfThreads(THREAD_NUMBER) BEFORE any ImageViewNext object is instantiated (ideally, in your Application class), as calling this function again after an ImageViewNext has been instantiated will have no effect.

You can retrieve the maximum number of concurrent threads with ImageViewNext.getMaximumNumberOfThreads().

ImageViewExinternally uses an old Android Framework class, Movie, to parse animated GIFs. This ensures fast execution, since the Movie class internally relies on native code. Due to Movie being a legacy class, though, there are a few quirks.

Firstly, you can't have Movie working on an hardware-accelerated canvas in Honeycomb and newer versions of Android. The ImageViewEx thus automatically disables hardware acceleration by itself when it has to display a GIF image. One side effect is that hardware acceleration is "lost" forever on the View once turned off, so if you reuse the ImageViewEx and at some point you assign a GIF image to it, from that point onwards it won't be hardware accelerated anymore. That's a limitation Android itself imposes, so there's not much we can do about that. On the bright side, this only affects cases where hardware acceleration is available; even when software rendering is active, there's not a big performance hit thou.

The second issue is that Movie has serious issues on some emulator instances and some retail devices. This is most likely due to some broken code down at native (maybe in Skia) or video driver level. So not much we can do on this one either. On the bright side, we've provided a workaround, that is setting setCanAlwaysAnimate(false) on phones known to cause issues. You will lose animation support, but you don't need to get crazy trying to handle several layouts, some using ImageViews and some using ImageViewExes.

If you use this library, letting us know would make us proud. We do not ask for anything else.