ADFA-6228: Read class lookups from the JVM symbol index instead of the classpath trie

app/src/main/java/com/itsaky/androidide/activities/editor/BaseEditorActivity.kt

@@ -167,6 +167,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import org.appdevforall.codeonthego.indexing.service.IndexingState
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode.MAIN
 import org.slf4j.Logger
@@ -404,6 +405,7 @@ abstract class BaseEditorActivity :
 		@UiThread set(value) {
 			field = value
 			onUpdateProgressBarVisibility()
+			postIndexingStatusUpdate()
 		}
 
 	private var debuggerService: DebuggerService? = null
@@ -1608,17 +1610,47 @@ abstract class BaseEditorActivity :
 
 	private fun onUpdateProgressBarVisibility() {
 		log.debug(
-			"onBuildStatusChanged: isInitializing: ${editorViewModel.isInitializing}, isBuildInProgress: ${editorViewModel.isBuildInProgress}",
+			"onBuildStatusChanged: isInitializing: ${editorViewModel.isInitializing}, isBuildInProgress: ${editorViewModel.isBuildInProgress}, isIndexing: ${editorViewModel.isIndexing}",
 		)
-		// An internal build owns the same Gradle slot, so it shows the same progress bar. It does
-		// NOT relabel the Run button: the cancel affordance stays keyed off isBuildInProgress.
-		val visible =
+		val visible = isStatusOwnedElsewhere || editorViewModel.isIndexing
+		content.progressIndicator.visibility = if (visible) View.VISIBLE else View.GONE
+		invalidateOptionsMenu()
+	}
+
+	/*
+	 * Whether a build, project initialization or debugger start owns the progress bar and status slot.
+	 * An internal build owns the same Gradle slot as a user build, but it does NOT relabel the Run
+	 * button: the cancel affordance stays keyed off isBuildInProgress.
+	 */
+	private val isStatusOwnedElsewhere: Boolean
+		get() =
 			editorViewModel.isBuildInProgress ||
 				editorViewModel.isInternalBuildInProgress ||
 				editorViewModel.isInitializing ||
 				isDebuggerStarting
-		content.progressIndicator.visibility = if (visible) View.VISIBLE else View.GONE
-		invalidateOptionsMenu()
+
+	private fun onIndexingStateChanged(state: IndexingState) {
+		val wasIndexing = editorViewModel.isIndexing
+		editorViewModel.onIndexingStateChanged(state)
+		if (editorViewModel.isIndexing != wasIndexing) {
+			onUpdateProgressBarVisibility()
+		}
+		onUpdateIndexingStatus()
+	}
+
+	private fun onUpdateIndexingStatus() {
+		editorViewModel.updateIndexingStatus(isStatusOwnedElsewhere) { done, total ->
+			getString(string.status_indexing_classes, done, total)
+		}
+	}
+
+	/*
+	 * Deferred to the next main-loop message: the callbacks that clear a slot-owning flag often
+	 * write their final status (e.g. "Build was cancelled") after clearing it, and the indexing
+	 * text must replace that write rather than be overwritten by it.
+	 */
+	private fun postIndexingStatusUpdate() {
+		lifecycleScope.launch(Dispatchers.Main) { onUpdateIndexingStatus() }
 	}
 
 	private fun setupStateObservers() {
@@ -1656,17 +1688,31 @@ abstract class BaseEditorActivity :
 						}
 					}
 				}
+
+				launch {
+					ProjectManagerImpl
+						.getInstance()
+						.indexingServiceManager.state
+						.collect { state -> onIndexingStateChanged(state) }
+				}
 			}
 		}
 
 		editorViewModel._isBuildInProgress.observe(this) { inProgress ->
 			onUpdateProgressBarVisibility()
+			postIndexingStatusUpdate()
 			// The bottom sheet's collapsed header follows the status line's height; while the
 			// build narrates one line per task it only grows, or the peek jumps on every task.
 			content.bottomSheet.setBuildNarrating(inProgress == true)
 		}
-		editorViewModel._isInternalBuildInProgress.observe(this) { onUpdateProgressBarVisibility() }
-		editorViewModel._isInitializing.observe(this) { onUpdateProgressBarVisibility() }
+		editorViewModel._isInternalBuildInProgress.observe(this) {
+			onUpdateProgressBarVisibility()
+			postIndexingStatusUpdate()
+		}
+		editorViewModel._isInitializing.observe(this) {
+			onUpdateProgressBarVisibility()
+			postIndexingStatusUpdate()
+		}
 		editorViewModel._statusText.observe(this) {
 			content.bottomSheet.setStatus(
 				it.first,

app/src/main/java/com/itsaky/androidide/viewmodel/EditorViewModel.kt

@@ -41,6 +41,7 @@ import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import org.appdevforall.codeonthego.indexing.service.IndexingState
 import java.io.File
 import java.io.IOException
 import java.util.Collections
@@ -250,6 +251,50 @@ class EditorViewModel : ViewModel() {
 			_statusText.value = (_statusText.value?.first ?: "") to value
 		}
 
+	/** The latest class indexing state the editor has observed. */
+	var indexingState: IndexingState = IndexingState.Idle
+		private set
+
+	/** Whether class indexing is in flight, derived from [indexingState]. */
+	val isIndexing: Boolean
+		get() = indexingState is IndexingState.Indexing
+
+	/** The indexing text last written to the status slot, or null if none is shown. */
+	private var shownIndexingStatus: CharSequence? = null
+
+	/** The message the indexing text replaced in the status slot, restored when indexing ends. */
+	private var replacedStatus: CharSequence? = null
+
+	/** Records [state], as reported by the project's indexing service manager. */
+	internal fun onIndexingStateChanged(state: IndexingState) {
+		indexingState = state
+	}
+
+	/**
+	 * Updates the status slot for [indexingState], formatting its progress with [formatProgress].
+	 *
+	 * [isSlotOwnedElsewhere] is true while a build, project initialization or debugger start owns
+	 * the slot; see [resolveIndexingStatus].
+	 */
+	fun updateIndexingStatus(
+		isSlotOwnedElsewhere: Boolean,
+		formatProgress: (done: Int, total: Int) -> CharSequence,
+	) {
+		val indexingStatus = (indexingState as? IndexingState.Indexing)?.let { formatProgress(it.done, it.total) }
+		val current = statusText
+		val next =
+			resolveIndexingStatus(isSlotOwnedElsewhere, indexingStatus, current, shownIndexingStatus, replacedStatus)
+				?: return
+		if (indexingStatus != null && shownIndexingStatus?.contentEquals(current) != true) {
+			replacedStatus = current
+		}
+		if (indexingStatus == null) {
+			replacedStatus = null
+		}
+		shownIndexingStatus = indexingStatus
+		_statusText.value = next to CENTER
+	}
+
 	var displayedFileIndex: Int
 		get() = _displayedFile.value!!
 		set(value) {
@@ -489,3 +534,27 @@ class EditorViewModel : ViewModel() {
 		return manager.projectDir.name
 	}
 }
+
+/**
+ * Decides what the status slot shows next for class indexing, or returns null to leave it alone.
+ *
+ * While [isSlotOwnedElsewhere] (a build, project initialization or debugger start is running) the
+ * slot is left to that operation. Otherwise [indexingStatus], the progress text or null when
+ * indexing is idle, takes it. When indexing ends the slot goes back to [replacedStatus], the message
+ * the indexing text replaced (a build result, say), or is cleared if there was none. It does so
+ * only if the slot still shows [shownIndexingStatus], the indexing text last written there, so a
+ * newer message survives.
+ */
+internal fun resolveIndexingStatus(
+	isSlotOwnedElsewhere: Boolean,
+	indexingStatus: CharSequence?,
+	currentStatus: CharSequence,
+	shownIndexingStatus: CharSequence?,
+	replacedStatus: CharSequence? = null,
+): CharSequence? =
+	when {
+		isSlotOwnedElsewhere -> null
+		indexingStatus != null -> indexingStatus.takeUnless { it.contentEquals(currentStatus) }
+		shownIndexingStatus?.contentEquals(currentStatus) == true -> replacedStatus ?: ""
+		else -> null
+	}