ADFA-2593 | Fix initialization crash in BuildOutputFragment

app/src/main/java/com/itsaky/androidide/fragments/output/BuildOutputFragment.kt

@@ -18,28 +18,33 @@ package com.itsaky.androidide.fragments.output
 
 import android.os.Bundle
 import android.view.View
-import com.blankj.utilcode.util.ThreadUtils
+import androidx.lifecycle.lifecycleScope
 import com.itsaky.androidide.R
 import com.itsaky.androidide.editor.ui.IDEEditor
 import com.itsaky.androidide.idetooltips.TooltipTag
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.ReceiveChannel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
 
 class BuildOutputFragment : NonEditableEditorFragment() {
+	companion object {
+ private const val LAYOUT_TIMEOUT_MS = 2000L
+	}
+
 	override val currentEditor: IDEEditor? get() = editor
 
-	private val unsavedLines: MutableList<String?> = ArrayList()
+	private val logChannel = Channel<String>(Channel.UNLIMITED)
 
-	override fun onViewCreated(
- view: View,
- savedInstanceState: Bundle?,
-	) {
+	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
  super.onViewCreated(view, savedInstanceState)
  editor?.tag = TooltipTag.PROJECT_BUILD_OUTPUT
  emptyStateViewModel.setEmptyMessage(getString(R.string.msg_emptyview_buildoutput))
- if (unsavedLines.isNotEmpty()) {
- for (line in unsavedLines) {
- editor?.append("${line!!.trim()}\n")
- }
- unsavedLines.clear()
+
+ viewLifecycleOwner.lifecycleScope.launch(Dispatchers.Default) {
+ processLogs()
  }
 	}
 
@@ -49,20 +54,72 @@ class BuildOutputFragment : NonEditableEditorFragment() {
 	}
 
 	fun appendOutput(output: String?) {
- if (editor == null) {
- unsavedLines.add(output)
- return
+ if (!output.isNullOrEmpty()) {
+ logChannel.trySend(output)
+ }
+	}
+
+	/**
+ * Ensures the string ends with a newline character (`\n`).
+ * Useful for maintaining correct formatting when concatenating log lines.
+ */
+	private fun String.ensureNewline(): String =
+ if (endsWith('\n')) this else "$this\n"
+
+	/**
+ * Immediately drains (consumes) all available messages from the channel into the [buffer].
+ *
+ * This is a **non-blocking** operation that enables batching, grouping hundreds of pending lines
+ * into a single memory operation to avoid saturating the UI queue.
+ */
+	private fun ReceiveChannel<String>.drainTo(buffer: StringBuilder) {
+ var result = tryReceive()
+ while (result.isSuccess) {
+ val line = result.getOrNull()
+ if (!line.isNullOrEmpty()) {
+ buffer.append(line.ensureNewline())
+ }
+ result = tryReceive()
  }
- ThreadUtils.runOnUiThread {
- val message =
- if (output == null || output.endsWith("\n")) {
- output
- } else {
- "${output}\n"
- }
- editor?.append(message).also {
- emptyStateViewModel.setEmpty(false)
+	}
+
+	/**
+ * Main log orchestrator: Consumes, Batches, and Dispatches.
+ *
+ * 1. Suspends (zero CPU usage) until the first log arrives.
+ * 2. Wakes up and drains the entire queue (Batching).
+ * 3. Sends the complete block to the UI in a single pass.
+ */
+	private suspend fun processLogs() = with(StringBuilder()) {
+ for (firstLine in logChannel) {
+ append(firstLine.ensureNewline())
+ logChannel.drainTo(this)
+
+ if (isNotEmpty()) {
+ val batchText = toString()
+ clear()
+ flushToEditor(batchText)
  }
  }
 	}
+
+	/**
+ * Performs the safe UI update on the Main Thread.
+ *
+ * Uses [IDEEditor.awaitLayout] to guarantee the editor has physical dimensions (width > 0)
+ * before attempting to insert text, preventing the Sora library's `ArrayIndexOutOfBoundsException`.
+ */
+	private suspend fun flushToEditor(text: String) = withContext(Dispatchers.Main) {
+ editor?.run {
+ withTimeoutOrNull(LAYOUT_TIMEOUT_MS) {
+ awaitLayout(onForceVisible = {
+ emptyStateViewModel.setEmpty(false)
+ })
+ }
+
+ appendBatch(text)
+
+ emptyStateViewModel.setEmpty(false)
+ }
+	}
 }

editor/src/main/java/com/itsaky/androidide/editor/ui/IDEEditor.kt

@@ -24,6 +24,7 @@ import android.os.Handler
 import android.os.Looper
 import android.util.AttributeSet
 import android.view.MotionEvent
+import android.view.View
 import android.view.inputmethod.EditorInfo
 import androidx.annotation.StringRes
 import androidx.annotation.VisibleForTesting
@@ -97,12 +98,14 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withContext
 import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
 import org.slf4j.LoggerFactory
 import java.io.File
+import kotlin.coroutines.resume
 
 fun interface OnEditorLongPressListener {
  fun onLongPress(event: MotionEvent)
@@ -206,6 +209,9 @@ constructor(
  return _diagnosticWindow ?: DiagnosticWindow(this).also { _diagnosticWindow = it }
  }
 
+ val isReadyToAppend: Boolean
+ get() = !isReleased && isAttachedToWindow && isLaidOut && width > 0
+
  companion object {
  private const val TAG = "TrackpadScrollDebug"
  private const val SELECTION_CHANGE_DELAY = 500L
@@ -266,6 +272,59 @@ constructor(
  }
  }
 
+ /**
+ * Suspends the current coroutine until the editor has valid dimensions (`width > 0`).
+ *
+ * This is a **reactive** alternative to busy-waiting or `postDelayed`. It ensures that
+ * no text insertion is attempted before the editor's internal layout engine is ready,
+ * preventing the `ArrayIndexOutOfBoundsException`.
+ *
+ * @param onForceVisible A callback invoked immediately if the view is not ready.
+ * Used to set the view to `VISIBLE` and trigger the layout pass.
+ */
+ suspend fun awaitLayout(onForceVisible: () -> Unit) {
+ if (isReadyToAppend) return
+
+ withContext(Dispatchers.Main) {
+ onForceVisible()
+ }
+
+ return suspendCancellableCoroutine { continuation ->
+ val listener = object : OnLayoutChangeListener {
+ override fun onLayoutChange(
+ v: View?, left: Int, top: Int, right: Int, bottom: Int,
+ oldLeft: Int, oldTop: Int, oldRight: Int, oldBottom: Int
+ ) {
+ if ((v?.width ?: 0) > 0) {
+ v?.removeOnLayoutChangeListener(this)
+ if (continuation.isActive) {
+ continuation.resume(Unit)
+ }
+ }
+ }
+ }
+
+ addOnLayoutChangeListener(listener)
+
+ continuation.invokeOnCancellation {
+ removeOnLayoutChangeListener(listener)
+ }
+ }
+ }
+
+ /**
+ * Appends a block of text to the editor safely.
+ *
+ * It performs a final check on [isReadyToAppend] and wraps the underlying append operation
+ * in [runCatching]. This prevents the app from crashing if the editor's internal layout
+ * calculation fails during the insertion.
+ */
+ fun appendBatch(text: String) {
+ if (isReadyToAppend) {
+ runCatching { append(text) }
+ }
+ }
+
  override fun setLanguageServer(server: ILanguageServer?) {
  if (isReleased) {
  return