Fixing Kotlin Debugger Not Hitting Breakpoints

Are you frustrated because your Kotlin debugger is not hitting breakpoints in Android Studio? This common issue can slow down development and make debugging a painful experience. In this article, we’ll walk you through the most common causes and provide actionable solutions to get your breakpoints working properly again.

Common Causes of Kotlin Debugger Issues

Before diving into the fixes, let’s review some of the most frequent reasons your debugger is not stopping at breakpoints:

• Code not being compiled or deployed correctly
• ProGuard or R8 optimization stripping out debug info
• Breakpoint placed on an unreachable or optimized-out line
• Gradle build settings preventing debugging
• Incorrect debugger configuration

Case Example: Breakpoint Ignored in Kotlin Function

Let’s take a simple case. You’ve written this Kotlin code in your Android app:

fun calculateSum(a: Int, b: Int): Int {
    val result = a + b  // Breakpoint here not being hit
    return result
}

You place a breakpoint at val result = a + b, but when running the app in debug mode, it simply skips over it. Why?

Solution 1: Clean and Rebuild Project

Sometimes, Android Studio uses outdated build artifacts. Follow these steps:

1. Go to Build > Clean Project
2. Then select Build > Rebuild Project

After rebuilding, restart your debug session. This often solves invisible breakpoints.

Solution 2: Ensure Debuggable Build Variant

Make sure you’re running a debug build and not a release build. Check your build.gradle file:

android {
    buildTypes {
        debug {
            debuggable true
        }
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

If you’re running a release build (with minification enabled), the debugger may not work as expected.

Solution 3: Disable Code Minification Temporarily

R8 or ProGuard may strip out debug information. Try disabling them:

minifyEnabled false
shrinkResources false

Then clean and rebuild the project again. This ensures all debug symbols are retained.

Solution 4: Check Breakpoint Validity

Breakpoints may not be valid if they’re placed on:

• Empty lines
• Braces or comments
• Inlined or optimized-out expressions

Try moving the breakpoint to a nearby line with actual logic execution.

Solution 5: Invalidate Caches

Corrupted IDE cache can cause strange behavior.

1. Go to File > Invalidate Caches / Restart…
2. Select Invalidate and Restart

Solution 6: Check .gradle and .idea Directories

Sometimes, deleting the .gradle and .idea folders and re-importing the project can fix inconsistencies.

Advanced: Set Debug Type to Kotlin-Specific

Ensure that your debugger is configured for Kotlin. Go to:

1. Run > Edit Configurations
2. Ensure the correct Debugger type is selected (preferably auto or Java/Kotlin)

Solution 7: Check for Multithreading / Coroutines

Breakpoints may not be hit in coroutine-based code if the thread context is different. Example:

GlobalScope.launch(Dispatchers.IO) {
    val sum = calculateSum(3, 5) // Breakpoint here may be skipped
    println(sum)
}

Use structured concurrency and keep logs to ensure the coroutine is running as expected. Consider adding a Thread.sleep or breakpoint in the UI thread for better results.

Debugging Kotlin Lambdas and Inline Functions

Kotlin inlines many functions and lambdas. If your breakpoint is in a lambda passed to an inline function, the debugger might not pause. Consider replacing inline functions with non-inline temporarily for debug purposes.

Final Words

Debugging in Kotlin is powerful, but it can sometimes be tricky due to compiler optimizations, build configuration, and coroutine behavior. The steps above will help you identify and fix the “debugger not hitting breakpoints” issue effectively.

External Resource

Read more: Official Android Debugging Guide