Merge branch 'stage' into ADFA-4436-editor-coloring-hook

Author: hal-eisen-adfa

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

@@ -82,6 +82,7 @@ import com.google.android.material.tabs.TabLayout.Tab
 import com.itsaky.androidide.FeedbackButtonManager
 import com.itsaky.androidide.R
 import com.itsaky.androidide.R.string
+import com.itsaky.androidide.activities.MainActivity
 import com.itsaky.androidide.actions.build.DebugAction
 import com.itsaky.androidide.adapters.DiagnosticsAdapter
 import com.itsaky.androidide.adapters.SearchListAdapter
@@ -111,6 +112,7 @@ import com.itsaky.androidide.models.Range
 import com.itsaky.androidide.models.SearchResult
 import com.itsaky.androidide.plugins.manager.ui.PluginEditorTabManager
 import com.itsaky.androidide.preferences.internal.BuildPreferences
+import com.itsaky.androidide.preferences.internal.GeneralPreferences
 import com.itsaky.androidide.projects.IProjectManager
 import com.itsaky.androidide.projects.ProjectManagerImpl
 import com.itsaky.androidide.services.debug.DebuggerService
@@ -631,11 +633,35 @@ abstract class BaseEditorActivity :
 		builder.show()
 	}
 
+	/**
+	 * Restores the project path on recreation (saved state, launch intent, or last opened
+	 * project) and routes back to MainActivity if none is available, rather than crashing while
+	 * building the editor UI.
+	 */
 	override fun onCreate(savedInstanceState: Bundle?) {
-		savedInstanceState?.getString(KEY_PROJECT_PATH)
-			?.let(ProjectManagerImpl.getInstance()::projectPath::set)
+		// The OS can recreate EditorActivity after process death without routing through
+		// MainActivity, leaving the ProjectManagerImpl singleton's lateinit projectPath unset.
+		// Restore it from the saved state, the launch intent, or the last opened project.
+		val restoredProjectPath =
+			savedInstanceState?.getString(KEY_PROJECT_PATH)?.takeIf { it.isNotBlank() }
+				?: intent?.getStringExtra("PROJECT_PATH")?.takeIf { it.isNotBlank() }
+				?: GeneralPreferences.lastOpenedProject
+					.takeIf { it.isNotBlank() && it != GeneralPreferences.NO_OPENED_PROJECT }
+		if (restoredProjectPath != null) {
+			ProjectManagerImpl.getInstance().projectPath = restoredProjectPath
+		}
 		super.onCreate(savedInstanceState)
 
+		// If we still have no project path after every fallback, we cannot safely build the
+		// editor UI (setupToolbar -> getProjectName dereferences the project path). Route the
+		// user back to MainActivity instead of crashing.
+		if (ProjectManagerImpl.getInstance().projectDirPath.isBlank()) {
+			log.warn("No project path available in EditorActivity.onCreate(); returning to MainActivity")
+			startActivity(Intent(this, MainActivity::class.java))
+			finish()
+			return
+		}
+
 		editorViewModel.isBuildInProgress = false
 		editorViewModel.isInitializing = false
 

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

@@ -420,23 +420,35 @@ open class EditorHandlerActivity :
 		syncPluginUiFontSize()
 	}
 
+	/**
+	 * Restores the plugin tabs cached from the previous session, running the
+	 * SharedPreferences IO and Gson decode off the main thread to avoid a startup UI stall.
+	 */
 	private fun restoreOpenedPluginTabs() {
-		try {
-			val prefs = (application as BaseApplication).prefManager
-			val json = prefs.getString(PREF_KEY_OPEN_PLUGIN_TABS, null) ?: return
+		lifecycleScope.launch {
+			try {
+				val prefs = (application as BaseApplication).prefManager
+				val json = withContext(Dispatchers.IO) {
+					prefs.getString(PREF_KEY_OPEN_PLUGIN_TABS, null)
+				} ?: return@launch
 
-			val tabIds = Gson().fromJson(json, Array<String>::class.java)?.toList() ?: return
-			Log.d("EditorHandlerActivity", "Restoring plugin tabs: $tabIds")
+				// Decoding the cached JSON off the main thread avoids a UI stall on startup.
+				val tabIds = withContext(Dispatchers.Default) {
+					Gson().fromJson(json, Array<String>::class.java)?.toList()
+				} ?: return@launch
+				Log.d("EditorHandlerActivity", "Restoring plugin tabs: $tabIds")
 
-			tabIds.forEach { tabId ->
-				if (!pluginTabIndices.containsKey(tabId)) {
-					selectPluginTabById(tabId)
+				// Tab selection touches UI state, so keep it on the main thread.
+				tabIds.forEach { tabId ->
+					if (!pluginTabIndices.containsKey(tabId)) {
+						selectPluginTabById(tabId)
+					}
 				}
-			}
 
-			prefs.putString(PREF_KEY_OPEN_PLUGIN_TABS, null)
-		} catch (e: Exception) {
-			Log.e("EditorHandlerActivity", "Failed to restore plugin tabs", e)
+				withContext(Dispatchers.IO) { prefs.putString(PREF_KEY_OPEN_PLUGIN_TABS, null) }
+			} catch (e: Exception) {
+				Log.e("EditorHandlerActivity", "Failed to restore plugin tabs", e)
+			}
 		}
 	}
 

app/src/main/java/com/itsaky/androidide/fragments/onboarding/PermissionsFragment.kt

@@ -32,6 +32,7 @@ import androidx.core.net.toUri
 import androidx.fragment.app.viewModels
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.repeatOnLifecycle
+import androidx.lifecycle.withResumed
 import androidx.recyclerview.widget.RecyclerView
 import com.github.appintro.SlidePolicy
 import com.github.appintro.SlideSelectionListener
@@ -45,6 +46,7 @@ import com.itsaky.androidide.databinding.LayoutOnboardingPermissionsBinding
 import com.itsaky.androidide.events.InstallationEvent
 import com.itsaky.androidide.preferences.internal.prefManager
 import com.itsaky.androidide.tasks.doAsyncWithProgress
+import com.itsaky.androidide.utils.OverlayPermissionGuide
 import com.itsaky.androidide.utils.PermissionsHelper
 import com.itsaky.androidide.utils.flashError
 import com.itsaky.androidide.utils.isTestMode
@@ -73,7 +75,6 @@ class PermissionsFragment :
 	private var recyclerView: RecyclerView? = null
 	private var finishButton: MaterialButton? = null
     private lateinit var pulseAnimation: Animation
-	private var awaitingOverlayGrantResult = false
 
 	private val storagePermissionRequestLauncher =
 		registerForActivityResult(
@@ -97,6 +98,8 @@ class PermissionsFragment :
 		private val logger = LoggerFactory.getLogger(PermissionsFragment::class.java)
 		private const val KEY_PRIVACY_DISCLOSURE_SHOWN = "privacy.disclosure.shown"
 
+		private var awaitingOverlayGrantResult = false
+
 		@JvmStatic
 		fun newInstance(context: Context): PermissionsFragment =
 			PermissionsFragment().apply {
@@ -231,12 +234,13 @@ class PermissionsFragment :
        }
        awaitingOverlayGrantResult = false
 
-       if (PermissionsHelper.canDrawOverlays(requireContext())) {
-          return
+       viewLifecycleScope.launch {
+          viewLifecycleOwner.withResumed {
+             if (!PermissionsHelper.canDrawOverlays(requireContext())) {
+                OverlayPermissionGuide.showRestrictedSettingsDialog(requireContext())
+             }
+          }
        }
-
-       flashError(getString(R.string.permission_overlay_restricted_settings_hint))
-       requestSettingsTogglePermission(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
     }
 
 	private fun startIdeSetup() {

app/src/main/java/com/itsaky/androidide/utils/OverlayPermissionGuide.kt

@@ -0,0 +1,55 @@
+package com.itsaky.androidide.utils
+
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.provider.Settings
+import android.text.SpannableStringBuilder
+import com.itsaky.androidide.resources.R
+import org.slf4j.LoggerFactory
+
+object OverlayPermissionGuide {
+
+	private val log = LoggerFactory.getLogger(OverlayPermissionGuide::class.java)
+
+	fun showRestrictedSettingsDialog(context: Context) {
+		val message = SpannableStringBuilder()
+		message.append(context.getString(R.string.permission_overlay_restricted_dialog_message))
+		message.append("\n\n")
+		message.appendOrderedList(*context.resources.getStringArray(R.array.overlay_restricted_settings_steps))
+
+		DialogUtils
+			.newMaterialDialogBuilder(context)
+			.setTitle(R.string.permission_overlay_restricted_dialog_title)
+			.setMessage(message)
+			.setPositiveButton(R.string.permission_overlay_open_app_info) { dialog, _ ->
+				dialog.dismiss()
+				openAppInfo(context)
+			}
+			.setNegativeButton(android.R.string.cancel, null)
+			.show()
+	}
+
+	private fun openAppInfo(context: Context) {
+		val intent = Intent(
+			Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+			Uri.fromParts("package", context.packageName, null),
+		)
+		if (context !is Activity) {
+			intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+		}
+		try {
+			context.startActivity(intent)
+		} catch (e: ActivityNotFoundException) {
+			log.error("Failed to open App info settings", e)
+			flashError(
+				context.getString(
+					R.string.err_no_activity_to_handle_action,
+					Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+				),
+			)
+		}
+	}
+}

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

@@ -344,8 +344,16 @@ class EditorViewModel : ViewModel() {
         return file
     }
 
+    /**
+     * Returns the open project's directory name, or an empty string when no project path is
+     * available (the process-death recreation state where the project path is uninitialized).
+     */
     fun getProjectName(): String {
         val manager = ProjectManagerImpl.getInstance()
+        val path = manager.projectDirPath
+        if (path.isBlank()) {
+            return ""
+        }
         return manager.projectDir.name
     }
 }

app/src/test/java/com/itsaky/androidide/activities/editor/RestorePluginTabsThreadTest.kt

@@ -0,0 +1,144 @@
+/*
+ *  This file is part of AndroidIDE.
+ *
+ *  AndroidIDE is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  AndroidIDE is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *   along with AndroidIDE.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.itsaky.androidide.activities.editor
+
+import com.google.common.truth.Truth.assertThat
+import com.itsaky.androidide.app.BaseApplication
+import com.itsaky.androidide.eventbus.events.preferences.PreferenceChangeEvent
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import org.greenrobot.eventbus.EventBus
+import org.greenrobot.eventbus.Subscribe
+import org.greenrobot.eventbus.ThreadMode
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * ADFA-4331 repro: [EditorHandlerActivity.restoreOpenedPluginTabs] must do its
+ * SharedPreferences IO + Gson decode OFF the main thread (it stalls startup otherwise).
+ *
+ * Detector (deterministic, no timing): we run the real, private production method with
+ * the Main dispatcher pinned to a single-threaded [StandardTestDispatcher] (so "main" ==
+ * the test thread). The method, when it finishes restoring, clears the cached-tabs
+ * preference via `prefManager.putString(KEY, null)`, which posts a [PreferenceChangeEvent]
+ * on EventBus on the *thread that executed the write*. We capture that thread.
+ *
+ *  - BUGGED (stage): the whole body — pref read, Gson decode, final pref write — runs
+ *    directly inside `lifecycleScope.launch { }` on the Main dispatcher, i.e. the test
+ *    thread. The captured write thread == the test/main thread  ->  test FAILS.
+ *  - FIXED (branch): read/decode are wrapped in `withContext(Dispatchers.IO/Default)` and
+ *    the final write in `withContext(Dispatchers.IO)`, so the write runs on a real
+ *    background thread != the test/main thread  ->  test PASSES.
+ *
+ * UI tab-selection is skipped: we pre-seed the private `pluginTabIndices` map with the
+ * decoded id so `restoreOpenedPluginTabs` short-circuits the `selectPluginTabById(...)`
+ * UI call (`if (!pluginTabIndices.containsKey(tabId))`).
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+@Config(application = RestorePluginTabsThreadTest.TestApp::class)
+class RestorePluginTabsThreadTest {
+
+  open class TestApp : BaseApplication()
+
+  /** Captures the thread on which the cached-tabs preference write executed. */
+  class WriteThreadCapture {
+    @Volatile var writeThreadName: String? = null
+    val latch = CountDownLatch(1)
+
+    @Subscribe(threadMode = ThreadMode.POSTING)
+    fun onPrefChange(event: PreferenceChangeEvent) {
+      if (event.key == EditorHandlerActivity.PREF_KEY_OPEN_PLUGIN_TABS && event.value == null) {
+        writeThreadName = Thread.currentThread().name
+        latch.countDown()
+      }
+    }
+  }
+
+  private val testDispatcher = StandardTestDispatcher()
+
+  @Before
+  fun setUp() {
+    Dispatchers.setMain(testDispatcher)
+  }
+
+  @After
+  fun tearDown() {
+    Dispatchers.resetMain()
+  }
+
+  /** Asserts the cached-tabs clearing write runs on a background thread, not the main thread. */
+  @Test
+  fun `restore decodes and writes off the main thread`() {
+    val mainThreadName = Thread.currentThread().name
+
+    val controller = Robolectric.buildActivity(EditorHandlerActivity::class.java)
+    val activity = controller.get()
+    val app = activity.application as BaseApplication
+
+    // Seed the cached plugin-tabs JSON that the method will read + decode.
+    app.prefManager.putString(
+      EditorHandlerActivity.PREF_KEY_OPEN_PLUGIN_TABS,
+      """["tabA"]""",
+    )
+
+    // Pre-seed the private pluginTabIndices map so restoreOpenedPluginTabs() skips the
+    // UI-touching selectPluginTabById("tabA") call.
+    val mapField = EditorHandlerActivity::class.java.getDeclaredField("pluginTabIndices")
+    mapField.isAccessible = true
+    @Suppress("UNCHECKED_CAST")
+    val pluginTabIndices = mapField.get(activity) as MutableMap<String, Int>
+    pluginTabIndices["tabA"] = 0
+
+    // Subscribe AFTER seeding so we only capture the method's own clearing write.
+    val capture = WriteThreadCapture()
+    EventBus.getDefault().register(capture)
+    try {
+      // Invoke the real private production method.
+      val method = EditorHandlerActivity::class.java.getDeclaredMethod("restoreOpenedPluginTabs")
+      method.isAccessible = true
+      method.invoke(activity)
+
+      // The launched coroutine hops between the (test) Main dispatcher and the real
+      // Dispatchers.IO/Default background pools. Pump the test scheduler repeatedly while
+      // giving the background hops time to complete, until the clearing write fires.
+      val deadline = System.currentTimeMillis() + 10_000
+      while (capture.latch.count > 0 && System.currentTimeMillis() < deadline) {
+        testDispatcher.scheduler.advanceUntilIdle()
+        capture.latch.await(50, TimeUnit.MILLISECONDS)
+      }
+
+      val writeThread = capture.writeThreadName
+      assertThat(writeThread).isNotNull()
+      // The fix requires the IO/decode work to run OFF the main thread.
+      assertThat(writeThread).isNotEqualTo(mainThreadName)
+    } finally {
+      EventBus.getDefault().unregister(capture)
+    }
+  }
+}