Caching image in android

Loading and caching images in android with 1 annotation

Feb 3, 2020 · 3 min read

Images are one of the most (if not the most) cached items in any application. When it comes to android there are some great libraries like Glide and Picasso that help us cache images with ease. I have used both the libraries and love them both but I wanted to eliminate the same code that I have to write for caching images into ImageViews in multiple places and achieve all that using just annotations.

The Glide or Picasso way of caching images:-

If I have manage d to capture your attention with my insane claim that an annotation can load and cache images into an ImageView I have few more surprises about this annotation later on. 😃

How to use @LoadImage

• Add the ColdStorage library into your application following the instructions here .Make sure to use version > 4.0.0 to use the load image annotation.
• Create an activity whose layout contains at lease one ImageView. The annotation also works on fragments. For the purpose of this post, I will create an activity that will contain one ImageView and a Fragment which in turn will contain 2 ImageViews.

The layout of the Activity

The layout of the Fragment

• Now let us see how we can load data from a URL and display it inside the image views.

The code for the Activity

The code for the Fragment

Ok, now that the coding is complete let us see what is exactly happening here. The image views have been annotated with @LoadImage and we are passing the resource id and the URL into it with some additional parameters which we will look at later on. The resource id and the URL are the mandatory parameters for the annotation. If you notice, we are not actually initializing the image views with findViewById in our code because @LoadImage takes care of it for us. It will bind the view to the variable and download the image from the URL and load it onto the imageView.

The binding of the cache with the view takes place when we call Cache.bind(this). The bind method needs to be called only after the layout has been attached to the fragment (in onViewCreated method) or the activity (after setContentView).

Now, what if we want a placeholder image until the actual image is downloaded? No problem! Just pass the resource id of the placeholder drawable to the annotation.

Still not impressed? Ok how about I need to show a loading spinner and not a static placeholder? Again, just simply set a static image of a spinner as a drawable and set the enableLoadingAnimation value to true and you will get your spinner.

Источник

Top 10: Best Android Image Loading and Caching Libraries

Carlos Delgado

See our review from 10 of the Best Android Image Loading and Caching Libraries.

An application that doesn’t load images, is pretty weird and boring nowadays. Knowing how to display an image in your mobile application is one of the most common tasks for every developer. However, the way you work with them will be different for everyone, due to the way you code your app to handle the image. For example, website developers don’t need to take care of image caching because the browser does this automatically, but for an android developer, an image will be normally loaded again and again (if we are talking from a remote/web source) without really good performance. If you are willing to display efficiently images on your application, you need to take care of the image caching, specially when you work on a free application to organize photos.

In this top, we’ll share with you 10 of the most imponent image caching libraries to increase the performance and loading times of your Android Application.

10. Mirage

Mirage is an image loading library developed by the Android team at The Climate Corporation for loading, caching, and sync’ing for offline usage of images. Our main consideration for creating this system was to allow for explicit sync’ing of images for offline use. Libraries like Picasso didn’t fulfill our requirements because as stated «Picasso doesn’t have a disk cache. It delegates to whatever HTTP client».

9. Android Image Cache

An image download-and-cacher that also knows how to efficiently generate and retrieve thumbnails of various sizes. This library features:

• easily integrates into content-provider backed applications, providing an adapter that can read local and web URLs from a cursor
• automatic generation and caching of multiple sizes of images based on one downloaded asset
• provides a disk cache as well as a memory cache
• automatic disk cache management; no setup necessary, but parameters can be fine-tuned if desired
• designed to work with your existing setup: no extending a custom application or activity needed
• cursor adapter supports multiple image fields for each ImageView; skips fields that are null or empty
• cursor adapter has an automatic progress bar when loading the cursor

8. Shutterbug

Shutterbug is an Android library that lets you fetch remote images and cache them. It is particularly suited for displaying remote images in lists or grids as it includes a convenience subclass of ImageView ( FetchableImageView ) that make implementation a one-liner.

A dual memory and disk cache was implemented. It makes use of two backports of Android classes: LruCache for the memory part and DiskLruCache for the disk part. LruCache was introduced by API Level 12, but we provide it here as a standalone class so you can use the library under lower level APIs. Both LruCache and DiskLruCache are licensed under the Apache Software License, 2.0.

Shutterbug was inspired by SDWebImage which does the same thing on iOS. It uses the same structure and interface. People who are familiar with SDWebImage on iOS will feel at home with Shutterbug on Android.

7. Slight

Sligh is an easy, sample and flexible library for loading, caching and displaying images on Android written in Kotlin.

6. Ion

ION is an Android Asynchronous Networking and Image Loading library. This library features:

• Asynchronously download:
  • Images into ImageViews or Bitmaps (animated GIFs supported too)
  • JSON (via Gson)
  • Strings
  • Files
  • Java types using Gson
• Easy to use Fluent API designed for Android
  • Automatically cancels operations when the calling Activity finishes
  • Manages invocation back onto the UI thread
  • All operations return a Future and can be cancelled
• HTTP POST/PUT:
  • text/plain
  • application/json — both JsonObject and POJO
  • application/x-www-form-urlencoded
  • multipart/form-data
• Transparent usage of HTTP features and optimizations:
  • SPDY and HTTP/2
  • Caching
  • Gzip/Deflate Compression
  • Connection pooling/reuse via HTTP Connection: keep-alive
  • Uses the best/stablest connection from a server if it has multiple IP addresses
  • Cookies
• View received headers
• Grouping and cancellation of requests
• Download progress callbacks
• Supports file:/, http(s):/, and content:/ URIs
• Request level logging and profiling
• Support for proxy servers like Charles Proxy to do request analysis
• Based on NIO and AndroidAsync
• Ability to use self signed SSL certificates

5. Android Smart Image View

SmartImageView is a drop-in replacement for Android’s standard ImageView which additionally allows images to be loaded from URLs or the user’s contact address book. Images are cached to memory and to disk for super fast loading. This library features:

• Drop-in replacement for ImageView
• Load images from a URL
• Load images from the phone’s contact address book
• Asynchronous loading of images, loading happens outside the UI thread
• Images are cached to memory and to disk for super fast loading
• SmartImage class is easily extendable to load from other sources

4. Android Universal Image Loader

UIL is a powerful and flexible library for loading, caching and displaying images on Android. UIL aims to provide a powerful, flexible and highly customizable instrument for image loading, caching and displaying. It provides a lot of configuration options and good control over the image loading and caching process. This library features:

• Multithread image loading (async or sync)
• Wide customization of ImageLoader’s configuration (thread executors, downloader, decoder, memory and disk cache, display image options, etc.)
• Many customization options for every display image call (stub images, caching switch, decoding options, Bitmap processing and displaying, etc.)
• Image caching in memory and/or on disk (device’s file system or SD card)
• Listening loading process (including downloading progress)
• Android 2.0+ support.

3. Fresco by Facebook

An Android library for managing images and the memory they use. Fresco takes care of image loading and display, so you don’t have to. It will load images from the network, local storage, or local resources, and display a placeholder until the image has arrived. It has two levels of cache; one in memory and another in internal storage. In Android 4.x and lower, Fresco puts images in a special region of Android memory. This lets your application run faster — and suffer the dreaded OutOfMemoryError much less often. Fresco also supports:

• streaming of progressive JPEGs
• display of animated GIFs and WebPs
• extensive customization of image loading and display
• and much more!

2. Picasso

Picasso is a powerful image downloading and caching library for Android. Images add much-needed context and visual flair to Android applications. Picasso allows for hassle-free image loading in your application—often in one line of code! Many common pitfalls of image loading on Android are handled automatically by Picasso:

• Handling ImageView recycling and download cancelation in an adapter.
• Complex image transformations with minimal memory use.
• Automatic memory and disk caching.

Adapter re-use is automatically detected and the previous download canceled. If you would like to contribute code you can do so through GitHub by forking the repository and sending a pull request.

1. Glide

Glide is a fast and efficient open source media management and image loading framework for Android that wraps media decoding, memory and disk caching, and resource pooling into a simple and easy to use interface. Glide supports fetching, decoding, and displaying video stills, images, and animated GIFs. Glide includes a flexible API that allows developers to plug in to almost any network stack. By default Glide uses a custom HttpUrlConnection based stack, but also includes utility libraries plug in to Google’s Volley project or Square’s OkHttp library instead.

Glide’s primary focus is on making scrolling any kind of a list of images as smooth and fast as possible, but Glide is also effective for almost any case where you need to fetch, resize, and display a remote image. Glide takes in to account two key aspects of image loading performance on Android:

• The speed at which images can be decoded.
• The amount of jank incurred while decoding images.

For users to have a great experience with an app, images must not only appear quickly, but they must also do so without causing lots of jank and stuttering from main thread I/O or excessive garbage collections.

Glide takes a number of steps to ensure image loading is both as fast and as smooth as possible on Android:

• Smart and automatic downsampling and caching minimize storage overhead and decode times.
• Aggressive re-use of resources like byte arrays and Bitmaps minimizes expensive garbage collections and heap fragmentation.
• Deep lifecycle integration ensures that only requests for active Fragments and Activities are prioritized and that Applications release resources when neccessary to avoid being killed when backgrounded.

Honorable mentions

An image loading library for Android backed by Kotlin Coroutines. Coil is:

• Fast: Coil performs a number of optimizations including memory and disk caching, downsampling the image in memory, re-using Bitmaps, automatically pausing/cancelling requests, and more.
• Lightweight: Coil adds

1500 methods to your APK (for apps that already use OkHttp and Coroutines), which is comparable to Picasso and significantly less than Glide and Fresco.

Easy to use: Coil’s API leverages Kotlin’s language features for simplicity and minimal boilerplate.

Modern: Coil is Kotlin-first and uses modern libraries including Coroutines, OkHttp, Okio, and AndroidX Lifecycles.

Coil is an acronym for: Coroutine Image Loader.

If you know another awesome image caching library for Android, please share it with the community in the comment box.

Источник

Caching image in android

In this tutorial you can read about Glide. The advanced library for image uploading, caching, rotating and small memory usage.

Android SDK does not have a good way to get images from web and display it to android app. To solve this problem, numbers of third party libraries are available.

You can read some comparison here and here.

• supports thumbnail
• supports animations
• animated GIF decoding, you can load GIF animation into ImageView
• supports OkHttp and Volley library
• display video stills
• placeholder can be added before loading the original image
• any custom image can be shown if error occurs while loading the original image

Glide offers some additional advantages over other image loading libraries. For example, when loading an image, Glide will cache both a version of the image in its original size as well as one that’s the size of its intended ImageView . This means Glide loads the image noticeably faster than libraries like Picasso because no resize is necessary. Additionally, Glide works with Android’s ImageView (Facebook’s Fresco uses DraweeView and Volley uses NetworkImageView ).

Getting started with Glide is as easy as using Picasso. Their API also look quite similar.

Add the Gradle dependency to your android module build.gradle. Glide also needs android support library v4. Also I’m going to use CircleImageView for circle effect for image.

The way to load an image to ImageView with Glide is quite the same as Picasso.

Although it looks quite the same but in details Glide is designed far better since with doesn’t accept only Context but also Activity and Fragment . The brilliant benefit from passing Activity/Fragment to Glide is: image loading would be integrated with Activity/Fragment‘s lifecycle for example, pause loading in Paused state and automatically resume on Resumed state.

Most options in Glide can be applied using the RequestOptions class and the apply() method.

Use request options to apply (among others):

• Placeholders
• Transformations
• Caching Strategies
• Component specific options, like encode quality, or decode Bitmap configurations.

For example, to apply a CenterCrop transformation, you’d use the following:

Glide is very customizable. Starting with the 4.0 release Glide creates a custom fluent interface depending on your customization. Glide’s developers call this result generated API.

In order to create the generated API, which we’ll use in all upcoming tutorials, you’ll have to create a class extending AppGlideModule somewhere in your app project:

Don’t forget the @GlideModule ! Then, by default, the generated API is accessible via GlideApp . For example:

Loading image from res/drawable folder

Show placeholder image

You can load image to Bitmap via following snippet

Let’s build simple application that will demonstrates Glide usage

In MainActivity file define variable for ImageView and set image URL for load method of Glide. Following is the complete code of java activity file.

We can use transformations for crop, blur, color, mask.

Glide’s default bitmap format is set to RGB_565 so image quality will be poorer compared with Picasso. But the advantage is that it will consume less memory. If you are ok with image quality, don’t change the bitmap format else change it to ARGB_8888 as below.

Then, add meta-tag into AndroidManifest.xml

If you run the app, images will look better now.

Glide creates cached images per size while Picasso saves the full image and process it. If you are trying to load image (500×500) into ImageView (200×200). Glide will download full image, then resize it to 200×200, then it will cache and load into ImageView while Picasso will download full image then it will cache full image then resize it to 200×200 and load it into ImageView.

Next time when you request same image (500×500) to load into ImageView (100×100), Glide will again download the full image (500×500) then resize it to 100×100 then cache and load into ImageView . Picasso, unlike Glide, picks up the cached full size image and resize and load it into ImageView (100×100). Picasso doesn’t download same image again.

However, you can configure Glide to cache full size and resized image as below.

Loading Image to Target

If you want to do something with the loaded image, you need to load the request into target instead of view. You can use Glide provided SimpleTarget class which implements Target or create custom Target class to capture downloaded image.

Custom Glide Object

In the example above we used default singleton Glide object for loading images. Glide allows you to build custom Glide object using GlideBuilder and set the created Glide object as global singleton object using init() method on Glide class.

GlideBuilder has various methods to set bitmap pool, array pool, request options, transition options, disk cache, memory cache, and executor service.

You can set an image as place holder that will be displayed while an image loading request is being processed by Glide or if loading of the image fails. To set placeholder and error images, you need to instantiate RequestOptions object, set placeholder and error images by calling placeholder() and error() methods on it. Then add RequestOptions object to RequestManager by calling applyDefaultRequestOptions() method on RequestManager as shown below.

You can apply transitions to an image loading request by calling transition() method on RequestBuilder , the method takes TransitionOptions as argument. Transition will be shown while image is being downloaded. That is why image transition will be applied to the image when it is being loaded from disk cache, locally from the device or remotely, but not when it is downloaded from memory cache.

In the example below, transition method is used with DrawableTransitionOptions . Other Glide provided TransitionOptions implementations are BitmapTransitionOptions , DrawableTransitionOptions , and GenericTransitionOptions .

You can use android provided animations with Glide using GenericTransitionOptions.

You can define animation in xml use it with Glide.

You can define custom animation using ViewPropertyTransition.Animator and apply it to image loading request as shown below.

How to add rounded corners to ImageView

Using Glide with Kotlin

Include the Glide dependencies, including the annotation processor:

Include the kotlin-kapt plugin in your build.gradle file:

Create a AppGlideModule implementation:

Build the project and then use the generated API:

Источник