Handling Images

<ImageView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:src="@drawable/profile_image"
    android:scaleType=&quot:centerCrop"
/>

<ImageView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:src="@drawable/my_image" />

<ImageView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@drawable/my_background" />

import com.bumptech.glide.Glide

val imageView = findViewById<ImageView>(R.id.imageView)
val imageUri = "https://example.com/image.jpg"

Glide.with(this)
    .load(imageUri)
    .placeholder(R.drawable.placeholder)
    .error(R.drawable.error_image)
    .into(imageView)

import coil.load

val imageView = findViewById<ImageView>(R.id.imageView)
val imageUri = "https://example.com/image.jpg"

imageView.loadImage(imageUri) {
    placeholder(R.drawable.placeholder)
    error(R.drawable.error_image)
}

val bitmap = BitmapFactory.decodeFile("/sdcard/image.jpg")

val bitmap = BitmapFactory.decodeResource(resources, R.drawable.image)

val inputStream = FileInputStream("image.png")
val bitmap = BitmapFactory.decodeStream(inputStream)
inputStream.close()

val byteArray = File("image.jpg").readBytes()
val bitmap = BitmapFactory.decodeByteArray(byteArray, 0, byteArray.size)

val options = BitmapFactory.Options().apply {
    inJustDecodeBounds = true
    BitmapFactory.decodeResource(resources, R.drawable.image, this)
    val imageWidth = outWidth
    val imageHeight = outHeight

    inJustDecodeBounds = false
    inSampleSize = calculateInSampleSize(options, 1024, 1024)
    BitmapFactory.decodeResource(resources, R.drawable.image, this)
}

fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {
    val height = options.outHeight
    val width = options.outWidth
    var inSampleSize = 1

    if (height > reqHeight || width > reqWidth) {
        val halfHeight = height / 2
        val halfWidth = width / 2

        while (halfHeight / inSampleSize >= reqHeight &&
               halfWidth / inSampleSize >= reqWidth) {
            inSampleSize *= 2
        }
    }
    return inSampleSize
}

val bitmap = BitmapFactory.decodeResource(
    context.resources,
    R.drawable.sample_image
)

val bitmap = Bitmap.createBitmap(
    200,
    200,
    Bitmap.Config.ARGB_8888
)

class DrawingView(context: Context) : View(context) {
    private val paint = Paint().apply {
        color = Color.BLUE
        strokeWidth = 5f
        style = Paint.Style.STROKE
    }

    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        canvas.drawLine(100f, 100f, 300f, 300f, paint)
        canvas.drawCircle(200f, 200f, 50f, paint)
    }
}

val shader = LinearGradient(
    0f, 0f, 100f, 100f,
    Color.RED, Color.BLUE,
    Shader.TileMode.CLAMP
)
val paint = Paint().apply {
    shader = shader
    style = Paint.Style.FILL
}

canvas.drawRect(0f, 0f, 100f, 100f, paint)

val bitmap = BitmapFactory.decodeResource(
    resources, R.drawable.sample_image
)
canvas.drawBitmap(bitmap, 0f, 0f, null)

<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:name="vector_drawable"
    android:width="24dp"
    android:height="24dp"
    android:viewportWidth="24"
    android:viewportHeight="24">
  <path
      android:name="path"
      android:pathData="M12,2L2,7L2,17L12,22L22,17L22,7L12,2Z"
      android:fillColor="#FF0000"/>
</vector>

<ImageView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:src="@drawable/vector_drawable"/>

fun decodeSampledBitmapFromResource(
    res: Resources,
    resId: Int,
    reqWidth: Int,
    reqHeight: Int
): Bitmap {
    // First decode with inJustDecodeBounds=true to check dimensions
    val options = BitmapFactory.Options().apply {
        inJustDecodeBounds = true
    }
    BitmapFactory.decodeResource(res, resId, options)

    // Calculate inSampleSize
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight)

    // Decode bitmap with inSampleSize set
    options.inJustDecodeBounds = false
    return BitmapFactory.decodeResource(res, resId, options)
}

fun calculateInSampleSize(
    options: BitmapFactory.Options,
    reqWidth: Int,
    reqHeight: Int
): Int {
    val height = options.outHeight
    val width = options.outWidth
    var inSampleSize = 1

    if (height > reqHeight || width > reqWidth) {
        val halfHeight = height / 2
        val halfWidth = width / 2

        while ((halfHeight / inSampleSize) >= reqHeight &&
               (halfWidth / inSampleSize) >= reqWidth) {
            inSampleSize *= 2
        }
    }
    return inSampleSize
}

class BitmapLruCache : LruCache<String, Bitmap>(maxSize()) {
    companion object {
        private fun maxSize(): Int = (Runtime.getRuntime().maxMemory() / 8).toInt()
    }

    override fun sizeOf(key: String, bitmap: Bitmap): Int = bitmap.byteCount
}

val cache = BitmapLruCache()

fun getBitmapFromCache(key: String): Bitmap? = cache.get(key)

fun addBitmapToCache(key: String, bitmap: Bitmap) {
    if (getBitmapFromCache(key) == null) {
        cache.put(key, bitmap)
    }
}

import coil.compose.AsyncImage
import androidx.compose.runtime.Composable

@Composable
fun ImageLoader() {
    AsyncImage(
        model = "https://example.com/image.jpg",
        contentDescription = "Example Image"
    )
}

import coil.compose.AsyncImage
import androidx.compose.runtime.Composable

@Composable
fun ImageWithFallback() {
    AsyncImage(
        model = "https://example.com/image.jpg",
        contentDescription = "Example Image",
        placeholder = rememberAsyncImagePainter("https://example.com/placeholder.jpg"),
        error = rememberAsyncImagePainter("https://example.com/error.png")
    )
}