Gibt es eine Möglichkeit, Volley zu zwingen, ein Bild zu aktualisieren?

Question

Ich arbeite gerade an einer Front-End-App, die stark auf Images basiert, die von einem Webservice heruntergeladen werden. Um es kurz zu machen, das Frontend lädt von unserem Webservice ein bestimmtes Benutzerprofil mit 3 Image Slots herunter. Wenn ein solcher Benutzer ein neues Bild hochlädt (die gleiche URL beibehalten), wird er erst aktualisiert, wenn ich meine App beendet habe. Wenn ich ihn also im Hintergrund anzeigen und fortsetzen möchte, werden die Daten nicht geändert.

Hier ist eine kleine Probe des Codes, der mit dem ImageNetworkView Angebote:

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); 

Hier sind meine beiden VolleySingleton und Cache-Klassen:

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-Klasse:

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); 
} 

Vielen Dank im Voraus!

EDIT: Ich habe versucht, Abhilfe zu schaffen und so weit kam ich mit auf den Punkt:

Wenn ich das neue Bild auf dem Cache auf die Bild-URL zugewiesen platzieren, als ich GetBitmap nennen (URL) Ich werde das neue Bild bekommen, aber das Problem besteht weiter, wenn ich die App mit der Zurück-Taste schließe und es wieder öffne, lädt Volley das alte Bild, aber wenn ich die App kille, wird sie die neue laden. . Hier ist der Code, den ich verwendet habe, um das Bild auf dem Cache zu platzieren:

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

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

Answer 1

die Sache ist, dass Bild-Cache im Speicher ist und Die ImageLoader wird dies überprüfen, bevor Sie einen Anruf tätigen.

 // 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; 
    } 

Sie müssen den Cache reinigen manuell durch:

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

oder

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