Glide

private fun loadImage() {
    //default load source as Drawable
    Glide.with(this) //pass Context - returns RequestBuilder
        .load(url) //pass url, file, drawable object, local resource etc
        //set some RequestListener if needed
        .into(imageView) //tell where to load image
}

private fun loadImageIntoBitmapTarget() {
    val target = object: CustomTarget<Bitmap>() {
        override fun onResourceReady(resource: Bitmap, transition: Transition<in Bitmap>?) {
            val bitmap = resource
            //do something with downloaded bitmap
        }
        override fun onLoadCleared(placeholder: Drawable?) {
            //action when loading canceled
        }
        //implement other callback methods like onLoadStarted, onLoadFailed
    }

    //could be: asDrawable, asBitmap, asFile, asGif
    Glide.with(this).asBitmap().load(url).into(target)
}

private fun clearData() {
    //manual loading data clear
    Glide.with(this).clear(imageView) //or pass target
}

private fun loadWithPlaceholders() {
    Glide.with(this).load(url)
        .placeholder(R.drawable.placeholder) //main placeholder
        .error(R.drawable.placeholder_error) //placeholder when request permanently fails
        .fallback(R.drawable.placeholder_fallback) //placeholder when requested model is null
        .into(imageView)
}

private fun loadWithThumbnail() {
    Glide.with(this).load(url)
        .thumbnail(Glide.with(this).load(url_miniature))
        .into(imageView)
}

private fun loadImageCustom() {
    //load image with some custom modifications
    Glide.with(this).load(url)
        .centerCrop() //apply some transforms
        .transition(withCrossFade())
        .diskCacheStrategy(DiskCacheStrategy.AUTOMATIC)
        .into(imageView)
}

private fun loadImageCustomOptions() {
    //TransitionOptions are tied with specific type like DrawableTransitionOptions
    val transitionOptions = DrawableTransitionOptions()
        .crossFade()

    //create RequestOptions and reuse it
    val requestOptions = RequestOptions()
        .centerCrop()
        .diskCacheStrategy(DiskCacheStrategy.AUTOMATIC)
        //add more transforms

    Glide.with(this).load(url)
        .transition(transitionOptions)
        .apply(requestOptions).into(imageView)
}

private fun loadImageMultipleTransforms() {
    Glide.with(this).load(url)
        .transform(FitCenter(), Rotate(90))
        .into(imageView)
}

private fun loadImageWithCustomSignature() {
    Glide.with(this).load(url)
        .signature(ObjectKey("version")) //custom metadata if possible like last modified time
        .into(imageView)
}
	
private fun loadAndSaveImageBySomeStrategy() {
    Glide.with(this).load(url)
        .diskCacheStrategy(DiskCacheStrategy.AUTOMATIC) //is default
        .into(imageView)

    /* use one of DiskStrategyCache:
    AUTOMATIC - optimal strategy based on data source
    DATA - stores original retrieved data in disk cache
    RESOURCE - stores data in disk cache after decoding
    ALL - remote data with both DATA and RESOURCE, local data only with RESOURCE
    NONE - saves no data to disk cache */
}

private fun loadImageOnylIfExistsInCache() {
    Glide.with(this).load(url)
        .onlyRetrieveFromCache(true)
        .into(imageView)
	
    //if image doesn't exists in memory or disk cache then load fail
}

private fun loadImageSkippingCache() {
    Glide.with(this).load(url)
        .skipMemoryCache(true)
        .into(imageView)
	
    //skip memory cache
}

@GlideModule
class CustomAppGlideModule : AppGlideModule() {

    //this will apply as global settings
    override fun applyOptions(context: Context, builder: GlideBuilder) {
        //create custom options
        val requestOptions = RequestOptions()
            .circleCrop()
            .diskCacheStrategy(DiskCacheStrategy.DATA)

        val transitionOptions = DrawableTransitionOptions()
            .crossFade()

        //set custom memory size
        val customMemoryCacheSize = (MemorySizeCalculator.Builder(context)
            .build().memoryCacheSize * 1.1).toLong()

        //apply some custom settings
        builder
            .setDefaultRequestOptions(requestOptions)
            .setDefaultTransitionOptions(Drawable::class.java, transitionOptions)
            .setLogLevel(Log.ERROR)
            .setMemoryCache(LruResourceCache(customMemoryCacheSize))
    }

    //body can be also empty
}

@GlideExtension
object CustomGlideExtension {
    
    //class with private constructor and static annotated methods

    @GlideOption
    @JvmStatic
    fun smallCircle(options: BaseRequestOptions<*>): BaseRequestOptions<*> {
        return options.circleCrop().override(100)
    }

    //more @GlideOption and @GlideType methods
}

private fun loadImageByCustomModule() {
    //will draw circle crop 100px image with cross fade transition and custom log and cache settings
    GlideApp.with(this).load(url)
        .smallCircle() //new custom option
        .into(imageView)
}

//usage of RecyclerViewPreloader in RecyclerView
class RecyclerViewActivity : AppCompatActivity() {

    private lateinit var recyclerView: RecyclerView
    private lateinit var preloader: RecyclerViewPreloader<Any>
    private val urls = listOf("url1", "url2", "url3") //mock some url

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_recyclerView)

        initPreloader()
        initRecyclerView()
    }

    private fun initPreloader() {
        val size = 100
        val maxPreload = 10
        val sizeProvider: ListPreloader.PreloadSizeProvider<Any> = FixedPreloadSizeProvider(size, size)
        val modelProvider = CustomPreloadModelProvider(urls, this) //own implementation of PreloadModelProvider
        preloader = RecyclerViewPreloader(this, modelProvider, sizeProvider, maxPreload)
    }

    private fun initRecyclerView() {
        recyclerView = findViewById(R.id.recyclerView)
        recyclerView.apply {
            layoutManager = LinearLayoutManager(this@MainActivity)
            adapter = CustomAdapter(urls, this@MainActivity)
            addOnScrollListener(preloader) //set RecyclerViewPreloader as scroll listener
        }
    }
}

//implement PreloadModelProvider
class CustomPreloadModelProvider(val urls: List<String>, val context: Context) : ListPreloader.PreloadModelProvider<Any> {

    override fun getPreloadItems(position: Int): MutableList<Any> {
        val url = urls[position]
        if (TextUtils.isEmpty(url)) {
            return Collections.emptyList()
        }
        return Collections.singletonList(url)
    }

    override fun getPreloadRequestBuilder(item: Any): RequestBuilder<*>? {
        return GlideApp.with(context).load(item)
    }
}

//just simple adapter
class CustomAdapter(val urls: List<String>, val context: Context) : RecyclerView.Adapter<CustomAdapter.CustomViewHolder>() {

    class CustomViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        val imageView: ImageView
        init {
            imageView = view.findViewById(R.id.imageView)
        }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): CustomViewHolder {
        val view = LayoutInflater.from(parent.context).inflate(R.layout.item_layout, parent, false)
        return CustomViewHolder(view)
    }

    override fun onBindViewHolder(holder: CustomViewHolder, position: Int) {
        //set some data on item
        GlideApp.with(context).load(urls[position]).into(holder.imageView) //standard Glide loading
    }

    override fun getItemCount(): Int = urls.size
}