Glide 4.6.1自定义BitmapTransformation时RecyclerView图片闪烁求助

Hey, I’ve been exactly where you are! You follow Glide’s official docs to implement BitmapTransformation with proper updateDiskCacheKey, hashCode, and equals methods, but still get flickering/jumping images in RecyclerView—super frustrating, right? Let’s break down the most common sneaky issues that cause this, even when you think you did everything right:

1. Ensure your Transformation is completely immutable #

This is the #1 culprit I’ve run into. If your transformation uses any mutable properties (var instead of val) that change after initialization, Glide will treat every instance as a new transformation. That means it skips cache and re-loads the image every time, causing flickering.

For example, if you have a rounded corner transformation:

// Bad: mutable radius that could change
class RoundedCornerTransformation(var radius: Int) : BitmapTransformation() {
    // ... rest of implementation
}

// Good: immutable parameters only
class RoundedCornerTransformation(private val radius: Int) : BitmapTransformation() {
    // ... rest of implementation
}

Make sure all parameters that affect the transformation are val and set once during initialization—no runtime changes allowed.

2. Double-check your updateDiskCacheKey implementation #

The official docs say to include all parameters that affect the transformation in the disk cache key, but it’s easy to miss one. If you skip a parameter (like target image width/height), Glide will reuse the same cache entry for different-sized images. When RecyclerView reuses ViewHolders, it might load the wrong cached image first, then replace it with the correct one—causing that jump/flicker.

Here’s a correct example for a transformation that uses radius and target dimensions:

override fun updateDiskCacheKey(messageDigest: MessageDigest) {
    // Add a unique identifier for your transformation
    messageDigest.update("com.yourapp.RoundedCornerTransformation".toByteArray())
    // Add ALL parameters that change the output
    messageDigest.update(radius.toByteArray())
    messageDigest.update(targetWidth.toByteArray())
    messageDigest.update(targetHeight.toByteArray())
}

Every value that alters how the bitmap is transformed must be included here.

3. Fix RecyclerView ViewHolder reuse issues #

Sometimes the problem isn’t the transformation itself—it’s how you’re loading images in your adapter. When ViewHolders are reused, you need to clear any pending Glide requests before starting a new one. If you don’t, an old request might finish after the new one, overwriting the correct image and causing flicker.

In your adapter’s onBindViewHolder:

override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
    val item = items[position]
    // Clear any existing requests first
    Glide.with(holder.imageView.context).clear(holder.imageView)
    // Now load the image with your transformation
    Glide.with(holder.imageView.context)
        .load(item.imageUrl)
        .transform(RoundedCornerTransformation(16))
        .into(holder.imageView)
}

4. Verify hashCode and equals are parameter-complete #

Even if you think you followed the docs, double-check these methods. They must use every parameter that affects the transformation to correctly identify identical transformations.

Example implementation:

override fun hashCode(): Int {
    return Objects.hash("com.yourapp.RoundedCornerTransformation", radius, targetWidth, targetHeight)
}

override fun equals(other: Any?): Boolean {
    if (this === other) return true
    if (javaClass != other?.javaClass) return false
    other as RoundedCornerTransformation
    // Compare ALL relevant parameters
    if (radius != other.radius) return false
    if (targetWidth != other.targetWidth) return false
    if (targetHeight != other.targetHeight) return false
    return true
}

If you miss a parameter here, Glide might treat two identical transformations as different (or vice versa), leading to unnecessary re-loads.

5. Try disabling hardware acceleration (last resort) #

In some cases, certain transformations (like complex cropping or rounded corners) cause rendering glitches with hardware acceleration. You can test this by disabling it for the ImageView:

holder.imageView.setLayerType(View.LAYER_TYPE_SOFTWARE, null)

Note: This can impact performance, so only use it if all other fixes fail.

Start with the first two points—immutability and cache key completeness—they’re the most likely fixes for your issue.

内容的提问来源于stack exchange，提问作者TheHebrewHammer