Implement recomposition time profiling (#151)

Author: skydoves

compose-stability-analyzer-idea/build.gradle.kts

@@ -26,7 +26,7 @@ kotlin {
 }
 
 group = "com.github.skydoves"
-version = "0.7.3"
+version = "0.7.4-SNAPSHOT"
 
 repositories {
   mavenLocal()

compose-stability-analyzer-idea/src/main/kotlin/com/skydoves/compose/stability/idea/heatmap/AdbLogcatService.kt

@@ -190,6 +190,9 @@ internal class AdbLogcatService(
     )
 
     val maxRecent = settings.heatmapMaxRecentEvents
+    val paramChanges = buildParameterChangeLines(event)
+    val stateChanges = event.stateEntries.map { "[state] $it" }
+
     dataMap.compute(event.composableName) { _, existing ->
       if (existing == null) {
         ComposableHeatmapData(
@@ -202,27 +205,63 @@ internal class AdbLogcatService(
             .filter { it.status == ParameterStatus.CHANGED }
             .associate { it.name to 1 },
           unstableParameters = event.unstableParameters.toSet(),
+          lastDurationMs = event.durationMs,
+          totalDurationMs = event.durationMs,
+          lastParameterChanges = paramChanges,
+          lastStateChanges = stateChanges,
         )
       } else {
-        val mergedChanged = existing.changedParameters.toMutableMap()
+        val mergedChanged =
+          existing.changedParameters.toMutableMap()
         event.parameterEntries
           .filter { it.status == ParameterStatus.CHANGED }
-          .forEach { mergedChanged[it.name] = (mergedChanged[it.name] ?: 0) + 1 }
+          .forEach {
+            mergedChanged[it.name] =
+              (mergedChanged[it.name] ?: 0) + 1
+          }
 
-        val recentCapped = (existing.recentEvents + event).takeLast(maxRecent)
+        val recentCapped =
+          (existing.recentEvents + event).takeLast(maxRecent)
 
         existing.copy(
-          totalRecompositionCount = existing.totalRecompositionCount + 1,
-          maxSingleCount = maxOf(existing.maxSingleCount, event.recompositionCount),
+          totalRecompositionCount =
+            existing.totalRecompositionCount + 1,
+          maxSingleCount = maxOf(
+            existing.maxSingleCount,
+            event.recompositionCount,
+          ),
           recentEvents = recentCapped,
           lastSeenTimestampMs = event.timestampMs,
           changedParameters = mergedChanged,
-          unstableParameters = existing.unstableParameters + event.unstableParameters,
+          unstableParameters =
+            existing.unstableParameters + event.unstableParameters,
+          lastDurationMs = event.durationMs,
+          totalDurationMs =
+            existing.totalDurationMs + event.durationMs,
+          lastParameterChanges = paramChanges,
+          lastStateChanges = stateChanges,
         )
       }
     }
   }
 
+  /**
+   * Format parameter entries into readable lines for tooltip
+   * display (e.g. `[param] user: User changed (User@abc)`).
+   */
+  private fun buildParameterChangeLines(
+    event: ParsedRecompositionEvent,
+  ): List<String> {
+    return event.parameterEntries.map { entry ->
+      val detail = if (entry.detail.isNotEmpty()) {
+        " (${entry.detail})"
+      } else {
+        ""
+      }
+      "[param] ${entry.name}: ${entry.type} ${entry.status.name.lowercase()}$detail"
+    }
+  }
+
   // ── ADB helpers ────────────────────────────────────────────────────────
 
   private fun resolveAdbPath(): String? {

compose-stability-analyzer-idea/src/main/kotlin/com/skydoves/compose/stability/idea/heatmap/HeatmapInlayManager.kt

@@ -15,6 +15,8 @@
  */
 package com.skydoves.compose.stability.idea.heatmap
 
+import com.intellij.ide.IdeTooltip
+import com.intellij.ide.IdeTooltipManager
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.ModalityState
@@ -78,7 +80,7 @@ internal class HeatmapInlayManager(
   private var refreshTask: ScheduledFuture<*>? = null
 
   @Volatile
-  private var clickListenerRegistered = false
+  private var listenersRegistered = false
 
   /**
    * Mouse listener that detects clicks on heatmap block inlays
@@ -105,11 +107,59 @@ internal class HeatmapInlayManager(
     }
   }
 
+  /** Tracks the inlay currently showing a tooltip. */
+  private var activeTooltipInlay: Inlay<*>? = null
+
+  /**
+   * Mouse motion listener that shows a tooltip when the cursor
+   * hovers over a heatmap block inlay. Uses [IdeTooltipManager]
+   * which handles positioning automatically.
+   */
+  private val hoverListener =
+    object : com.intellij.openapi.editor.event.EditorMouseMotionListener {
+      override fun mouseMoved(event: EditorMouseEvent) {
+        val editor = event.editor
+        if (editor.project != project) return
+        val key = System.identityHashCode(editor)
+        val entries = editorState[key] ?: return
+        val pt = event.mouseEvent.point
+
+        for ((name, entry) in entries) {
+          if (!entry.inlay.isValid) continue
+          val b = entry.inlay.bounds ?: continue
+          if (!b.contains(pt)) continue
+          if (activeTooltipInlay == entry.inlay) return
+          activeTooltipInlay = entry.inlay
+          val renderer =
+            entry.inlay.renderer as? HeatmapBlockRenderer
+              ?: return
+          val html = renderer.tooltipHtml
+          if (html.isEmpty()) return
+          val label = javax.swing.JLabel(html).apply {
+            border = JBUI.Borders.empty(4, 8)
+          }
+          val tip = IdeTooltip(
+            editor.contentComponent,
+            pt,
+            label,
+          )
+          IdeTooltipManager.getInstance().show(tip, true)
+          return
+        }
+        activeTooltipInlay = null
+      }
+    }
+
   fun start() {
-    if (!clickListenerRegistered) {
-      clickListenerRegistered = true
-      EditorFactory.getInstance().eventMulticaster
-        .addEditorMouseListener(clickListener, this)
+    if (!listenersRegistered) {
+      listenersRegistered = true
+      val multicaster =
+        EditorFactory.getInstance().eventMulticaster
+      multicaster.addEditorMouseListener(clickListener, this)
+      multicaster.addEditorMouseMotionListener(
+        hoverListener,
+        this,
+      )
     }
 
     refreshTask = com.intellij.util.concurrency.AppExecutorUtil
@@ -137,7 +187,11 @@ internal class HeatmapInlayManager(
     refreshTask?.cancel(false)
     refreshTask = null
     ApplicationManager.getApplication().invokeLater(
-      { clearAllInlays() },
+      {
+        if (!project.isDisposed) {
+          clearAllInlays()
+        }
+      },
       ModalityState.any(),
     )
   }
@@ -212,7 +266,9 @@ internal class HeatmapInlayManager(
 
       val data = service.getHeatmapData(name) ?: continue
       val color = severityColor(data.totalRecompositionCount)
-      val renderer = HeatmapBlockRenderer(newText, color, editor)
+      val tooltip = buildTooltipHtml(data)
+      val renderer =
+        HeatmapBlockRenderer(newText, color, editor, tooltip)
       val inlay = editor.inlayModel.addBlockElement(
         offset,
         true, // relatesToPrecedingText
@@ -275,6 +331,7 @@ internal class HeatmapInlayManager(
     private val text: String,
     private val color: Color,
     editor: Editor,
+    val tooltipHtml: String = "",
   ) : EditorCustomElementRenderer {
 
     // Pre-compute the background color once at creation time
@@ -320,6 +377,65 @@ internal class HeatmapInlayManager(
     }
   }
 
+  /**
+   * Builds an HTML tooltip string summarising the most recent
+   * recomposition event and cumulative totals.
+   */
+  private fun buildTooltipHtml(
+    data: ComposableHeatmapData,
+  ): String {
+    return buildString {
+      append("<html><body style='font-size:11px'>")
+      append("<b>Last Recomposition (#")
+      append(data.totalRecompositionCount)
+      append(")</b>")
+      if (data.lastDurationMs > 0) {
+        append(" &mdash; ")
+        append("%.2f".format(data.lastDurationMs))
+        append("ms")
+      }
+      append("<br>")
+
+      if (data.lastParameterChanges.isNotEmpty()) {
+        data.lastParameterChanges.forEach { line ->
+          append(escapeHtml(line))
+          append("<br>")
+        }
+      }
+
+      if (data.lastStateChanges.isNotEmpty()) {
+        data.lastStateChanges.forEach { line ->
+          append(escapeHtml(line))
+          append("<br>")
+        }
+      }
+
+      if (data.unstableParameters.isNotEmpty()) {
+        append("Unstable: ")
+        append(escapeHtml(data.unstableParameters.toString()))
+        append("<br>")
+      }
+
+      append("<br><i>Total: ")
+      append(data.totalRecompositionCount)
+      append(" recomposition")
+      if (data.totalRecompositionCount != 1) append("s")
+      if (data.totalDurationMs > 0) {
+        append(", ")
+        append("%.1f".format(data.totalDurationMs))
+        append("ms cumulative")
+      }
+      append("</i></body></html>")
+    }
+  }
+
+  private fun escapeHtml(text: String): String {
+    return text
+      .replace("&", "&amp;")
+      .replace("<", "&lt;")
+      .replace(">", "&gt;")
+  }
+
   /**
    * Opens the Heatmap tab in the tool window and displays
    * recomposition data for the given composable.

compose-stability-analyzer-idea/src/main/kotlin/com/skydoves/compose/stability/idea/heatmap/LogcatParser.kt

@@ -24,30 +24,58 @@ package com.skydoves.compose.stability.idea.heatmap
  *
  * Expected format:
  * ```
- * [Recomposition #3] UserProfile (tag: user-screen)
- *   ├─ user: User changed (User@abc123 → User@def456)
- *   ├─ count: Int stable (42)
+ * [Recomposition #3] UserProfile (tag: user-screen) (2.30ms)
+ *   ├─ [param] user: User changed (User@abc123 → User@def456)
+ *   ├─ [param] count: Int stable (42)
+ *   ├─ [state] counter: Int changed (5 → 6)
  *   └─ Unstable parameters: [user]
  * ```
+ *
+ * Also supports the legacy format without `[param]`/`[state]` prefixes
+ * and without duration.
  */
 internal class LogcatParser(
   private val onEvent: (ParsedRecompositionEvent) -> Unit,
 ) {
 
   private companion object {
+    /** Header: `[Recomposition #N] Name (tag: t) (2.30ms)` */
     val HEADER_REGEX =
-      """\[Recomposition #(\d+)] (\S+)(?:\s+\(tag:\s+(.+?)\))?""".toRegex()
+      """\[Recomposition #(\d+)] (\S+)(?:\s+\(tag:\s+(.+?)\))?(?:\s+\((\d+\.?\d*)ms\))?"""
+        .toRegex()
+
+    /**
+     * Parameter line with optional `[param]` prefix:
+     *   `├─ [param] user: User changed (User@abc → User@def)`
+     *   `├─ user: User changed (User@abc → User@def)`
+     */
     val PARAM_REGEX =
-      """\s*[├└]─\s+(\w+):\s+(.+?)\s+(changed|stable|unstable)(?:\s+\((.+)\))?""".toRegex()
+      ("""\s*[├└]─\s+(?:\[param]\s+)?""" +
+        """(\w+):\s+(.+?)\s+(changed|stable|unstable)""" +
+        """(?:\s+\((.+)\))?""").toRegex()
+
+    /**
+     * State change line:
+     *   `├─ [state] counter: Int changed (5 → 6)`
+     */
+    val STATE_REGEX =
+      """\s*[├└]─\s+\[state]\s+(.+)"""
+        .toRegex()
+
     val UNSTABLE_SUMMARY_REGEX =
       """\s*[├└]─\s+Unstable parameters:\s+\[(.+)]""".toRegex()
+
+    val STATE_SUMMARY_REGEX =
+      """\s*[├└]─\s+State changes:\s+\[(.+)]""".toRegex()
   }
 
   private var currentName: String? = null
   private var currentTag: String = ""
   private var currentCount: Int = 0
+  private var currentDurationMs: Double = 0.0
   private var currentParams: MutableList<ParsedParameterEntry> = mutableListOf()
   private var currentUnstable: MutableList<String> = mutableListOf()
+  private var currentStateEntries: MutableList<String> = mutableListOf()
 
   /**
    * Feed a single logcat message line (after stripping the `D/Recomposition: ` prefix).
@@ -56,11 +84,15 @@ internal class LogcatParser(
     val headerMatch = HEADER_REGEX.find(line)
     if (headerMatch != null) {
       emitCurrent()
-      currentCount = headerMatch.groupValues[1].toIntOrNull() ?: 0
+      currentCount =
+        headerMatch.groupValues[1].toIntOrNull() ?: 0
       currentName = headerMatch.groupValues[2]
       currentTag = headerMatch.groupValues[3]
+      currentDurationMs =
+        headerMatch.groupValues[4].toDoubleOrNull() ?: 0.0
       currentParams = mutableListOf()
       currentUnstable = mutableListOf()
+      currentStateEntries = mutableListOf()
       return
     }
 
@@ -76,6 +108,16 @@ internal class LogcatParser(
       return
     }
 
+    // Skip state summary lines (not individual state entries)
+    if (STATE_SUMMARY_REGEX.find(line) != null) return
+
+    // [state] lines: capture the raw detail text
+    val stateMatch = STATE_REGEX.find(line)
+    if (stateMatch != null) {
+      currentStateEntries.add(stateMatch.groupValues[1])
+      return
+    }
+
     val paramMatch = PARAM_REGEX.find(line)
     if (paramMatch != null) {
       val status = when (paramMatch.groupValues[3]) {
@@ -111,6 +153,8 @@ internal class LogcatParser(
         parameterEntries = currentParams.toList(),
         unstableParameters = currentUnstable.toList(),
         timestampMs = System.currentTimeMillis(),
+        durationMs = currentDurationMs,
+        stateEntries = currentStateEntries.toList(),
       ),
     )
     currentName = null

compose-stability-analyzer-idea/src/main/kotlin/com/skydoves/compose/stability/idea/heatmap/RecompositionHeatmapData.kt

@@ -25,6 +25,8 @@ internal data class ParsedRecompositionEvent(
   val parameterEntries: List<ParsedParameterEntry>,
   val unstableParameters: List<String>,
   val timestampMs: Long,
+  val durationMs: Double = 0.0,
+  val stateEntries: List<String> = emptyList(),
 )
 
 /**
@@ -57,6 +59,10 @@ internal data class ComposableHeatmapData(
   val lastSeenTimestampMs: Long,
   val changedParameters: Map<String, Int>,
   val unstableParameters: Set<String>,
+  val lastDurationMs: Double = 0.0,
+  val totalDurationMs: Double = 0.0,
+  val lastParameterChanges: List<String> = emptyList(),
+  val lastStateChanges: List<String> = emptyList(),
 )
 
 /**