[feat] add maxLogcatEntries new config param (#247)

## Summary by CodeRabbit

* **New Features**
  * Introduced `maxLogcatEntries` configuration setting to control the Logcat buffer size; defaults to 300 entries.
  * Logcat buffer capacity can now be updated at runtime.

* **Tests**
  * Added test coverage for configuration validation and buffer capacity adjustments.

Author: Manabu-GT

debugoverlay-core/src/main/kotlin/com/ms/square/debugoverlay/DebugOverlay.kt

@@ -5,6 +5,7 @@ import android.app.Application
 import android.content.Context
 import android.content.Intent
 import androidx.annotation.AnyThread
+import androidx.annotation.IntRange
 import androidx.annotation.MainThread
 import androidx.annotation.RestrictTo
 import com.ms.square.debugoverlay.internal.InternalDebugOverlayApi
@@ -40,6 +41,7 @@ public object DebugOverlay {
         _overlayDataRepository?.apply {
           setNetworkSource(newConfig.networkRequestSource)
           setCustomLogSource(newConfig.customLogSource)
+          setLogcatMaxEntries(newConfig.maxLogcatEntries)
         }
         overlayViewManager?.overlayMode?.value = newConfig.overlayMode
       }
@@ -82,7 +84,11 @@ public object DebugOverlay {
     check(!isInstalled) { "DebugOverlay already installed" }
 
     overlayScope = CoroutineScope(SupervisorJob() + Dispatchers.Default).also { scope ->
-      val repository = DebugOverlayDataRepository(application, scope).apply {
+      val repository = DebugOverlayDataRepository(
+        context = application,
+        scope = scope,
+        initialLogcatMaxEntries = config.maxLogcatEntries
+      ).apply {
         setNetworkSource(config.networkRequestSource)
         setCustomLogSource(config.customLogSource)
       }
@@ -220,11 +226,29 @@ public object DebugOverlay {
      */
     public var bugReportExporter: BugReportExporter = initial.bugReportExporter
 
+    /**
+     * Maximum number of entries kept in the built-in Logcat tab buffer.
+     * Also passed to `logcat -T N` / `-t N` so it controls how many lines the
+     * OS replays on producer start (panel open) and on bug-report snapshot.
+     *
+     * Default is [Config.DEFAULT_MAX_LOGCAT_ENTRIES] (300). Each entry holds a parsed
+     * [com.ms.square.debugoverlay.model.LogEntry].
+     *
+     * @throws IllegalArgumentException if assigned a non-positive value.
+     */
+    @IntRange(from = 1)
+    public var maxLogcatEntries: Int = initial.maxLogcatEntries
+      set(value) {
+        require(value > 0) { "maxLogcatEntries must be positive, was $value" }
+        field = value
+      }
+
     internal fun build(): Config = Config(
       overlayMode = overlayMode,
       networkRequestSource = networkRequestSource,
       customLogSource = customLogSource,
-      bugReportExporter = bugReportExporter
+      bugReportExporter = bugReportExporter,
+      maxLogcatEntries = maxLogcatEntries
     )
   }
 
@@ -243,6 +267,8 @@ public object DebugOverlay {
    *   Use debugoverlay-extension-timber for Timber integration.
    * @property bugReportExporter The exporter used when the user submits a bug report.
    *   Default is the built-in share sheet exporter.
+   * @property maxLogcatEntries Maximum number of entries kept in the built-in Logcat
+   *   tab buffer. Default is [DEFAULT_MAX_LOGCAT_ENTRIES].
    *
    * @see configure
    */
@@ -251,5 +277,11 @@ public object DebugOverlay {
     val networkRequestSource: NetworkRequestSource = NoOpNetworkRequestSource,
     val customLogSource: LogSource? = null,
     val bugReportExporter: BugReportExporter = IntentShareExporter,
-  )
+    val maxLogcatEntries: Int = DEFAULT_MAX_LOGCAT_ENTRIES,
+  ) {
+    public companion object {
+      /** Default value for [maxLogcatEntries]. */
+      public const val DEFAULT_MAX_LOGCAT_ENTRIES: Int = 300
+    }
+  }
 }

debugoverlay-core/src/main/kotlin/com/ms/square/debugoverlay/internal/data/DebugOverlayDataRepository.kt

@@ -38,10 +38,10 @@ import kotlin.time.Duration.Companion.milliseconds
 /** Default name shown when a custom log source doesn't provide a source name. */
 internal const val DEFAULT_CUSTOM_LOG_SOURCE_NAME = "Custom"
 
-internal class DebugOverlayDataRepository(context: Context, scope: CoroutineScope) {
+internal class DebugOverlayDataRepository(context: Context, scope: CoroutineScope, initialLogcatMaxEntries: Int) {
 
   private val currentNetworkRequestSource = MutableStateFlow<NetworkRequestSource>(NoOpNetworkRequestSource)
-  private val logcatDataSource = LogcatDataSource(scope)
+  private val logcatDataSource = LogcatDataSource(scope, initialMaxEntries = initialLogcatMaxEntries)
   private val customLogSource = MutableStateFlow<LogSource?>(null)
   private val netStatsDataSource = NetStatsDataSource(scope)
   private val deviceInfoDataSource = DeviceInfoDataSource(context, scope)
@@ -116,6 +116,10 @@ internal class DebugOverlayDataRepository(context: Context, scope: CoroutineScop
     customLogSource.value = source
   }
 
+  fun setLogcatMaxEntries(maxEntries: Int) {
+    logcatDataSource.maxEntries = maxEntries
+  }
+
   fun startOrResumeJankStatsTracking(activity: Activity) {
     jankStatsDataSource.startOrResumeTracking(activity)
   }

debugoverlay-core/src/main/kotlin/com/ms/square/debugoverlay/internal/data/EvictingQueue.kt

@@ -1,24 +1,41 @@
 package com.ms.square.debugoverlay.internal.data
 
+import androidx.annotation.GuardedBy
+import androidx.annotation.IntRange
 import androidx.annotation.RestrictTo
 import com.ms.square.debugoverlay.internal.InternalDebugOverlayApi
 
 /**
  * A bounded queue that automatically evicts the oldest element when capacity is reached.
  *
- * Thread-safe: all operations are synchronized.
+ * Thread-safe: all operations are synchronized on the instance monitor. The [capacity]
+ * property is mutable; assigning a new value resizes the queue (evicting from the head
+ * if shrinking below current size).
  *
- * @param capacity Maximum number of elements to retain. Must be positive.
+ * @param initialCapacity Initial maximum number of elements to retain. Must be positive.
  */
 @InternalDebugOverlayApi
 @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
-public class EvictingQueue<T>(private val capacity: Int) {
+public class EvictingQueue<T>(initialCapacity: Int) {
 
-  init {
-    require(capacity > 0) { "capacity must be positive, was $capacity" }
-  }
+  @GuardedBy("this")
+  private val queue = ArrayDeque<T>(initialCapacity)
 
-  private val queue = ArrayDeque<T>(capacity)
+  /**
+   * Current maximum number of elements the queue will retain.
+   * Assigning a smaller value evicts the oldest elements until size <= capacity.
+   */
+  @IntRange(from = 1)
+  @GuardedBy("this")
+  public var capacity: Int = initialCapacity
+    @Synchronized get
+
+    @Synchronized set(value) {
+      field = value
+      while (queue.size > value) {
+        queue.removeFirst()
+      }
+    }
 
   /**
    * Adds an element to the queue, evicting the oldest if at capacity.

debugoverlay-core/src/main/kotlin/com/ms/square/debugoverlay/internal/data/source/LogcatDataSource.kt

@@ -2,6 +2,7 @@ package com.ms.square.debugoverlay.internal.data.source
 
 import android.os.Build
 import androidx.annotation.GuardedBy
+import androidx.annotation.IntRange
 import com.ms.square.debugoverlay.Clearable
 import com.ms.square.debugoverlay.LogSource
 import com.ms.square.debugoverlay.internal.InternalDebugOverlayApi
@@ -38,7 +39,7 @@ import kotlin.time.Duration.Companion.milliseconds
 internal class LogcatDataSource(
   scope: CoroutineScope,
   private val parser: LogcatEntryParser = LogcatEntryParser(),
-  private val maxEntries: Int = 300,
+  initialMaxEntries: Int,
 ) : LogSource,
   Clearable,
   Closeable {
@@ -49,8 +50,20 @@ internal class LogcatDataSource(
 
   @GuardedBy("processLock")
   private var currentProcess: Process? = null
+  private val entries = EvictingQueue<LogEntry>(initialMaxEntries)
 
-  private val entries = EvictingQueue<LogEntry>(maxEntries)
+  /**
+   * Maximum number of entries retained in the in-memory buffer and the count
+   * requested from logcat on next subscription. The currently-running subprocess
+   * keeps its original `-T N` arg until [WhileSubscribed][SharingStarted.WhileSubscribed]
+   * restarts the producer (panel reopen).
+   */
+  var maxEntries: Int
+    @IntRange(from = 1)
+    get() = entries.capacity
+    set(@IntRange(from = 1) value) {
+      entries.capacity = value
+    }
 
   // Drops OS-replayed entries from before the last clear (e.g. when the producer
   // restarts on panel reopen and `-T N` walks the OS ring buffer).

debugoverlay-core/src/test/kotlin/com/ms/square/debugoverlay/DebugOverlayTest.kt

@@ -29,6 +29,7 @@ class DebugOverlayTest {
       networkRequestSource = NoOpNetworkRequestSource
       customLogSource = null
       bugReportExporter = IntentShareExporter
+      maxLogcatEntries = DebugOverlay.Config.DEFAULT_MAX_LOGCAT_ENTRIES
     }
     DebugOverlay.bugReportContributors.clear()
   }
@@ -41,6 +42,30 @@ class DebugOverlayTest {
     assertThat(config.networkRequestSource).isEqualTo(NoOpNetworkRequestSource)
     assertThat(config.customLogSource).isNull()
     assertThat(config.bugReportExporter).isSameInstanceAs(IntentShareExporter)
+    assertThat(config.maxLogcatEntries).isEqualTo(DebugOverlay.Config.DEFAULT_MAX_LOGCAT_ENTRIES)
+  }
+
+  @Test
+  fun `configure updates maxLogcatEntries`() {
+    DebugOverlay.configure {
+      maxLogcatEntries = 1000
+    }
+
+    assertThat(DebugOverlay.config.maxLogcatEntries).isEqualTo(1000)
+  }
+
+  @Test(expected = IllegalArgumentException::class)
+  fun `configure throws when maxLogcatEntries is zero`() {
+    DebugOverlay.configure {
+      maxLogcatEntries = 0
+    }
+  }
+
+  @Test(expected = IllegalArgumentException::class)
+  fun `configure throws when maxLogcatEntries is negative`() {
+    DebugOverlay.configure {
+      maxLogcatEntries = -1
+    }
   }
 
   @Test

debugoverlay-core/src/test/kotlin/com/ms/square/debugoverlay/internal/data/EvictingQueueTest.kt

@@ -7,22 +7,6 @@ import org.junit.Test
 @OptIn(InternalDebugOverlayApi::class)
 class EvictingQueueTest {
 
-  @Test(expected = IllegalArgumentException::class)
-  fun `constructor throws when capacity is zero`() {
-    EvictingQueue<String>(0)
-  }
-
-  @Test(expected = IllegalArgumentException::class)
-  fun `constructor throws when capacity is negative`() {
-    EvictingQueue<String>(-1)
-  }
-
-  @Test
-  fun `constructor succeeds with capacity of 1`() {
-    val queue = EvictingQueue<String>(1)
-    assertThat(queue.size).isEqualTo(0)
-  }
-
   @Test
   fun `add returns null when queue is not at capacity`() {
     val queue = EvictingQueue<String>(3)
@@ -141,4 +125,53 @@ class EvictingQueueTest {
 
     assertThat(queue.toList()).containsExactly(null, "value", null).inOrder()
   }
+
+  @Test
+  fun `capacity reflects initial value`() {
+    val queue = EvictingQueue<String>(5)
+    assertThat(queue.capacity).isEqualTo(5)
+  }
+
+  @Test
+  fun `capacity setter grows queue without dropping elements`() {
+    val queue = EvictingQueue<Int>(2)
+    queue.add(1)
+    queue.add(2)
+
+    queue.capacity = 4
+
+    assertThat(queue.capacity).isEqualTo(4)
+    assertThat(queue.toList()).containsExactly(1, 2).inOrder()
+    assertThat(queue.add(3)).isNull()
+    assertThat(queue.add(4)).isNull()
+    assertThat(queue.toList()).containsExactly(1, 2, 3, 4).inOrder()
+  }
+
+  @Test
+  fun `capacity setter shrinks queue and evicts oldest elements`() {
+    val queue = EvictingQueue<Int>(5)
+    queue.add(1)
+    queue.add(2)
+    queue.add(3)
+    queue.add(4)
+    queue.add(5)
+
+    queue.capacity = 3
+
+    assertThat(queue.capacity).isEqualTo(3)
+    assertThat(queue.toList()).containsExactly(3, 4, 5).inOrder()
+  }
+
+  @Test
+  fun `add respects new capacity after grow then shrink`() {
+    val queue = EvictingQueue<Int>(2)
+    queue.capacity = 4
+    queue.add(1)
+    queue.add(2)
+    queue.add(3)
+    queue.add(4)
+
+    assertThat(queue.add(5)).isEqualTo(1)
+    assertThat(queue.toList()).containsExactly(2, 3, 4, 5).inOrder()
+  }
 }