First things first, let's add Glide to your project's dependencies. Open up your build.gradle file (you'll usually find it at the root level of the app module) and pop this in:

dependencies {
    implementation 'com.github.bumptech.glide:glide:4.12.0'
    annotationProcessor 'com.github.bumptech.glide:compiler:4.12.0'
}

Next, head over to your java directory and create a custom Glide module class. This will make sure Glide uses your new API endpoint:

@GlideModule
public final class MyAppGlideModule extends AppGlideModule {
    @Override
    public void applyOptions(@NonNull Context context, @NonNull GlideBuilder builder) {
        builder.setDefaultRequestOptions(
            new RequestOptions().placeholder(R.drawable.placeholder)
                                 .error(R.drawable.error_image)
        );
    }

    @Override
    public void registerComponents(@NonNull Context context, @NonNull Glide glide, @NonNull Registry registry) {
        // Register custom ModelLoader here
        registry.append(String.class, InputStream.class, new CustomUrlLoader.Factory());
    }

    @Override
    public boolean isManifestParsingEnabled() {
        return false;
    }
}

To use your custom API endpoint, you'll need to create a custom model loader. Implement ModelLoader and ModelLoaderFactory.

Create CustomUrlLoader.java:

public class CustomUrlLoader implements ModelLoader<String, InputStream> {
    
    @Override
    public boolean handles(@NonNull String url) {
        return url.startsWith("http");
    }

    @Nullable
    @Override
    public LoadData<InputStream> buildLoadData(@NonNull String model, int width, int height, @NonNull Options options) {
        return new LoadData<>(new ObjectKey(model), new CustomUrlLoaderFetcher(model));
    }

    public static class Factory implements ModelLoaderFactory<String, InputStream> {
        
        @NonNull
        @Override
        public ModelLoader<String, InputStream> build(@NonNull MultiModelLoaderFactory multiFactory) {
            return new CustomUrlLoader();
        }

        @Override
        public void teardown() {
            // Do nothing
        }
    }
}

Now, let's create CustomUrlLoaderFetcher.java to fetch data from your custom API endpoint:

public class CustomUrlLoaderFetcher implements DataFetcher<InputStream> {
    private final String url;
    private InputStream stream;

    public CustomUrlLoaderFetcher(String url) {
        this.url = url;
    }

    @Override
    public void loadData(@NonNull Priority priority, @NonNull DataCallback<? super InputStream> callback) {
        try {
            // Use your library for HTTP requests here
            URL apiUrl = new URL(url);
            HttpURLConnection connection = (HttpURLConnection) apiUrl.openConnection();
            stream = connection.getInputStream();
            callback.onDataReady(stream);
        } catch (Exception e) {
            callback.onLoadFailed(e);
        }
    }

    @Override
    public void cleanup() {
        if (stream != null) {
            try {
                stream.close();
            } catch (IOException ignored) {}
        }
    }

    @Override
    public void cancel() {
        // Implement cancellation logic if needed
    }

    @NonNull
    @Override
    public Class<InputStream> getDataClass() {
        return InputStream.class;
    }

    @NonNull
    @Override
    public DataSource getDataSource() {
        return DataSource.REMOTE;
    }
}

Finally, use Glide in your activities or fragments just like you normally would. Glide will now use your custom API endpoint for loading images:

GlideApp.with(this)
        .load("http://custom.api/endpoint/image.jpg")
        .into(imageView);

And there you have it! This setup lets Glide fetch images using your custom API endpoint, giving you all the flexibility you need for custom data handling.