Can you tell about any design patterns related to the…

The "Builder" pattern is often used to create complex objects step-by-step, separating the construction process from its representation. In Android, it is frequently combined with other patterns.

Builder with Factory: A factory can use a Builder to create instances of objects.

// Example: Factory using Builder to create AlertDialog
public class DialogFactory {
    public AlertDialog createCustomDialog(Context context, String title, String message) {
        AlertDialog.Builder builder = new AlertDialog.Builder(context);
        builder.setTitle(title);
        builder.setMessage(message);
        // Additional builder settings...
        return builder.create();
    }
}

Builder with Singleton: A Builder can be used to configure a singleton during its first creation.

// Example: Singleton with configuration via Builder
public class AppConfig {
    private static AppConfig instance;
    private String apiUrl;

    private AppConfig(Builder builder) {
        this.apiUrl = builder.apiUrl;
    }

    public static AppConfig getInstance() {
        if (instance == null) {
            // Usually initialized here, possibly via Builder,
            // although Builder is often used for non-singleton objects.
            // This example demonstrates the possibility
            // of shared usage, not typical application.
            throw new IllegalStateException("AppConfig not initialized. Use init() first.");
        }
        return instance;
    }

    public static void init(Builder builder) {
        if (instance != null) {
            throw new IllegalStateException("AppConfig already initialized.");
        }
        instance = new AppConfig(builder);
    }

    public String getApiUrl() {
        return apiUrl;
    }

    public static class Builder {
        private String apiUrl;

        public Builder setApiUrl(String apiUrl) {
            this.apiUrl = apiUrl;
            return this;
        }

        public AppConfig build() {
            return new AppConfig(this);
        }
    }
}

(Note: More typical use of Builder with Singleton might be if the Singleton itself is a builder or constructs some internal structure)

Builder with Adapter: Builder can be used to create complex data elements that are then passed to an adapter (e.g., for RecyclerView).
Builder in the context of Dependency Injection: A service or component can be configured using a Builder before being injected.
Builder as Director: Although the pure "Builder" pattern includes a Director that manages the construction process, in Android, often the client code or another part of the application acts as the Director, calling builder methods to step-by-step create an object.

In Android, Builder is most often used to create instances of classes that have many options or parameters, such as AlertDialog.Builder, NotificationCompat.Builder, OkHttpClient.Builder, Retrofit.Builder, ConstraintSet.Builder, and others, where sequential calls to set*() or add*() configure the object before its final creation with build(). This improves code readability compared to constructors with many parameters and makes it easy to add new options without changing existing constructors.

Can you tell about any design patterns related to the 'builder' pattern in Android?