tessl/maven-com-github-bumptech-glide--glide

A fast and efficient open source media management and image loading framework for Android that wraps media decoding, memory and disk caching, and resource pooling into a simple and easy to use interface.

—

Pending

Overview

Eval results

Files

Modules and Configuration

Name: tessl/maven-com-github-bumptech-glide--glide
Author: tessl

Global configuration and extension system for customizing Glide behavior, including custom loaders, decoders, cache implementations, and module registration.

Capabilities

Glide Modules

Base interfaces for creating configuration modules that customize Glide's behavior.

/**
 * Legacy module interface for global Glide configuration
 */
public interface GlideModule {
    /**
     * Apply global configuration options
     * @param context Application context
     * @param builder Glide builder for configuration
     */
    void applyOptions(@NonNull Context context, @NonNull GlideBuilder builder);
    
    /**
     * Register custom components
     * @param context Application context
     * @param glide Glide instance
     * @param registry Component registry
     */
    void registerComponents(@NonNull Context context, @NonNull Glide glide, @NonNull Registry registry);
}

/**
 * Application-level module for configuration
 */
public abstract class AppGlideModule extends GeneratedAppGlideModule {
    /**
     * Apply global configuration options
     * @param context Application context  
     * @param builder Glide builder for configuration
     */
    public void applyOptions(@NonNull Context context, @NonNull GlideBuilder builder) {
        // Override to customize configuration
    }
    
    /**
     * Register custom components
     * @param context Application context
     * @param glide Glide instance
     * @param registry Component registry
     */
    public void registerComponents(@NonNull Context context, @NonNull Glide glide, @NonNull Registry registry) {
        // Override to register custom components
    }
    
    /**
     * Control manifest parsing
     * @return true to enable parsing AndroidManifest.xml for modules
     */
    public boolean isManifestParsingEnabled() {
        return true;
    }
    
    /**
     * Get excluded module classes
     * @return Set of module classes to exclude
     */
    @NonNull
    public Set<Class<?>> getExcludedModuleClasses() {
        return Collections.emptySet();
    }
}

/**
 * Library-level module for component registration
 */
public abstract class LibraryGlideModule implements RegistersComponents {
    /**
     * Register custom components
     * @param context Application context
     * @param glide Glide instance
     * @param registry Component registry
     */
    @Override
    public abstract void registerComponents(@NonNull Context context, @NonNull Glide glide, @NonNull Registry registry);
}

Usage Examples:

// AppGlideModule implementation
@GlideModule
public final class MyAppGlideModule extends AppGlideModule {
    @Override
    public void applyOptions(Context context, GlideBuilder builder) {
        // Custom memory cache
        int memoryCacheSizeBytes = 1024 * 1024 * 20; // 20mb
        builder.setMemoryCache(new LruResourceCache(memoryCacheSizeBytes));
        
        // Custom disk cache
        builder.setDiskCache(new InternalCacheDiskCacheFactory(context, 100 * 1024 * 1024));
        
        // Request options
        RequestOptions requestOptions = new RequestOptions()
            .format(DecodeFormat.PREFER_RGB_565)
            .disallowHardwareConfig();
        builder.setDefaultRequestOptions(requestOptions);
    }
    
    @Override
    public void registerComponents(Context context, Glide glide, Registry registry) {
        // Custom model loader
        registry.append(MyCustomModel.class, InputStream.class, new MyModelLoaderFactory());
        
        // Custom decoder
        registry.register(InputStream.class, MyResource.class, new MyResourceDecoder());
    }
}

// LibraryGlideModule implementation  
public class MyLibraryGlideModule extends LibraryGlideModule {
    @Override
    public void registerComponents(Context context, Glide glide, Registry registry) {
        // Register library-specific components
        registry.prepend(MyLibraryModel.class, InputStream.class, new MyLibraryModelLoader.Factory());
    }
}

Glide Builder

Configuration builder for customizing Glide's global behavior and components.

/**
 * Builder for configuring Glide instances
 */
public final class GlideBuilder {
    /**
     * Set custom bitmap pool
     * @param bitmapPool Custom bitmap pool implementation
     * @return GlideBuilder for chaining
     */
    @NonNull public GlideBuilder setBitmapPool(@Nullable BitmapPool bitmapPool);
    
    /**
     * Set custom array pool
     * @param arrayPool Custom array pool implementation  
     * @return GlideBuilder for chaining
     */
    @NonNull public GlideBuilder setArrayPool(@Nullable ArrayPool arrayPool);
    
    /**
     * Set custom memory cache
     * @param memoryCache Custom memory cache implementation
     * @return GlideBuilder for chaining
     */
    @NonNull public GlideBuilder setMemoryCache(@Nullable MemoryCache memoryCache);
    
    /**
     * Set custom disk cache factory
     * @param diskCacheFactory Custom disk cache factory
     * @return GlideBuilder for chaining
     */
    @NonNull public GlideBuilder setDiskCache(@Nullable DiskCache.Factory diskCacheFactory);
    
    /**
     * Set custom execution engine
     * @param engine Custom engine implementation
     * @return GlideBuilder for chaining
     */
    @NonNull public GlideBuilder setEngine(@Nullable Engine engine);
    
    /**
     * Set default request options
     * @param requestOptions Default options for all requests
     * @return GlideBuilder for chaining
     */
    @NonNull public GlideBuilder setDefaultRequestOptions(@Nullable RequestOptions requestOptions);
    
    /**
     * Set default transition options for specific resource type
     * @param clazz Resource class
     * @param options Transition options
     * @return GlideBuilder for chaining
     */
    @NonNull public <T> GlideBuilder setDefaultTransitionOptions(@NonNull Class<T> clazz, @Nullable TransitionOptions<?, T> options);
    
    /**
     * Set logging level
     * @param logLevel Android log level (Log.VERBOSE, Log.DEBUG, etc.)
     * @return GlideBuilder for chaining
     */
    @NonNull public GlideBuilder setLogLevel(int logLevel);
    
    /**
     * Set whether to log request origins for debugging
     * @param isEnabled true to enable request origin logging
     * @return GlideBuilder for chaining
     */
    @NonNull public GlideBuilder setLogRequestOrigins(boolean isEnabled);
    
    /**
     * Set image header parser registry
     * @param imageHeaderParsers Custom header parsers
     * @return GlideBuilder for chaining
     */
    @NonNull public GlideBuilder setImageDecoderEnabledForBitmaps(boolean isEnabled);
}

Configuration Examples:

@Override
public void applyOptions(Context context, GlideBuilder builder) {
    // Memory configuration
    int memoryCacheSizeBytes = (int) (Runtime.getRuntime().maxMemory() / 8);
    builder.setMemoryCache(new LruResourceCache(memoryCacheSizeBytes));
    
    // Disk cache configuration
    long diskCacheSizeBytes = 1024 * 1024 * 100; // 100 MB
    builder.setDiskCache(new InternalCacheDiskCacheFactory(context, diskCacheSizeBytes));
    
    // Bitmap pool configuration
    int bitmapPoolSizeBytes = memoryCacheSizeBytes / 2;
    builder.setBitmapPool(new LruBitmapPool(bitmapPoolSizeBytes));
    
    // Default request options
    RequestOptions requestOptions = new RequestOptions()
        .format(DecodeFormat.PREFER_RGB_565)
        .timeout(30000);
    builder.setDefaultRequestOptions(requestOptions);
    
    // Debugging
    builder.setLogLevel(Log.DEBUG)
           .setLogRequestOrigins(true);
}

Registry System

Component registry for registering custom loaders, decoders, encoders, and transformations.

/**
 * Registry for Glide components
 */
public class Registry {
    /**
     * Append model loader factory
     * @param modelClass Model class
     * @param dataClass Data class  
     * @param factory Loader factory
     * @return Registry for chaining
     */
    @NonNull public <Model, Data> Registry append(@NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass, @NonNull ModelLoaderFactory<Model, Data> factory);
    
    /**
     * Prepend model loader factory
     * @param modelClass Model class
     * @param dataClass Data class
     * @param factory Loader factory  
     * @return Registry for chaining
     */
    @NonNull public <Model, Data> Registry prepend(@NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass, @NonNull ModelLoaderFactory<Model, Data> factory);
    
    /**
     * Replace model loader factory
     * @param modelClass Model class
     * @param dataClass Data class
     * @param factory Loader factory
     * @return Registry for chaining
     */
    @NonNull public <Model, Data> Registry replace(@NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass, @NonNull ModelLoaderFactory<Model, Data> factory);
    
    /**
     * Register resource decoder
     * @param dataClass Input data class
     * @param resourceClass Output resource class
     * @param decoder Resource decoder
     * @return Registry for chaining
     */
    @NonNull public <Data, TResource> Registry register(@NonNull Class<Data> dataClass, @NonNull Class<TResource> resourceClass, @NonNull ResourceDecoder<Data, TResource> decoder);
    
    /**
     * Register resource encoder
     * @param resourceClass Resource class
     * @param encoder Resource encoder
     * @return Registry for chaining
     */
    @NonNull public <TResource> Registry register(@NonNull Class<TResource> resourceClass, @NonNull ResourceEncoder<TResource> encoder);
    
    /**
     * Register transformation
     * @param resourceClass Resource class
     * @param transformation Transformation implementation
     * @return Registry for chaining
     */
    @NonNull public <TResource> Registry register(@NonNull Class<TResource> resourceClass, @NonNull Transformation<TResource> transformation);
}

Registry Examples:

@Override
public void registerComponents(Context context, Glide glide, Registry registry) {
    // Custom model loader for special URL format
    registry.append(CustomUrl.class, InputStream.class, new CustomUrlLoader.Factory());
    
    // Custom decoder for special image format
    registry.register(InputStream.class, SpecialImage.class, new SpecialImageDecoder());
    
    // Custom encoder for special format
    registry.register(SpecialImage.class, new SpecialImageEncoder());
    
    // Custom transformation
    registry.register(Bitmap.class, new BlurTransformation());
    
    // Replace existing loader
    registry.replace(GlideUrl.class, InputStream.class, new MyHttpUrlLoader.Factory());
}

Custom Components

Interfaces for creating custom loaders, decoders, and encoders.

/**
 * Factory for creating model loaders
 */
public interface ModelLoaderFactory<T, Y> {
    /**
     * Build model loader instance
     * @param multiFactory Multi model loader factory
     * @return Model loader instance
     */
    @NonNull ModelLoader<T, Y> build(@NonNull MultiModelLoaderFactory multiFactory);
    
    /**
     * Cleanup resources
     */
    void teardown();
}

/**
 * Decoder for converting data to resources
 */
public interface ResourceDecoder<T, Z> {
    /**
     * Check if decoder can handle the data
     * @param source Data source
     * @param options Request options
     * @return true if can decode
     */
    boolean handles(@NonNull T source, @NonNull Options options) throws IOException;
    
    /**
     * Decode data to resource
     * @param source Data source
     * @param width Target width
     * @param height Target height
     * @param options Request options
     * @return Decoded resource
     */
    @Nullable Resource<Z> decode(@NonNull T source, int width, int height, @NonNull Options options) throws IOException;
}

/**
 * Encoder for persisting resources to disk
 */
public interface ResourceEncoder<T> {
    /**
     * Encode resource to file
     * @param data Resource to encode
     * @param file Output file
     * @param options Request options
     * @return true if successful
     */
    boolean encode(@NonNull Resource<T> data, @NonNull File file, @NonNull Options options);
    
    /**
     * Get encoding strategy
     * @param options Request options
     * @return Encoding strategy
     */
    @NonNull EncodeStrategy getEncodeStrategy(@NonNull Options options);
}

Types

// Component interfaces
public interface RegistersComponents {
    void registerComponents(@NonNull Context context, @NonNull Glide glide, @NonNull Registry registry);
}

// Encoding strategy
public enum EncodeStrategy {
    NONE, SOURCE, TRANSFORMED
}

// Generated module base class
public abstract class GeneratedAppGlideModule {
    // Generated by annotation processor
}

Install with Tessl CLI

npx tessl i tessl/maven-com-github-bumptech-glide--glide

docs

caching-strategies.md

error-handling-debugging.md

index.md

modules-configuration.md

request-configuration.md

request-management.md

targets-loading.md

transformations.md

transitions-animations.md

tile.json