Add asset caching + progress

Author: jkmassel

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

@@ -3,11 +3,11 @@ package org.wordpress.gutenberg
 import android.webkit.WebResourceRequest
 import android.webkit.WebResourceResponse
 import android.util.Log
-import org.wordpress.gutenberg.stores.EditorAssetsLibrary
+import org.wordpress.gutenberg.model.EditorAssetBundle
 import java.io.ByteArrayInputStream
 
 class CachedAssetRequestInterceptor(
-    private val library: EditorAssetsLibrary,
+    private val bundle: EditorAssetBundle,
     private val allowedHosts: Set<String> = emptySet()
 ) : GutenbergRequestInterceptor {
     companion object {
@@ -45,28 +45,21 @@ class CachedAssetRequestInterceptor(
             }
 
             // Handle asset caching - only serve if already cached
-            val cachedData = library.getCachedAsset(url)
-            if (cachedData != null) {
+            if (bundle.hasAssetData(url)) {
+                val cachedData = bundle.assetData(url)
                 Log.d(TAG, "Serving cached asset: $url")
                 return createResponse(url, cachedData)
             }
 
-            // Not cached - let WebView fetch normally and cache in background
-            Log.d(TAG, "Asset not cached, will cache in background: $url")
-            // Start background caching for next time
-            library.cacheAssetInBackground(url)
-            
+            // Not cached - let WebView fetch normally
+            Log.d(TAG, "Asset not cached: $url")
             return null // Let WebView handle the request normally
         } catch (e: Exception) {
             Log.e(TAG, "Error handling request: $url", e)
             return null
         }
     }
 
-    fun shutdown() {
-        library.shutdown()
-    }
-
     private fun createResponse(url: String, data: ByteArray): WebResourceResponse {
         val mimeType = getMimeType(url)
         return WebResourceResponse(

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

@@ -0,0 +1,62 @@
+package org.wordpress.gutenberg
+
+import org.wordpress.gutenberg.model.EditorProgress
+
+/**
+ * Callback interface for monitoring editor loading state.
+ *
+ * Implement this interface to receive updates about the editor's loading progress,
+ * allowing you to display appropriate UI (progress bar, spinner, etc.) while the
+ * editor initializes.
+ *
+ * ## Loading Flow
+ *
+ * When dependencies are **not provided** to `GutenbergView.start()`:
+ * 1. `onDependencyLoadingStarted()` - Begin showing progress bar
+ * 2. `onDependencyLoadingProgress()` - Update progress bar (called multiple times)
+ * 3. `onDependencyLoadingFinished()` - Hide progress bar, show spinner
+ * 4. `onEditorReady()` - Hide spinner, editor is usable
+ *
+ * When dependencies **are provided** to `GutenbergView.start()`:
+ * 1. `onDependencyLoadingFinished()` - Show spinner (no progress phase)
+ * 2. `onEditorReady()` - Hide spinner, editor is usable
+ */
+interface EditorLoadingListener {
+    /**
+     * Called when dependency loading begins.
+     *
+     * This is the appropriate time to show a progress bar to the user.
+     * Only called when dependencies were not provided to `start()`.
+     */
+    fun onDependencyLoadingStarted()
+
+    /**
+     * Called periodically with progress updates during dependency loading.
+     *
+     * @param progress The current loading progress with completed/total counts.
+     */
+    fun onDependencyLoadingProgress(progress: EditorProgress)
+
+    /**
+     * Called when dependency loading completes.
+     *
+     * This is the appropriate time to hide the progress bar and show a spinner
+     * while the WebView loads and parses the editor JavaScript.
+     */
+    fun onDependencyLoadingFinished()
+
+    /**
+     * Called when the editor has fully loaded and is ready for use.
+     *
+     * This is the appropriate time to hide all loading indicators and reveal
+     * the editor. The editor APIs are safe to call after this callback.
+     */
+    fun onEditorReady()
+
+    /**
+     * Called if dependency loading fails.
+     *
+     * @param error The exception that caused the failure.
+     */
+    fun onDependencyLoadingFailed(error: Throwable)
+}

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

@@ -24,16 +24,17 @@ import android.webkit.WebView
 import android.webkit.WebViewClient
 import androidx.webkit.WebViewAssetLoader
 import androidx.webkit.WebViewAssetLoader.AssetsPathHandler
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.json.JSONException
 import org.json.JSONObject
 import org.wordpress.gutenberg.model.EditorConfiguration
 import org.wordpress.gutenberg.model.EditorDependencies
 import org.wordpress.gutenberg.model.GBKitGlobal
-import org.wordpress.gutenberg.stores.EditorAssetsLibrary
-import java.io.File
-import java.net.URL
+import org.wordpress.gutenberg.services.EditorService
 import java.util.Locale
 
 const val ASSET_URL = "https://appassets.androidplatform.net/assets/index.html"
@@ -63,6 +64,10 @@ class GutenbergView : WebView {
     private var autocompleterTriggeredListener: AutocompleterTriggeredListener? = null
     private var modalDialogStateListener: ModalDialogStateListener? = null
     private var networkRequestListener: NetworkRequestListener? = null
+    private var loadingListener: EditorLoadingListener? = null
+
+    private val coroutineScope = CoroutineScope(Dispatchers.Main + Job())
+    private var dependencyLoadingJob: Job? = null
 
     /**
      * Stores the contextId from the most recent openMediaLibrary call
@@ -119,6 +124,10 @@ class GutenbergView : WebView {
         editorDidBecomeAvailableListener = listener
     }
 
+    fun setEditorLoadingListener(listener: EditorLoadingListener?) {
+        loadingListener = listener
+    }
+
     constructor(context: Context) : super(context)
     constructor(context: Context, attrs: AttributeSet) : super(context, attrs)
     constructor(context: Context, attrs: AttributeSet, defStyle: Int) : super(
@@ -262,25 +271,82 @@ 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
-        this.dependencies = dependencies
 
-        // Set up asset caching if enabled
-        if (configuration.enableAssetCaching) {
-            val storageRoot = getCacheDirectory(configuration)
-            val httpClient = EditorHTTPClient(authHeader = configuration.authHeader)
-            val library = EditorAssetsLibrary(
-                configuration = configuration,
-                httpClient = httpClient,
-                storageRoot = storageRoot
-            )
-            val cachedInterceptor = CachedAssetRequestInterceptor(
-                library,
-                configuration.cachedAssetHosts
-            )
-            requestInterceptor = cachedInterceptor
+        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.
+     *
+     * This method is the entry point for the async flow when no dependencies were provided.
+     */
+    private fun prepareAndLoadEditor() {
+        loadingListener?.onDependencyLoadingStarted()
+
+        dependencyLoadingJob = coroutineScope.launch {
+            try {
+                val editorService = EditorService.create(
+                    context = context,
+                    configuration = configuration
+                )
+
+                val fetchedDependencies = editorService.prepare { progress ->
+                    loadingListener?.onDependencyLoadingProgress(progress)
+                }
+
+                // Store dependencies and load the editor
+                loadEditor(fetchedDependencies)
+            } catch (e: Exception) {
+                Log.e("GutenbergView", "Failed to load dependencies", e)
+                loadingListener?.onDependencyLoadingFailed(e)
+            }
+        }
+    }
+
+    /**
+     * Loads the editor with the given dependencies.
+     *
+     * This is the shared loading path used by both flows after dependencies are available.
+     */
+    private fun loadEditor(dependencies: EditorDependencies) {
+        this.dependencies = dependencies
+
+        // Set up asset caching
+        requestInterceptor = CachedAssetRequestInterceptor(
+            dependencies.assetBundle,
+            configuration.cachedAssetHosts
+        )
+
+        // Notify that dependency loading is complete (spinner phase begins)
+        loadingListener?.onDependencyLoadingFinished()
 
         initializeWebView()
 
@@ -292,13 +358,13 @@ class GutenbergView : WebView {
         this.clearCache(true)
         // All cookies are third-party cookies because the root of this document
         // lives under `https://appassets.androidplatform.net`
-        CookieManager.getInstance().setAcceptThirdPartyCookies(this, true);
+        CookieManager.getInstance().setAcceptThirdPartyCookies(this, true)
 
         // Erase all local cookies before loading the URL – we don't want to persist
         // anything between uses – otherwise we might send the wrong cookies
         CookieManager.getInstance().removeAllCookies {
             CookieManager.getInstance().flush()
-            for(cookie in configuration.cookies) {
+            for (cookie in configuration.cookies) {
                 CookieManager.getInstance().setCookie(cookie.key, cookie.value)
             }
             this.loadUrl(editorUrl)
@@ -468,6 +534,7 @@ class GutenbergView : WebView {
         isEditorLoaded = true
         handler.post {
             if(!didFireEditorLoaded) {
+                loadingListener?.onEditorReady()
                 editorDidBecomeAvailableListener?.onEditorAvailable(this)
                 this.didFireEditorLoaded = true
                 this.visibility = VISIBLE
@@ -691,14 +758,15 @@ class GutenbergView : WebView {
 
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
+        dependencyLoadingJob?.cancel()
         clearConfig()
         this.stopLoading()
-        (requestInterceptor as? CachedAssetRequestInterceptor)?.shutdown()
         FileCache.clearCache(context)
         contentChangeListener = null
         historyChangeListener = null
         featuredImageChangeListener = null
         editorDidBecomeAvailableListener = null
+        loadingListener = null
         filePathCallback = null
         onFileChooserRequested = null
         autocompleterTriggeredListener = null
@@ -708,26 +776,6 @@ class GutenbergView : WebView {
         this.destroy()
     }
 
-    private fun getCacheDirectory(configuration: EditorConfiguration): File {
-        var siteName = "shared"
-
-        if (configuration.siteURL.isNotEmpty()) {
-            try {
-                val url = URL(configuration.siteURL)
-                val host = url.host.replace(":", "-")
-                val path = url.path.replace("/", "-").trim('-')
-                siteName = if (path.isEmpty()) host else "$host-$path"
-
-                // Remove illegal characters
-                siteName = siteName.replace(Regex("[/:\\\\?%*|\"<>]"), "-")
-            } catch (e: Exception) {
-                Log.w("GutenbergView", "Failed to parse site URL for cache directory", e)
-            }
-        }
-
-        return File(context.filesDir, "editor-caches/$siteName")
-    }
-
     companion object {
         private const val ASSET_LOADING_TIMEOUT_MS = 5000L
 
@@ -748,7 +796,7 @@ class GutenbergView : WebView {
             // Create dedicated warmup WebView
             val webView = GutenbergView(context)
             webView.initializeWebView()
-            webView.start(configuration)
+            webView.start(configuration, EditorDependencies.empty)
             warmupWebView = webView
 
             // Schedule cleanup after assets are loaded

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

@@ -23,4 +23,13 @@ data class EditorDependencies(
      * This is `null` if preloading is disabled or no preload data is available.
      */
     val preloadList: EditorPreloadList?
-)
+) {
+    companion object {
+        /** Empty dependencies for use when no pre-fetched data is available. */
+        val empty = EditorDependencies(
+            editorSettings = EditorSettings.undefined,
+            assetBundle = EditorAssetBundle.empty,
+            preloadList = null
+        )
+    }
+}