Memory Management & GC on Android

Copy code┌─────────────────────────────────────────────────────────────┐
│                          ART Heap                           │
├──────────────────────┬──────────────────────────────────────┤
│    Young Generation  │          Old Generation              │
│  (Allocation space)  │   (Tenured / Large object space)     │
│  Most new objects    │   Long-lived objects; large arrays   │
│  allocated here      │   (> ~12 KB) go directly here       │
└──────────────────────┴──────────────────────────────────────┘

Copy codeFrame timeline with GC pause:
│───── 16 ms budget ─────│
│ measure │ layout │ draw │← normal
│── GC pause (10ms) ──│ d │← jank: frame dropped

Copy code// Typical OOM stack trace:
// java.lang.OutOfMemoryError: Failed to allocate a 8294400 byte allocation
//   with 6291456 free bytes and 6MB until OOM, target footprint 201326592,
//   growth limit 201326592

// Check available heap at runtime:
val runtime = Runtime.getRuntime()
val maxMemory = runtime.maxMemory()         // hard limit
val totalMemory = runtime.totalMemory()     // current heap size
val freeMemory = runtime.freeMemory()       // free in current heap
val usedMemory = totalMemory - freeMemory

// Safe image loading check:
fun canLoadBitmap(width: Int, height: Int): Boolean {
    val needed = width.toLong() * height * 4 // ARGB_8888
    val available = runtime.maxMemory() - (totalMemory - freeMemory)
    return needed < available * 0.8 // keep 20% headroom
}

Copy codeoverride fun onTrimMemory(level: Int) {
    when (level) {
        // Still running (foreground)
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE -> trimThumbnailCache()
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW -> trimAllCaches()
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL -> dropEverything()

        // Backgrounded
        ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN -> releaseBitmapCache()
        ComponentCallbacks2.TRIM_MEMORY_BACKGROUND -> releaseSmallCaches()
        ComponentCallbacks2.TRIM_MEMORY_MODERATE -> releaseMostCaches()
        ComponentCallbacks2.TRIM_MEMORY_COMPLETE -> releaseAllCaches()
    }
}

Copy code// BAD: allocates a new Paint and RectF on every draw call (60x/sec!)
override fun onDraw(canvas: Canvas) {
    val paint = Paint().apply { color = Color.RED }
    canvas.drawRect(RectF(0f, 0f, width.toFloat(), height.toFloat()), paint)
}

// GOOD: allocate once in init
private val paint = Paint().apply { color = Color.RED }
private val rect = RectF()

override fun onDraw(canvas: Canvas) {
    rect.set(0f, 0f, width.toFloat(), height.toFloat())
    canvas.drawRect(rect, paint)
}

Copy code// Kotlin stdlib Pools (from AndroidX):
import androidx.core.util.Pools

class MotionEventPool {
    private val pool = Pools.SynchronizedPool<MotionEvent>(10)

    fun obtain(): MotionEvent = pool.acquire() ?: MotionEvent.obtain(...)

    fun recycle(event: MotionEvent) {
        pool.release(event)
    }
}

Copy code// BAD for large data sets: each Int is boxed to Integer object (16 bytes each)
val scores: List<Int> = List(100_000) { it }

// GOOD: primitive array, 4 bytes each, no GC overhead
val scores: IntArray = IntArray(100_000) { it }

Copy code// BAD: creates N intermediate String objects
var result = ""
for (item in items) {
    result += item.name + ", "
}

// GOOD: single StringBuilder, one final String allocation
val result = buildString {
    for (item in items) {
        append(item.name)
        append(", ")
    }
}

Copy code// BAD: HashMap boxes Int keys to Integer
val map = HashMap<Int, String>()

// GOOD: SparseArray uses primitive int keys
val map = SparseArray<String>()
map.put(42, "hello")
val value = map.get(42)

Copy codeclass ImageLoader {
    private val listeners = mutableListOf<WeakReference<LoadListener>>()

    fun addListener(listener: LoadListener) {
        listeners.add(WeakReference(listener))
    }

    private fun notifyListeners(bitmap: Bitmap) {
        val iter = listeners.iterator()
        while (iter.hasNext()) {
            val ref = iter.next().get()
            if (ref == null) {
                iter.remove() // Clean up dead references
            } else {
                ref.onLoaded(bitmap)
            }
        }
    }
}

Copy code// LeakCanary (Square) — add to debugImplementation only:
// debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.x'
// No code changes needed — it hooks into Activity/Fragment lifecycle automatically.

Copy code# Record allocations over 5 seconds with Perfetto:
adb shell perfetto \
  -c - --txt \
  -o /data/misc/perfetto-traces/trace \
<<EOF
buffers: { size_kb: 63488 fill_policy: DISCARD }
data_sources: { config { name: "android.heapprofd"
  heapprofd_config { pid: <YOUR_PID> sampling_interval_bytes: 4096 } } }
duration_ms: 5000
EOF
adb pull /data/misc/perfetto-traces/trace ~/Desktop/heap.perfetto
# Open in ui.perfetto.dev

Copy codeval cacheSize = (Runtime.getRuntime().maxMemory() / 1024 / 8).toInt() // 1/8 of max heap
val cache = object : LruCache<String, Bitmap>(cacheSize) {
    override fun sizeOf(key: String, value: Bitmap): Int = value.byteCount / 1024
}