Android get cache size

Displaying Cache data or Offline mode support in android application

Problems without caching
1. Fetching data over a network connection is an expensive operation. Sometimes due to poor network connectivity, it takes a lot of time to display result( which is a bad experience in terms of mobile application).

2. Sometimes requirement may come with offline support or to display previously fetched response when there is no internet connectivity.

Thanks to Caching mechanism. We can solve the above requirements if we cache some data.

In my project, I have used the dagger, so I have written all the code for caching in ApiModule class. If you want to skip then directly go to below link

How to enable cache
1. define cache memory size

2. Create a cache object ( provide application context )

Provide this cache object in OkHttpClient

Now we will create 2 interceptors ( onlineInterceptor and offlineInterceptor). Interceptors are a powerful mechanism that can monitor, rewrite, and retry calls.

OnlineInterceptor which will be used when the device is connected to the network

OfflineInterceptor which will be used when the device is not connected to the network

Now its time to add cache interceptor to OkHttpClient.

Finally, add OkHttpClient to Retrofit

Using this retrofit instance, we can make an API call and the caching mechanism will work.

Few points to remember

Soon I will post more articles on android, core java.
till then happy learning… 🙂

MindOrks

Our community publishes stories worth reading on Android…

Источник

Android get cache size

By default, Glide checks multiple layers of caches before starting a new request for an image:

1. Active resources — Is this image displayed in another View right now?
2. Memory cache — Was this image recently loaded and still in memory?
3. Resource — Has this image been decoded, transformed, and written to the disk cache before?
4. Data — Was the data this image was obtained from written to the disk cache before?

The first two steps check to see if the resource is in memory and if so, return the image immediately. The second two steps check to see if the image is on disk and return quickly, but asynchronously.

If all four steps fail to find the image, then Glide will go back to the original source to retrieve the data (the original File, Uri, Url etc).

For details on default sizes and locations of Glide’s caches or to configure those parameters, see the configuration page.

Cache Keys

In Glide 4, all cache keys contain at least two elements:

1. The model the load is requested for (File, Uri, Url). If you are using a custom model, it needs to correctly implements hashCode() and equals()
2. An optional Signature

In fact, the cache keys for steps 1-3 (Active resources, memory cache, resource disk cache) also include a number of other pieces of data including:

1. The width and height
2. The optional Transformation
3. Any added Options
4. The requested data type (Bitmap, GIF, etc)

The keys used for active resources and the memory cache also differ slightly from those used from the resource disk cache to accomodate in memory Options like those thataffect the configuration of the Bitmap or other decode time only parameters.

To generate the name of disk cache keys on disk, the individual elements of the keys are hashed to create a single String key, which is then used as the file name in the disk cache.

Cache Configuration

Glide provides a number of options that allow you to choose how loads will interact with Glide’s caches on a per request basis.

Disk Cache Strategies

DiskCacheStrategy can be applied with the diskCacheStrategy method to an individual request. The available strategies allow you to prevent your load from using or writing to the disk cache or choose to cache only the unmodified original data backing your load, only the transformed thumbnail produced by your load, or both.

The default strategy, AUTOMATIC , tries to use the optimal strategy for local and remote images. AUTOMATIC will store only the unmodified data backing your load when you’re loading remote data (like from URLs) because downloading remote data is expensive compared to resizing data already on disk. For local data AUTOMATIC will store the transformed thumbnail only because retrieving the original data is cheap if you need to generate a second thumbnail size or type.

Loading only from cache

In some circumstances you may want a load to fail if an image is not already in cache. To do so, you can use the onlyRetrieveFromCache method on a per request basis:

If the image is found in the memory cache or in the disk cache, it will be loaded. Otherwise, if this option is set to true, the load will fail.

Skipping the cache.

If you’d like to make sure a particular request skips either the disk cache or the memory cache or both, Glide provides a few alternatives.

To skip the memory cache only, use skipMemoryCache() :

To skip the disk cache only, use DiskCacheStrategy.NONE :

These options can be used together:

In general you want to try to avoid skipping caches. It’s vastly faster to load an image from cache than it is to retrieve, decode, and transform it to create a new thumbnail.

If you’d just like to update the entry for an item in the cache, see the documentation on invalidation below.

Implementation

If the available options aren’t sufficient for your needs, you can also write your own DiskCache implementation. See the configuration page for details.

Cache Invalidation

Because disk cache are hashed keys, there is no good way to simply delete all of the cached files on disk that correspond to a particular url or file path. The problem would be simpler if you were only ever allowed to load or cache the original image, but since Glide also caches thumbnails and provides various transformations, each of which will result in a new File in the cache, tracking down and deleting every cached version of an image is difficult.

In practice, the best way to invalidate a cache file is to change your identifier when the content changes (url, uri, file path etc) when possible.

Custom Cache Invalidation

Since it’s often difficult or impossible to change identifiers, Glide also offers the signature() API to mix in additional data that you control into your cache key. Signatures work well for media store content, as well as any content you can maintain some versioning metadata for.

• Media store content — For media store content, you can use Glide’s MediaStoreSignature class as your signature. MediaStoreSignature allows you to mix the date modified time, mime type, and orientation of a media store item into the cache key. These three attributes reliably catch edits and updates allowing you to cache media store thumbs.
• Files — You can use ObjectKey to mix in the File’s date modified time.
• Urls — Although the best way to invalidate urls is to make sure the server changes the url and updates the client when the content at the url changes, you can also use ObjectKey to mix in arbitrary metadata (such as a version number) instead.

Passing in signatures to loads is simple:

The media store signature is also straightforward data from the MediaStore:

You can also define your own signature by implementing the Key interface. Be sure to implement equals() , hashCode() and the updateDiskCacheKey() method:

Keep in mind that to avoid degrading performance, you will want to batch load any versioning metadata in the background so that it is available when you want to load your image.

If all else fails and you can neither change your identifier nor keep track of any reasonable version metadata, you can also disable disk caching entirely using diskCacheStrategy() and DiskCacheStrategy.NONE .

Resource Management

Glide’s disk and memory caches are LRU which means that they take increasingly more memory and/or disk space until they reach their limit at which point they will use at or near the limit continuously. For some added flexibility, Glide provides a few additional ways you can manage the resources your application uses.

Keep in mind that larger memory caches, bitmap pools and disk caches typically provide somewhat better performance, at least up to a point. If you change cache sizes, you should carefully measure performance before and after your changes to make sure the performance/size tradeoffs are reasonable.

Memory Cache

By default Glide’s memory cache and BitmapPool respond to ComponentCallbacks2 and automatically evict their contents to varying degrees depending on the level the framework provides. As a result, you typically don’t need to try to dynamically monitor or clear your cache or BitmapPool . However, should the need arise, Glide does provide a couple of manual options.

Permanent size changes

To change the amount of RAM available to Glide across your application, see the Configuration page.

Temporary size changes.

To temporarily allow Glide to use more or less memory in certain parts of your app, you can use setMemoryCategory :

Make sure to reset the memory category back when you leave the memory or performance sensitive area of your app:

Clearing memory

To simply clear out Glide’s in memory cache and BitmapPool , use clearMemory :

Clearing all memory isn’t particularly efficient and should be avoided whenever possible to avoid jank and increased loading times.

Disk Cache

Glide provides only limited controls for the disk cache size at run time, but the size and configuration can be changed in an AppGlideModule .

Permanent size changes

To change the amount of sdcard space available to Glide’s disk cache across your application, see the Configuration page.

Clearing the disk cache

To try to clear out all items in the disk cache, you can use clearDiskCache :

Источник

Retrofit 2: Http Caching in Android

May 28, 2020 · 3 min read

Caching is nothing but a way to store network fetched data on a device’s storage and access later when the device is offline or we want the same data again and again. Some image loading library like Picasso or Glide provide this caching when loading and displaying images but retrofit does not use this by default for its requests.

So in this article, you’ll learn the basics of caching and the way to enable online and offline caching in your Android app with Retrofit and Okhttp libraries.

Before starting lets know why caching is important…

Advantages of Caching

• It reduces bandwidth consumption; therefore, it decreases network traffic and diminishes network congestion.
• Saves you time you’d spend waiting for the server to get response.
• If you need to access the same network resource again after having accessed it recently, your device won’t need to make a request to the server; it’ll get the cached response instead.

So Let’s start caching requests

Befor e starting, we will go through some important terms which are related to caching like: Okhttp, Interceptor, Cache-control, max-age, max-stale.

* Okhttp

This is the default HttpClient for Retrofit.

* Interceptors

Interceptor is a powerful component of this okhttp through which we can read and modify the requests and obviously, we will use this interceptor for our Cache control. There are two types of interceptor:

• Application Interceptors — Gets you the final response.
• Network Interceptors — To intercept intermediate requests.

For caching, we will use Network interceptor.

* Cache-control

Cache-control is an header used to specify caching policies in client requests and server responses. Inside the interceptors, we will to get the current request using chain.request() and add caching options to that request.

By the following way, we can add a “Cache-Control” header to the request: «public, only-if-cached, max-stale=60»

Then do a chain.proceed(request) to proceed with the modified request to return the response.

Find details for cache-control here.

* max-age =

max-age is the oldest limit ( lower limit) till which the response can be returned from the cache. It takes value in seconds.

* max-stale =

max-stale is the highest limit beyond which cache cannot be returned. It also takes value in seconds.

Step 1: Define a method to check for internet connectivity

We first need to have a method in our app that checks for Internet connectivity. May be you’re already familiar with it and want to take a look at it again:

Источник

Best strategy to load images using Glide — Image loading library for Android

Feb 21, 2019 · 4 min read

Glide is an Image Loader Library for Android developed by bumptech and is a library that is recommended by Google. It has been used in many Google open source projects including Google I/O 2014 official application.

Many of us use glide for image loading but only some of us know its real power. If we dive into the features of glide, the article will go into TL;DR category. Instead I like it to be short and sweet 😉

I have been working on glide since long and the app I am working on relies on images heavily, images in recycler view, view pager, nested recycler views and every single image is a url.

To make app smooth, we had to brainstorm on cache strategy.

How Glide Cache Works

By default, Glide checks multiple layers of caches before starting a new request for an image:

1. Active resources — Is this image displayed in another View right now?
2. Memory cache — Was this image recently loaded and still in memory?
3. Resource — Has this image been decoded, transformed, and written to the disk cache before?
4. Data — Was the data this image was obtained from written to the disk cache before?

If all four steps fail to find the image, then Glide will go back to the original source to retrieve the data from the URL.

Best Image Loading and Caching Strategy

ONE — Enable Disk Cache
Applications that use the same resource multiple times in multiple sizes and are willing to trade off some speed and disk space in return for lower bandwidth usage may want to consider enabling disk cache.
You can find more details here.
To enable it we will write the following code.

TWO — Add Image Signature
Guess, what if the image on same URL is changed? Glide will show the old image from cache.
But glide is something from heaven 😍 — it comes with the solution.
Make sure whenever the image on server is changed, it also notifies client. Let it be the latest date time stamp.
Now it can be used for versioning in cache as well. Whenever new signature is provided, it will fetch the new image and cache it as well. Details.
Just add it to the request options.

THREE — Override Image Size (Optional)
If you need very specific size of the image and you are very sure of it, you can use the override request option. It is very useful for the thumbnails.

FOUR — Add Thumbnail Url
Glide’s thumbnail() API allows you to specify a RequestBuilder to start in parallel with your main request. The thumbnail() will be displayed while the primary request is loading. If the primary request completes before the thumbnail request, the image from the thumbnail request will not be shown.

If you only have a single remote URL, you can still benefit from the thumbnail API by using Glide’s override() or sizeMultiplier() APIs to force Glide to load a lower resolution image in the thumbnail request

FIVE — Setup Monthly Schedule for Cleaning
In case when image url is changed and old one is never used but it is still in cache and eating up the phone memory, what to do?
Glide don’t provide the solution for this but you can set up a monthly schedule to clear up all the cache. Details.

SIX — Setup Cache Limit (Optional)

Glide allows applications to use AppGlideModule implementations to completely control Glide’s memory and disk cache usage. Glide tries to provide reasonable defaults for most applications, but for some applications, it will be necessary to customise these values. Be sure to measure the results of any changes to avoid performance regressions. Details can be seen here.

These were the 6 easy steps to achieve better strategy for image caching. Implement and let me know if you find it helpful.

If you have any suggestions or better approach, please do let me know in comments below, I will add them to the article.

Thank you for reading and don’t forget to clap if you liked it 🙂

Источник