Remove image from cache in Glide library

Question

I am using Glide in one of my projects to show images from files.

Below is my code of how I am showing the image:

Glide.with(DemoActivity.this)
     .load(Uri.parse("file://" + imagePath))
     .into(mImage);

The image at this location(imagePath) keeps on changing. By default Glide cache the image it shows in the ImageView. Because of this, the Glide was showing the first image from the cache for new images at that location.

If I change the image at location imagePath with some other image having the same name then the Glide is showing the first image instead of the new one.

Two queries are:

Is it possible to always the image from File and not cache? This way problem will be solved.
Is it possible to clear the image from the cache before getting the newly replaced image? This will also solve the problem.

score 182 · Accepted Answer · edited Jul 25 '23 at 17:11

182

This is how I solved this problem.

Method 1: When the URL changes whenever the image changes

Glide.with(DemoActivity.this)
    .load(Uri.parse("file://" + imagePath))
    .diskCacheStrategy(DiskCacheStrategy.NONE)
    .skipMemoryCache(true)
    .into(mImage);

diskCacheStrategy() can be used to handle the disk cache and you can skip the memory cache using the skipMemoryCache() method.

Method 2: When the URL doesn't change, however, the image changes

If your URL remains constant then you need to use Signature for image cache.

Glide.with(yourFragment)
     .load(yourFileDataModel)
     .signature(new StringSignature(yourVersionMetadata))
     .into(yourImageView);

Glide signature() offers you the capability to mix additional data with the cache key.

You can use MediaStoreSignature if you are fetching content from a media store. 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.
You may StringSignature as well for content saved as Files to mix the file date modified time.

edited Jul 25 '23 at 17:11

Hamza

41
7

answered Oct 31 '15 at 12:07

Nitesh Kumar

5,370
5
37
54

It works for me. Make sure you are actually changing the picture. – Juan José Melero Gómez Sep 15 '17 at 18:01
25

Note that with Glide v4 `StringSignature` has been replaced by `ObjectKey`, see [Glide v4 Caching](https://bumptech.github.io/glide/doc/caching.html#custom-cache-invalidation) – SoftWyer Dec 30 '17 at 20:08
In this method if we have same url with different version does it load relavent version when we pass the version? – Ishan Fernando Feb 14 '18 at 16:28
3

You didnt solve the 2 problem "Is it possible to clear image from cache before getting newly replaced image? This will also solve the problem." – Nick Jun 14 '18 at 07:56
1

while it works, it's painfully slow to load the images every time with this method – The Fluffy T Rex Apr 22 '20 at 09:10
In v4 one can use .signature(new ObjectKey(System.currentTimeMillis())) (Note StringSignature doesn't work in this version) – tanni tanna Oct 14 '22 at 13:59

score 64 · Answer 2 · edited Jun 20 '20 at 09:12

64

As explained in the section Caching and Cache Invalidation of the Glide wiki:

Because File names 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).

Since you can't change the file path, Glide offers the signature() API that allows you sets some additional data to be mixed in to the memory and disk cache keys allowing the caller more control over when cached data is invalidated.

If you want to reload every time the image from the disk, you can change your code like this:

Glide.with(DemoActivity.this)
     .load(Uri.parse("file://" + imagePath))
     .signature(new StringSignature(String.valueOf(System.currentTimeMillis())))
     .into(mImage);

edited Jun 20 '20 at 09:12

Community

1
1

answered Oct 31 '15 at 09:47

Mattia Maestrini

32,270
15
87
94

This is perfect for my needs. I have a version for my data, so just adding `.signature(new StringSignature(Integer.toString(data.getVersion())))` forces an update of images whenever the version is changed. – Krøllebølle Apr 13 '16 at 15:52
@Mattia Maestrini Thanks, your solution update single image into cache by `System.currentTimeMillis()`? – DolDurma Apr 25 '16 at 15:18
1

So I'm guessing this will not pollute the cache directory because the URL is implied to be constant right? That means it will overwrite previous cache entries? – TheRealChx101 Jul 16 '19 at 15:36
3

for Kotlin use `.signature(ObjectKey(System.currentTimeMillis())))` – Yonko Kilasi Jul 14 '20 at 19:57
With Glide 4.2.0, `StringSignature` was not resolved so instead of `StringSignature` use `ObjectKey` – Dinesh Dec 21 '22 at 13:47

Chandrahasan · Answer 3 · 2019-01-09T10:55:59.110

There are two ways to handle Glide cache refresh,

Firstway: - Add below with glide implementation

.diskCacheStrategy(DiskCacheStrategy.NONE)
.skipMemoryCache(true)

Second way:

If you able to identify image changes then give your new file name in below,

.signature(new StringSignature(String.valueOf(fileName)))

or you want to load every time with latest images , use below

.signature(new StringSignature(String.valueOf(System.currentTimeMillis())))

Hope this helps.

score 39 · Answer 4 · answered Apr 15 '16 at 06:04

39

This will remove cache memory which is stored by Glide.And it should be done in background otherwise it will throw exception

new Thread(new Runnable() {
          @Override
          public void run() {
             Glide.get(MainActivity.this).clearDiskCache();
          }
     }).start();

answered Apr 15 '16 at 06:04

Anand Savjani

2,484
3
26
39

1

then how it will be decided by the system to stop the running thread just after deleting the cache? – Yash Agrawal Nov 14 '16 at 18:55
1

@YashAgrawal : It will decide by the internal structure. So no need to worry about it – Anand Savjani Nov 15 '16 at 04:20
@AnandSavjani when you need to call this ? – abh22ishek Apr 12 '21 at 12:17
@abh22ishek when you want to refresh your images during scrolling recyclerview or viewpager or whenever you need to update images with same url and same image name. – Anand Savjani Apr 13 '21 at 16:57

score 27 · Answer 5 · answered Oct 17 '17 at 13:34

Had troubles with Glide 4.2.0, StringSignature was not resolved.

Looks like StringSignature is not available anymore and you have to use ObjectKey instead.

So code looks like

Glide.with(imageView).
load(pathToImage).
apply(new RequestOptions().signature(new ObjectKey("signature string"))).
into(imageView);

score 16 · Answer 6 · answered Oct 06 '16 at 15:25

If you save images to the same known filename as a convention and want to invalidate the Glide cache only when the file has changed, using the file modification timestamp can work well.

I was using such a convention for avatar images which I was downloading to File objects outside Glide, and then using Glide just to efficiently resize and make them round, etc.

So I ended up using the StringSignature strategy with the value of the file's lastChanged timestamp as the signature. Here's what the fluent code for that looks like:

Glide.with(this)
        .load(avatarFile)
        .diskCacheStrategy(DiskCacheStrategy.RESULT)
        .signature(new StringSignature(String.valueOf(avatarFile.lastModified())))
        .into(ivProfile);
}

where avatarFile is my java.io.File object, of course.

Palejandro · Answer 7 · 2017-10-09T22:39:09.627

14

I had troubles with setting signature using Glide version 4.* with Kotlin. After some time I ended up with this:

fun ImageView.loadUrl(url: String) {
    var requestOptions = RequestOptions()
    requestOptions.signature(ObjectKey(System.currentTimeMillis()))
    Glide.with(this).load(url).apply(requestOptions).into(this)
}

It's an extension function for ImageView, and it's used this way:

 imageView.loadUrl(url)

I Hope it will help someone

edited Oct 09 '17 at 22:39

answered Sep 16 '17 at 14:02

Palejandro

2,092
5
26
38

1

exactly what I need. – Anton Derevyanko Mar 27 '18 at 15:42

score 13 · Answer 8 · answered Dec 14 '17 at 07:27

For Glide 4.3.+ library you need to something like this to ,

Glide.with(context)
    .load(image_path)
    .apply(new RequestOptions()
                        .diskCacheStrategy(DiskCacheStrategy.NONE)
                        .skipMemoryCache(true))
    .into(imge_view);

score 13 · Answer 9 · edited Nov 25 '18 at 00:18

In the latest versions we should use RequestOptions

RequestOptions Provides type independent options to customize loads with Glide in the latest versions of Glide.

Make a RequestOptions Object and use it when we are loading the image.

 RequestOptions requestOptions = new RequestOptions()
                        .diskCacheStrategy(DiskCacheStrategy.NONE) // because file name is always same
                        .skipMemoryCache(true);

 Glide.with(this)
           .load(photoUrl)
           .apply(requestOptions)
           .into(profile_image);

score 7 · Answer 10 · answered Aug 28 '19 at 19:41

7

I was using Glide to load a File, and here's what I ended up doing to make sure Glide's disk cache was invalidated every time my file changed (even though it had the same path):

Glide.with(context)
    .load(bitmapFile)
    .signature(new ObjectKey(bitmapFile.lastModified()))
    .into(imageView);

answered Aug 28 '19 at 19:41

Adam Johns

35,397
25
123
176

1

Very smart! This is actually the best for local files. Thanks for sharing! – Jona Mar 26 '21 at 21:08

score 7 · Answer 11 · answered May 05 '20 at 11:07

I worked on this for days, and all the above-mentioned solutions are just slow as a sloth.

I know you've probably read this before and ignored it because you thought it would probably take a lot of work to change your code. But seriously, it's well worth it. The performance, as far as I can tell, beats all the other methods presented, it's Glide's recommended solution, AND you don't need to skip cache or create signatures so it keeps your code cleaner too.

FROM Glide:

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. - https://bumptech.github.io/glide/doc/caching.html

SOLUTION: Change the name of the image when the user uploads a new image. Get the file name and use that for example. Once the image URL has changed, Glide understands you have changed the image and will update the Cache accordingly. This has by far given me the best performance.

WHEN USING:

.diskCacheStrategy(DiskCacheStrategy.NONE)
.skipMemoryCache(true)

It never caches the images and this really makes images load slowly. You'd think Signatures are better for performance, but to me they seemed just as slow.

score 6 · Answer 12 · answered Dec 05 '17 at 13:13

6

signature with GlideApp

    GlideApp.with(imageView)
            .load(url)
            .signature(new ObjectKey(System.currentTimeMillis()))
            .placeholder(R.drawable.sky)
            .error(R.drawable.sky)
            .into(imageView);

answered Dec 05 '17 at 13:13

Dan Alboteanu

9,404
1
52
40

score 5 · Answer 13 · answered Jul 06 '18 at 09:42

And finally Kotlin implementation (For Fragments):

Glide.with(activity)
            .load(url)
            .apply(RequestOptions()
                    .diskCacheStrategy(DiskCacheStrategy.NONE)
                    .skipMemoryCache(true))
            .into(myImageView)

score 4 · Answer 14 · answered Aug 10 '17 at 08:49

This worked for me

  //use  diskCacheStrategy(DiskCacheStrategy.NONE) after skipMemoryCache(true) 
         Glide.with(this)
            .load(image)
            .skipMemoryCache(true) 
            .diskCacheStrategy(DiskCacheStrategy.NONE)
            .into(imageview);

score 3 · Answer 15 · edited Jun 23 '21 at 09:43

3

Programmatically simply you can use:

 // must run on main thread
 Glide.get(getApplicationContext()).clearMemory(); 

 // must run in background thread
 Glide.get(getApplicationContext()).clearDiskCache();

For More

edited Jun 23 '21 at 09:43

Philipp Jahoda

50,880
24
180
187

answered Oct 16 '19 at 08:17

Amal

261
4
9

score 2 · Answer 16 · answered Oct 11 '18 at 22:50

2

This one worked for me!

Glide.with(DemoActivity.this)
    .load(Uri.parse("file://" + imagePath))
    .diskCacheStrategy(DiskCacheStrategy.NONE)
    .skipMemoryCache(true)
    .into(mImage);

answered Oct 11 '18 at 22:50

Allan Jaqueira

27
5

score 1 · Answer 17 · answered Apr 12 '16 at 19:17

To benefit from the cache provided by Glide and ensure that the correct image is shown everytime, you can use the signature() API.

All you have to do is to set as signature an information that relates to the image file. When you replace that file, the information changes too and Glide knows it must reload it, ignoring the cache.

A valid information could be a digest (for example SHA-1) calculated on the file contents.

Glide.with(context)
   .load(inputFile)
   .signature(new StringSignature(sha1(inputFile)))
   .into(targetImageView);

Here I found the following implementation of sha1() function:

public static String sha1(final File file) throws NoSuchAlgorithmException, IOException {
   final MessageDigest messageDigest = MessageDigest.getInstance("SHA1");

   try (InputStream is = new BufferedInputStream(new FileInputStream(file)) {
     final byte[] buffer = new byte[1024];
     for (int read = 0; (read = is.read(buffer)) != -1;) {
       messageDigest.update(buffer, 0, read);
     }
   }

   // Convert the byte to hex format
   try (Formatter formatter = new Formatter()) {
     for (final byte b : messageDigest.digest()) {
       formatter.format("%02x", b);
     }
     return formatter.toString();
   }
}

seems working with using signature, diskcache and skipmemory all together. — Panache, Jan 12 '17 at 16:26

score 1 · Answer 18 · answered Jan 11 '20 at 23:08

1) First clear disk cache.

private class ClearGlideCacheAsyncTask extends AsyncTask<Void, Void, Boolean>{

        private boolean result;

        @Override
        protected Boolean doInBackground(Void... params) {
            try {
                Glide.get(getContext()).clearDiskCache();
                result = true;
            }
            catch (Exception e){
            }
            return result;
        }

        @Override
        protected void onPostExecute(Boolean result) {
            super.onPostExecute(result);
            if(result)
                Toast.makeText(getActivity(), "cache deleted", Toast.LENGTH_SHORT).show();
        }
    }

You can call from your ui with new ClearGlideCacheAsyncTask ().execute();

2) Clear memory cache

// This method must be called on the main thread.
Glide.get(context).clearMemory();

Source : https://bumptech.github.io/glide/doc/caching.html

score 0 · Answer 19 · answered Jan 09 '23 at 07:03

0

you can use a time stamp, that time could be the file's date modified or System.currentTimeMillis()

this works perfectly

Glide.with(DemoActivity.this)
 .load(Uri.parse("file://" + imagePath+"?time="+System.currentTimeMillis()))
 .into(mImage);

answered Jan 09 '23 at 07:03

Enakhi

1,143
10
16

Remove image from cache in Glide library

19 Answers19

Linked