Esiste un modo per forzare Volley ad aggiornare un'immagine?

Question

Attualmente sto lavorando a un'app di front end che fa molto affidamento su immagini scaricate da un webservice. Per farla breve, il front-end scarica dal nostro webservice un determinato profilo utente con 3 aree immagine. Se tale utente carica una nuova immagine (mantenendo lo stesso url) non si aggiornerà fino a quando non uccido la mia app, quindi se dovessi metterlo in background e riprendere i dati non verranno modificati.

Ecco un piccolo esempio del codice che si occupa della ImageNetworkView:

mImage = (NetworkImageView) mView 
      .findViewById(R.id.profile_network_image); 

    mProgressBar = (ProgressBar) mView 
      .findViewById(R.id.profileProgressBar); 

    // Cargo image loader 
    mLoader = VolleySingleton.getInstance(mActivity).getImageLoader(); 

    if(mLoader!=null && imageUrl!=null){ 
     mLoader.get(imageUrl, new ImageListener() { 


      @Override 
      public void onErrorResponse(VolleyError error) { 

       System.out.println("Error loading "+imageUrl+"..."); 

      } 

      @Override 
      public void onResponse(ImageContainer response, boolean isImmediate) { 
       if (response.getBitmap() != null) { 
        mImage.setImageBitmap(response.getBitmap()); 
        mProgressBar.setVisibility(View.GONE); 
        System.out.println("Done loading "+imageUrl); 
       } 

      } 
     }); 

mImage.setImageUrl(imageUrl, mLoader); 

Qui sono le mie due VolleySingleton e Cache classi: classe

public class VolleySingleton { 
private static VolleySingleton mInstance = null; 
private RequestQueue mRequestQueue; 
private ImageLoader mImageLoader; 
private ImageLoader.ImageCache mImageCache; 

private VolleySingleton(Context context){ 
    mRequestQueue = Volley.newRequestQueue(context); 
    mImageCache = new BitmapLruImageCache(); 
    mImageLoader = new ImageLoader(this.mRequestQueue, mImageCache); 
} 

public static VolleySingleton getInstance(Context context){ 
    if(mInstance == null){ 
     mInstance = new VolleySingleton(context); 
    } 
    return mInstance; 
} 

public RequestQueue getRequestQueue(){ 
    return this.mRequestQueue; 
} 

public ImageLoader getImageLoader(){ 
    return this.mImageLoader; 
} 

public ImageLoader.ImageCache getImageCache(){ 
    return mImageCache; 
} 

cache:

public class BitmapLruImageCache extends LruCache<String, Bitmap> implements ImageCache { 

public static int getDefaultLruCacheSize() { 
    final int maxMemory = (int) (Runtime.getRuntime().maxMemory()/1024); 
    final int cacheSize = maxMemory/8; 

    return cacheSize; 
} 

public BitmapLruImageCache() { 
    this(getDefaultLruCacheSize()); 

    Log.v("tag", Integer.toString(getDefaultLruCacheSize())); 
} 

public BitmapLruImageCache(int sizeInKiloBytes) { 
    super(sizeInKiloBytes); 

} 

@Override 
protected int sizeOf(String key, Bitmap value) { 
    return value.getRowBytes() * value.getHeight()/1024; 
} 

@Override 
public Bitmap getBitmap(String url) { 
    return get(url); 
} 

@Override 
public void putBitmap(String url, Bitmap bitmap) { 
    put(url, bitmap); 
} 

Grazie a tutti in anticipo!

EDIT: Ho cercato di trovare una soluzione e finora mi si avvicinò con questo:

Se dovessi mettere la nuova immagine sulla cache assegnato alla URL dell'immagine quando chiamo getBitmap (url) Riceverò la nuova immagine, ma il problema persiste, se chiudo l'app con il pulsante Indietro e lo apro ancora una volta scarica la vecchia immagine, ma se uccido l'app verrà caricata la nuova .. . Ecco il codice che ho usato per posizionare l'immagine sulla cache:

VolleySingleton.getInstance(mActivity).getImageCache().putBitmap(imageUrl, bmp); 

tempBitmap = VolleySingleton.getInstance(mActivity).getImageCache().getBitmap(imageUrl); 

Answer 1

il fatto è che la cache immagine è nella memoria e il ImageLoader verificherà che prima persino effettuare una chiamata.

 // Try to look up the request in the cache of remote images. 
    Bitmap cachedBitmap = mCache.getBitmap(cacheKey); 
    if (cachedBitmap != null) { 
     // Return the cached bitmap. 
     ImageContainer container = new ImageContainer(cachedBitmap, requestUrl, null, null); 
     imageListener.onResponse(container, true); 
     return container; 
    } 

Sarà necessario pulire manualmente la cache:

VolleySingleton.getInstance(mActivity).getImageCache().remove(imageUrl); 

o

VolleySingleton.getInstance(mActivity).getImageCache().evictAll()