Android Lrucache Example .If you want to know about Android Lrucache Example , then this article is for you. You will find a lot of information about Android Lrucache Example in this article. We hope you find the information useful and informative. You can find more articles on the website.

What is Android?

Android, the widely popular operating system, is the beating heart behind millions of smartphones and tablets globally. Developed by Google, Android is an open-source platform that powers a diverse range of devices, offering users an intuitive and customizable experience. With its user-friendly interface, Android provides easy access to a plethora of applications through the Google Play Store, catering to every need imaginable. From social media and gaming to productivity and entertainment, Android seamlessly integrates into our daily lives, ensuring that the world is at our fingertips. Whether you're a tech enthusiast or a casual user, Android's versatility and accessibility make it a cornerstone of modern mobile technology.


Android LruCache Example

LruCache in Android is a powerful utility that helps developers efficiently manage memory by caching frequently accessed data. It is based on the Least Recently Used (LRU) algorithm, which means it automatically evicts the least recently used items when the cache size exceeds the set limit. This is particularly useful for memory-intensive data like images, which are frequently loaded from a remote server.

In this example, we'll create a simple LruCache implementation for caching images in an Android app.

1. Setting Up LruCache

Before we start implementing, let's understand how to set up LruCache in Android.

Create an LruCache Instance

To use LruCache, you need to specify the cache size. The cache size is generally set in bytes, and the size you choose depends on the available memory on the device. Here, we will set a cache size of 4MB for demonstration purposes.

import android.graphics.Bitmap;
import android.util.LruCache;

public class ImageCache {
    private LruCache<String, Bitmap> mMemoryCache;

    // Constructor to initialize the LruCache with a specified size
    public ImageCache() {
        // Set the cache size to 4MB
        final int cacheSize = 4 * 1024 * 1024; // 4MB
        mMemoryCache = new LruCache<>(cacheSize);
    }

    // Method to add a bitmap to the cache
    public void addBitmapToCache(String key, Bitmap bitmap) {
        if (getBitmapFromCache(key) == null) {
            mMemoryCache.put(key, bitmap);
        }
    }

    // Method to get a bitmap from the cache
    public Bitmap getBitmapFromCache(String key) {
        return mMemoryCache.get(key);
    }
}

2. Explanation of the Code

  • Cache Size: In the example above, the cache size is set to 4MB. You can calculate the cache size based on the available memory and adjust it accordingly.

  • addBitmapToCache: This method adds a Bitmap to the cache if it’s not already present. The cache is stored with a key that helps retrieve the item later.

  • getBitmapFromCache: This method retrieves a Bitmap from the cache based on the provided key.

3. Using LruCache in an Android Activity

Next, let's demonstrate how to use the LruCache in an Android activity. We’ll load an image from resources and cache it using the ImageCache class.

Activity Code Example

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.widget.ImageView;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {
    private ImageCache imageCache;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Initialize ImageCache
        imageCache = new ImageCache();

        // Load a sample image from resources
        Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sample_image);

        // Add the bitmap to the cache
        String key = "sample_image_key";
        imageCache.addBitmapToCache(key, bitmap);

        // Retrieve the bitmap from cache and set it in an ImageView
        Bitmap cachedBitmap = imageCache.getBitmapFromCache(key);
        if (cachedBitmap != null) {
            ImageView imageView = findViewById(R.id.imageView);
            imageView.setImageBitmap(cachedBitmap);
        }
    }
}

Explanation of the Activity Code:

  • BitmapFactory: The BitmapFactory.decodeResource() method loads an image from the app’s resources into a Bitmap object.

  • Add to Cache: The loaded Bitmap is added to the LruCache with the key "sample_image_key".

  • Retrieve from Cache: The cache is checked using the key "sample_image_key", and if the image is found, it is displayed in an ImageView.

4. Displaying Cached Images in a List (Optional)

In more complex scenarios, such as displaying images in a list or grid, you can efficiently load and cache images using LruCache.

Here’s a quick example of how you might implement LruCache in an adapter for a RecyclerView to cache images as you load them:

public class ImageAdapter extends RecyclerView.Adapter<ImageAdapter.ViewHolder> {
    private List<String> imageUrls;
    private ImageCache imageCache;

    public ImageAdapter(List<String> imageUrls, ImageCache imageCache) {
        this.imageUrls = imageUrls;
        this.imageCache = imageCache;
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_image, parent, false);
        return new ViewHolder(view);
    }

    @Override
    public void onBindViewHolder(ViewHolder holder, int position) {
        String imageUrl = imageUrls.get(position);

        // Check if the image is already in cache
        Bitmap cachedBitmap = imageCache.getBitmapFromCache(imageUrl);
        if (cachedBitmap != null) {
            holder.imageView.setImageBitmap(cachedBitmap);
        } else {
            // Load the image (you can use libraries like Glide or Picasso here)
            // For simplicity, using a placeholder method to simulate image loading
            Bitmap bitmap = loadImage(imageUrl);
            imageCache.addBitmapToCache(imageUrl, bitmap);
            holder.imageView.setImageBitmap(bitmap);
        }
    }

    @Override
    public int getItemCount() {
        return imageUrls.size();
    }

    private Bitmap loadImage(String imageUrl) {
        // Simulate loading an image (in reality, you can use libraries like Glide or Picasso here)
        return BitmapFactory.decodeResource(context.getResources(), R.drawable.sample_image);
    }

    public static class ViewHolder extends RecyclerView.ViewHolder {
        ImageView imageView;

        public ViewHolder(View itemView) {
            super(itemView);
            imageView = itemView.findViewById(R.id.imageView);
        }
    }
}

5. Performance Considerations

  • Memory Management: The size of the cache should be considered in relation to the available memory on the device. You want to avoid setting an excessively large cache size that could cause OutOfMemoryError.

  • Eviction Strategy: LruCache will automatically evict the least recently used items when the cache reaches its size limit. This is the primary benefit of using LruCache.

  • Bitmap Decoding: When using images as cached objects, consider using BitmapFactory with inSampleSize to decode large images into scaled-down versions to save memory.

Conclusion

In this example, we demonstrated how to use LruCache to cache images in Android, both for single-item caching and for caching in a list using a RecyclerView adapter. LruCache is an excellent tool for optimizing memory usage and improving app performance, especially when dealing with images or frequently accessed data that’s expensive to load or compute.

By implementing LruCache effectively, you can avoid unnecessary data loading and improve the overall responsiveness of your Android applications, providing a smoother user experience.