Address feedback items

Author: jkmassel

android/Gutenberg/build.gradle.kts

@@ -64,6 +64,7 @@ dependencies {
     implementation(libs.okhttp)
 
     testImplementation(libs.junit)
+    testImplementation(libs.kotlinx.coroutines.test)
     testImplementation(libs.mockito.core)
     testImplementation(libs.mockito.kotlin)
     testImplementation(libs.robolectric)

android/Gutenberg/src/main/java/org/wordpress/gutenberg/GutenbergView.kt

@@ -22,6 +22,9 @@ import android.webkit.WebResourceResponse
 import android.webkit.WebStorage
 import android.webkit.WebView
 import android.webkit.WebViewClient
+import androidx.lifecycle.coroutineScope
+import androidx.lifecycle.findViewTreeLifecycleOwner
+import androidx.lifecycle.lifecycleScope
 import androidx.webkit.WebViewAssetLoader
 import androidx.webkit.WebViewAssetLoader.AssetsPathHandler
 import kotlinx.coroutines.CoroutineScope
@@ -47,8 +50,8 @@ class GutenbergView : WebView {
     private var assetLoader = WebViewAssetLoader.Builder()
         .addPathHandler("/assets/", AssetsPathHandler(this.context))
         .build()
-    private var configuration: EditorConfiguration = EditorConfiguration.bundled()
-    private var dependencies: EditorDependencies? = null
+    private val configuration: EditorConfiguration
+    private lateinit var dependencies: EditorDependencies
 
     private val handler = Handler(Looper.getMainLooper())
     var filePathCallback: ValueCallback<Array<Uri?>?>? = null
@@ -68,14 +71,14 @@ class GutenbergView : WebView {
     private var networkRequestListener: NetworkRequestListener? = null
     private var loadingListener: EditorLoadingListener? = null
 
-    private val coroutineScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
-
     /**
      * Stores the contextId from the most recent openMediaLibrary call
      * to pass back to JavaScript when media is selected
      */
     private var currentMediaContextId: String? = null
 
+    private val coroutineScope: CoroutineScope
+
     var textEditorEnabled: Boolean = false
         set(value) {
             field = value
@@ -129,16 +132,23 @@ class GutenbergView : WebView {
         loadingListener = listener
     }
 
-    constructor(context: Context) : super(context)
-    constructor(context: Context, attrs: AttributeSet) : super(context, attrs)
-    constructor(context: Context, attrs: AttributeSet, defStyle: Int) : super(
-        context,
-        attrs,
-        defStyle
-    )
+    constructor(configuration: EditorConfiguration, dependencies: EditorDependencies?, coroutineScope: CoroutineScope, context: Context) : super(context) {
+        this.configuration = configuration
+        this.coroutineScope = coroutineScope
+
+        if (dependencies != null) {
+            this.dependencies = dependencies
+
+            // FAST PATH: Dependencies were provided - load immediately
+            loadEditor(dependencies)
+        } else {
+            // ASYNC FLOW: No dependencies - fetch them asynchronously
+            prepareAndLoadEditor()
+        }
+    }
 
     @SuppressLint("SetJavaScriptEnabled") // Without JavaScript we have no Gutenberg
-    fun initializeWebView() {
+    private fun initializeWebView() {
         this.settings.javaScriptCanOpenWindowsAutomatically = true
         this.settings.javaScriptEnabled = true
         this.settings.domStorageEnabled = true
@@ -272,38 +282,6 @@ class GutenbergView : WebView {
         }
     }
 
-    /**
-     * Starts the editor with the given configuration and optional dependencies.
-     *
-     * ## Loading Flows
-     *
-     * **When dependencies are provided (Fast Path):**
-     * The editor loads immediately using the pre-fetched dependencies.
-     * Only `onDependencyLoadingFinished()` and `onEditorReady()` callbacks are invoked.
-     *
-     * **When dependencies are null (Async Flow):**
-     * Dependencies are fetched asynchronously with progress reporting.
-     * All loading callbacks are invoked in order:
-     * 1. `onDependencyLoadingStarted()`
-     * 2. `onDependencyLoadingProgress()` (multiple times)
-     * 3. `onDependencyLoadingFinished()`
-     * 4. `onEditorReady()`
-     *
-     * @param configuration The editor configuration.
-     * @param dependencies Pre-fetched dependencies, or null to fetch them asynchronously.
-     */
-    fun start(configuration: EditorConfiguration, dependencies: EditorDependencies? = null) {
-        this.configuration = configuration
-
-        if (dependencies != null) {
-            // FAST PATH: Dependencies were provided - load immediately
-            loadEditor(dependencies)
-        } else {
-            // ASYNC FLOW: No dependencies - fetch them asynchronously
-            prepareAndLoadEditor()
-        }
-    }
-
     /**
      * Fetches all required dependencies and then loads the editor.
      *
@@ -312,17 +290,25 @@ class GutenbergView : WebView {
     private fun prepareAndLoadEditor() {
         loadingListener?.onDependencyLoadingStarted()
 
+        Log.i("GutenbergView", "Fetching dependencies...")
+
         coroutineScope.launch {
+            Log.i("GutenbergView", "In coroutine scope")
+            Log.i("GutenbergView", "Fetching dependencies in IO context")
             try {
                 val editorService = EditorService.create(
                     context = context,
                     configuration = configuration
                 )
-
+                Log.i("GutenbergView", "Created editor service")
                 val fetchedDependencies = editorService.prepare { progress ->
                     loadingListener?.onDependencyLoadingProgress(progress)
+
+                    Log.i("GutenbergView", "Progress: $progress")
                 }
 
+                Log.i("GutenbergView", "Finished fetching dependencies")
+
                 // Store dependencies and load the editor
                 loadEditor(fetchedDependencies)
             } catch (e: Exception) {
@@ -759,7 +745,6 @@ class GutenbergView : WebView {
 
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
-        coroutineScope.cancel()
         clearConfig()
         this.stopLoading()
         FileCache.clearCache(context)
@@ -785,40 +770,6 @@ class GutenbergView : WebView {
         private var warmupRunnable: Runnable? = null
         private var warmupWebView: GutenbergView? = null
 
-        /**
-         * Warmup the editor by preloading assets in a temporary WebView.
-         * This pre-caches assets to improve editor launch speed.
-         */
-        @JvmStatic
-        fun warmup(context: Context, configuration: EditorConfiguration) {
-            // Cancel any existing warmup
-            cancelWarmup()
-
-            // Create dedicated warmup WebView
-            val webView = GutenbergView(context)
-            webView.initializeWebView()
-            webView.start(configuration, EditorDependencies.empty)
-            warmupWebView = webView
-
-            // Schedule cleanup after assets are loaded
-            warmupHandler = Handler(Looper.getMainLooper())
-            warmupRunnable = Runnable {
-                cleanupWarmup()
-            }
-            warmupHandler?.postDelayed(warmupRunnable!!, ASSET_LOADING_TIMEOUT_MS)
-        }
-
-        /**
-         * Cancel any pending warmup and clean up resources.
-         */
-        @JvmStatic
-        fun cancelWarmup() {
-            warmupRunnable?.let { runnable ->
-                warmupHandler?.removeCallbacks(runnable)
-            }
-            cleanupWarmup()
-        }
-
         /**
          * Clean up warmup resources.
          */
@@ -832,21 +783,6 @@ class GutenbergView : WebView {
             warmupHandler = null
             warmupRunnable = null
         }
-
-        /**
-         * Create a new GutenbergView for the editor.
-         * Cancels any pending warmup to free resources.
-         */
-        @JvmStatic
-        fun createForEditor(context: Context): GutenbergView {
-            // Cancel any pending warmup to free resources
-            cancelWarmup()
-
-            // Create fresh WebView for editor
-            val webView = GutenbergView(context)
-            webView.initializeWebView()
-            return webView
-        }
     }
 }
 

android/Gutenberg/src/main/java/org/wordpress/gutenberg/model/EditorAssetBundle.kt

@@ -85,7 +85,7 @@ data class EditorAssetBundle(
         val empty = EditorAssetBundle(
             manifest = LocalEditorAssetManifest.empty,
             downloadDate = Date(),
-            bundleRoot = File(System.getProperty("java.io.tmpdir"))
+            bundleRoot = File("/tmp/empty-bundle")
         )
 
         /**

android/Gutenberg/src/main/java/org/wordpress/gutenberg/model/EditorDependenciesSerializer.kt

@@ -79,9 +79,7 @@ object EditorDependenciesSerializer {
      * @param filePath The absolute path to the serialized dependencies file.
      * @return The deserialized dependencies, or `null` if the file doesn't exist or is invalid.
      */
-    fun readFromDisk(filePath: String?): EditorDependencies? {
-        if (filePath == null) return null
-
+    fun readFromDisk(filePath: String): EditorDependencies? {
         val file = File(filePath)
         if (!file.exists()) return null
 

android/Gutenberg/src/test/java/org/wordpress/gutenberg/GutenbergViewTest.kt

@@ -6,8 +6,10 @@ import android.os.Looper
 import android.webkit.ValueCallback
 import android.webkit.WebChromeClient
 import android.webkit.WebView
+import kotlinx.coroutines.test.TestScope
 import org.junit.Before
 import org.junit.Test
+import org.junit.Rule
 import org.junit.runner.RunWith
 import org.mockito.Mock
 import org.mockito.Mockito.`when`
@@ -20,6 +22,8 @@ import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
+import org.wordpress.gutenberg.model.EditorConfiguration
+import org.wordpress.gutenberg.model.EditorDependencies
 
 @RunWith(RobolectricTestRunner::class)
 @Config(sdk = [28], manifest = Config.NONE)
@@ -35,11 +39,18 @@ class GutenbergViewTest {
 
     private lateinit var gutenbergView: GutenbergView
 
+    val testScope = TestScope() // Creates a StandardTestDispatcher
+
     @Before
     fun setup() {
         MockitoAnnotations.openMocks(this)
-        gutenbergView = GutenbergView(RuntimeEnvironment.getApplication())
-        gutenbergView.initializeWebView()
+
+        gutenbergView = GutenbergView(
+            EditorConfiguration.bundled(),
+            EditorDependencies.empty,
+            testScope,
+            RuntimeEnvironment.getApplication()
+        )
     }
 
     @Test

android/app/src/main/java/com/example/gutenbergkit/EditorActivity.kt

@@ -34,7 +34,6 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableStateOf
@@ -47,6 +46,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.lifecycle.lifecycleScope
 import com.example.gutenbergkit.ui.theme.AppTheme
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import org.wordpress.gutenberg.model.EditorConfiguration
 import org.wordpress.gutenberg.GutenbergView
@@ -97,13 +97,14 @@ class EditorActivity : ComponentActivity() {
 
         // Read dependencies from disk if a file path was provided
         val dependenciesPath = intent.getStringExtra(EXTRA_DEPENDENCIES_PATH)
-        val dependencies = EditorDependenciesSerializer.readFromDisk(dependenciesPath)
+        val dependencies = dependenciesPath?.let { EditorDependenciesSerializer.readFromDisk(it) }
 
         setContent {
             AppTheme {
                 EditorScreen(
                     configuration = configuration,
                     dependencies = dependencies,
+                    coroutineScope =  this.lifecycleScope,
                     onClose = { finish() },
                     onGutenbergViewCreated = { view ->
                         gutenbergView = view
@@ -140,6 +141,7 @@ enum class EditorLoadingState {
 fun EditorScreen(
     configuration: EditorConfiguration,
     dependencies: EditorDependencies? = null,
+    coroutineScope: CoroutineScope,
     onClose: () -> Unit,
     onGutenbergViewCreated: (GutenbergView) -> Unit = {}
 ) {
@@ -256,7 +258,7 @@ fun EditorScreen(
     ) { innerPadding ->
         AndroidView(
             factory = { context ->
-                GutenbergView(context).apply {
+                GutenbergView(configuration, dependencies, coroutineScope, context).apply {
                     gutenbergViewRef = this
                     setModalDialogStateListener(object : GutenbergView.ModalDialogStateListener {
                         override fun onModalDialogOpened(dialogType: String) {
@@ -326,7 +328,6 @@ fun EditorScreen(
                             loadingError = error.message ?: "Unknown error"
                         }
                     })
-                    start(configuration, dependencies)
                     onGutenbergViewCreated(this)
                 }
             },

android/gradle/libs.versions.toml

@@ -37,6 +37,7 @@ mockito-core = { group = "org.mockito", name = "mockito-core", version.ref = "mo
 mockito-kotlin = { group = "org.mockito.kotlin", name = "mockito-kotlin", version.ref = "mockito" }
 robolectric = { group = "org.robolectric", name = "robolectric", version.ref = "robolectric" }
 kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
 kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
 androidx-recyclerview = { group = "androidx.recyclerview", name = "recyclerview", version.ref = "androidx-recyclerview" }
 wordpress-rs-android = { group = "rs.wordpress.api", name = "android", version.ref = "wordpress-rs" }