feat: Discover Android demo app configuration (#225)

dcalhoun · web-flow · commit 07124da713a6 · 2025-11-12T15:09:45.000Z
* task: Add site discovery to Android demo app

Mirror the iOS demo app features.

* refactor: Rely upon wordpress-rs

* refactor: Prefer `lifecycleScope` over `CoroutineScope`

Follow best practices to avoid memory leaks.
diff --git a/android/app/src/main/java/com/example/gutenbergkit/MainActivity.kt b/android/app/src/main/java/com/example/gutenbergkit/MainActivity.kt
@@ -42,14 +42,18 @@ import com.example.gutenbergkit.ui.dialogs.AddConfigurationDialog
 import com.example.gutenbergkit.ui.dialogs.DeleteConfigurationDialog
 import com.example.gutenbergkit.ui.dialogs.DiscoveringSiteDialog
 import com.example.gutenbergkit.ui.theme.AppTheme
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.launch
 import org.wordpress.gutenberg.BuildConfig
 import org.wordpress.gutenberg.EditorConfiguration
 
 class MainActivity : ComponentActivity(), AuthenticationManager.AuthenticationCallback {
     private val configurations = mutableStateListOf<ConfigurationItem>()
     private val isDiscoveringSite = mutableStateOf(false)
+    private val isLoadingCapabilities = mutableStateOf(false)
     private lateinit var configurationStorage: ConfigurationStorage
     private lateinit var authenticationManager: AuthenticationManager
+    private val siteCapabilitiesDiscovery = SiteCapabilitiesDiscovery()
 
     companion object {
         const val EXTRA_CONFIGURATION = "configuration"
@@ -75,7 +79,7 @@ class MainActivity : ComponentActivity(), AuthenticationManager.AuthenticationCa
                     onConfigurationClick = { config ->
                         when (config) {
                             is ConfigurationItem.BundledEditor -> launchEditor(createBundledConfiguration())
-                            is ConfigurationItem.RemoteEditor -> launchEditor(createRemoteConfiguration(config))
+                            is ConfigurationItem.RemoteEditor -> loadRemoteEditor(config)
                         }
                     },
                     onConfigurationLongClick = { config ->
@@ -93,7 +97,8 @@ class MainActivity : ComponentActivity(), AuthenticationManager.AuthenticationCa
                         configurationStorage.saveConfigurations(configurations)
                     },
                     isDiscoveringSite = isDiscoveringSite.value,
-                    onDismissDiscovering = { isDiscoveringSite.value = false }
+                    onDismissDiscovering = { isDiscoveringSite.value = false },
+                    isLoadingCapabilities = isLoadingCapabilities.value
                 )
             }
         }
@@ -110,14 +115,42 @@ class MainActivity : ComponentActivity(), AuthenticationManager.AuthenticationCa
             .setCookies(emptyMap())
             .build()
 
-    private fun createRemoteConfiguration(config: ConfigurationItem.RemoteEditor): EditorConfiguration =
-        createCommonConfigurationBuilder()
-            .setPlugins(true)
-            .setSiteURL(config.siteUrl)
-            .setSiteApiRoot(config.siteApiRoot)
-            .setNamespaceExcludedPaths(arrayOf())
-            .setAuthHeader(config.authHeader)
-            .build()
+    private fun loadRemoteEditor(config: ConfigurationItem.RemoteEditor) {
+        isLoadingCapabilities.value = true
+
+        lifecycleScope.launch {
+            try {
+                val capabilities = siteCapabilitiesDiscovery.discoverCapabilities(
+                    siteApiRoot = config.siteApiRoot
+                )
+
+                val editorConfiguration = createCommonConfigurationBuilder()
+                    .setPlugins(capabilities.supportsPlugins)
+                    .setThemeStyles(capabilities.supportsThemeStyles)
+                    .setSiteURL(config.siteUrl)
+                    .setSiteApiRoot(config.siteApiRoot)
+                    .setNamespaceExcludedPaths(arrayOf())
+                    .setAuthHeader(config.authHeader)
+                    .build()
+
+                isLoadingCapabilities.value = false
+                launchEditor(editorConfiguration)
+            } catch (e: Exception) {
+                isLoadingCapabilities.value = false
+                // If capability discovery fails, use default configuration
+                val defaultConfiguration = createCommonConfigurationBuilder()
+                    .setPlugins(false)
+                    .setThemeStyles(false)
+                    .setSiteURL(config.siteUrl)
+                    .setSiteApiRoot(config.siteApiRoot)
+                    .setNamespaceExcludedPaths(arrayOf())
+                    .setAuthHeader(config.authHeader)
+                    .build()
+
+                launchEditor(defaultConfiguration)
+            }
+        }
+    }
 
     private fun createCommonConfigurationBuilder(): EditorConfiguration.Builder =
         EditorConfiguration.builder()
@@ -171,7 +204,8 @@ fun MainScreen(
     onAddConfiguration: (String) -> Unit,
     onDeleteConfiguration: (ConfigurationItem) -> Unit,
     isDiscoveringSite: Boolean = false,
-    onDismissDiscovering: () -> Unit = {}
+    onDismissDiscovering: () -> Unit = {},
+    isLoadingCapabilities: Boolean = false
 ) {
     var showAddDialog = remember { mutableStateOf(false) }
     var showDeleteDialog = remember { mutableStateOf<ConfigurationItem.RemoteEditor?>(null) }
@@ -295,6 +329,12 @@ fun MainScreen(
             onDismiss = onDismissDiscovering
         )
     }
+
+    if (isLoadingCapabilities) {
+        DiscoveringSiteDialog(
+            onDismiss = { /* Cannot dismiss while loading */ }
+        )
+    }
 }
 
 @OptIn(androidx.compose.foundation.ExperimentalFoundationApi::class)
diff --git a/android/app/src/main/java/com/example/gutenbergkit/SiteCapabilitiesDiscovery.kt b/android/app/src/main/java/com/example/gutenbergkit/SiteCapabilitiesDiscovery.kt
@@ -0,0 +1,83 @@
+package com.example.gutenbergkit
+
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import rs.wordpress.api.kotlin.ApiDiscoveryResult
+import rs.wordpress.api.kotlin.WpLoginClient
+
+/**
+ * Data class representing the capabilities discovered from a WordPress site.
+ */
+data class SiteCapabilities(
+    val supportsPlugins: Boolean,
+    val supportsThemeStyles: Boolean
+)
+
+/**
+ * Discovers WordPress site capabilities by querying the API root endpoint.
+ * This mirrors the iOS implementation's capability discovery logic.
+ */
+class SiteCapabilitiesDiscovery {
+
+    companion object {
+        private const val TAG = "SiteCapabilitiesDiscovery"
+
+        // Routes to check for capability support
+        private const val ROUTE_EDITOR_ASSETS = "/wpcom/v2/editor-assets"
+        private const val ROUTE_EDITOR_SETTINGS = "/wp-block-editor/v1/settings"
+    }
+
+    /**
+     * Discovers site capabilities via API discovery.
+     *
+     * @param siteApiRoot The WordPress REST API root URL (e.g., "https://example.com/wp-json")
+     * @return SiteCapabilities indicating which features are supported
+     */
+    suspend fun discoverCapabilities(
+        siteApiRoot: String,
+    ): SiteCapabilities = withContext(Dispatchers.IO) {
+        try {
+            // Extract the site URL from the API root URL
+            // e.g., "https://example.com/wp-json" -> "https://example.com"
+            val siteUrl = siteApiRoot.removeSuffix("/").substringBeforeLast("/wp-json")
+
+            // Use WpLoginClient to perform API discovery, which includes API details
+            when (val apiDiscoveryResult = WpLoginClient().apiDiscovery(siteUrl)) {
+                is ApiDiscoveryResult.Success -> {
+                    val success = apiDiscoveryResult.success
+                    val apiDetails = success.apiDetails
+
+                    // Check if the site has the required routes using hasRoute() method
+                    val supportsPlugins = apiDetails.hasRoute(ROUTE_EDITOR_ASSETS)
+                    val supportsThemeStyles = apiDetails.hasRoute(ROUTE_EDITOR_SETTINGS)
+
+                    Log.d(TAG, "Discovered capabilities - Plugins: $supportsPlugins, Theme Styles: $supportsThemeStyles")
+
+                    SiteCapabilities(
+                        supportsPlugins = supportsPlugins,
+                        supportsThemeStyles = supportsThemeStyles
+                    )
+                }
+                else -> {
+                    Log.w(TAG, "API discovery failed: $apiDiscoveryResult")
+                    getDefaultCapabilities()
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error discovering site capabilities", e)
+            getDefaultCapabilities()
+        }
+    }
+
+    /**
+     * Returns default capabilities when discovery fails.
+     * Conservative defaults: no plugins, no theme styles.
+     */
+    private fun getDefaultCapabilities(): SiteCapabilities {
+        return SiteCapabilities(
+            supportsPlugins = false,
+            supportsThemeStyles = false
+        )
+    }
+}
diff --git a/android/gradle/libs.versions.toml b/android/gradle/libs.versions.toml
@@ -15,7 +15,7 @@ mockito = "4.1.0"
 robolectric = "4.14.1"
 kotlinx-coroutines = '1.10.2'
 androidx-recyclerview = '1.3.2'
-wordpress-rs = 'trunk-503f1da9e067677d1517d09f926b1d038dfa58a1'
+wordpress-rs = 'trunk-d02efa6d4d56bc5b44dd2191e837163f9fa27095'
 composeBom = "2024.12.01"
 activityCompose = "1.9.3"
 
