[brownfield] Fix reading updates app.manifest and meta-data tags (expo#45655)

# Why

`expo-updates` would fail to read app.manifest and meta-data tags when
consuming it as a brownfield AAR, causing update to not start up
properly on android

# How

Extended `expo-brownfield`'s gradle plugin (`ExpoBrownfieldSetupPlugin`)
to forward the host `:app` module's build-time outputs into the
published brownfield AAR's release variant. Two pieces are forwarded:

1. **`:app:mergeReleaseAssets` output** is copied into a generated
source dir on the `:brownfield` library and registered as a
release-variant asset source. Forwarding the *merged* assets output
(rather than a specific generator task) is deliberate: it picks up
everything AGP would bundle into the host APK's `assets/` — the RN JS
bundle, expo-updates' `app.manifest`, expo-constants' `app.config`, and
any future generated asset emitted by a host-side gradle plugin. The old
`setupBundleDependencyForRelease` and the standalone
`generated/assets/react/release` source dir are now subsumed by this.

2. **Every `<application>` `<meta-data>` entry** from
`:app/src/main/AndroidManifest.xml` is forwarded into a generated
release-variant manifest on the `:brownfield` library, which AGP merges
into the consumer's manifest at AAR-consumption time. This covers
expo-updates, expo-notifications, expo-dev-launcher, and any other
config plugin that injects runtime configuration into the host manifest.
The forwarder also resolves `@string/...` references against
`:app/src/main/res/values/strings.xml` (inlining e.g.
`expo_runtime_version` → `"1.0.0"`) so the AAR doesn't need to also
forward `strings.xml`, and preserves `android:resource="..."` refs
alongside `android:value="..."`.
  

# Test Plan

End-to-end on Android:

1. **Publish the brownfield AAR to Maven Local**

   ```bash
   cd apps/minimal-tester
   npx expo-brownfield build:android --repository MavenLocal --release
   ```

2. **Verify the AAR carries the forwarded artifacts**

   ```bash

AAR=~/.m2/repository/com/community/minimaltester/brownfield/1.0.0/brownfield-1.0.0.aar
   unzip -l "$AAR" | grep -E 'assets/|AndroidManifest'
   unzip -p "$AAR" AndroidManifest.xml
   unzip -p "$AAR" assets/app.manifest
   unzip -p "$AAR" assets/app.config
   ```

3. **Run the brownfield consumer against the published AAR**

   ```bash
   cd apps/brownfield-tester/isolated/android
   ./gradlew assembleRelease
   ```

4. **Confirm the consumer's merged manifest picked up the forwarded
meta-data**

   ```bash
   grep -A1 expo.modules.updates \

apps/brownfield-tester/isolated/android/app/build/intermediates/merged_manifests/release/processReleaseManifest/AndroidManifest.xml
   ```

# Checklist

<!--
Please check the appropriate items below if they apply to your diff.
-->

- [ ] I added a `changelog.md` entry and rebuilt the package sources
according to [this short
guide](https://github.com/expo/expo/blob/main/CONTRIBUTING.md#-before-submitting)
- [ ] This diff will work correctly for `npx expo prebuild` & EAS Build
(eg: updated a module plugin).
- [ ] Conforms with the [Documentation Writing Style
Guide](https://github.com/expo/expo/blob/main/guides/Expo%20Documentation%20Writing%20Style%20Guide.md)

Author: gabrieldonadel

packages/expo-brownfield/CHANGELOG.md

@@ -8,6 +8,8 @@
 
 ### 🐛 Bug fixes
 
+- Fix reading updates app.manifest and meta-data tags ([#45655](https://github.com/expo/expo/pull/45655) by [@gabrieldonadel](https://github.com/gabrieldonadel))
+
 ### 💡 Others
 
 ## 56.0.5 — 2026-05-08

packages/expo-brownfield/gradle-plugins/brownfield/src/main/kotlin/expo/modules/plugin/ExpoBrownfieldSetupPlugin.kt

@@ -16,9 +16,9 @@ class ExpoBrownfieldSetupPlugin : Plugin<Project> {
     project.afterEvaluate { project ->
       setupSourceSets(project)
       setupCopyingAutolinking(project)
-      setupBundleDependencyForRelease(project)
       setupCopyingNativeLibsForType(project, "Release")
       setupCopyingNativeLibsForType(project, "Debug")
+      setupHostAppArtifactForwardingForRelease(project)
       wireDevLauncherTasks(project)
     }
   }
@@ -58,7 +58,7 @@ class ExpoBrownfieldSetupPlugin : Plugin<Project> {
 
     libraryExtension.sourceSets.getByName("release").apply {
       jniLibs.srcDirs("libsRelease")
-      assets.srcDirs("$appBuildDir/generated/assets/react/release")
+      // release assets src dir is wired in setupHostAppArtifactForwardingForRelease
       res.srcDirs("$appBuildDir/generated/res/react/release")
     }
 
@@ -120,18 +120,74 @@ class ExpoBrownfieldSetupPlugin : Plugin<Project> {
   }
 
   /**
-   * Setup the dependency of the bundle tasks.
+   * Forward the host `:app` module's build-time outputs into the published brownfield AAR so the
+   * runtime React Native + expo libraries inside the AAR find the configuration they need.
    *
-   * Needed to include bundle and assets in the release variant.
+   * Two pieces are forwarded:
    *
-   * @param brownfieldProject The brownfield project to setup the dependency of the bundle tasks
-   *   for.
+   *   1. `:app:mergeReleaseAssets` output (everything that AGP would bundle into the host APK's
+   *      `assets/`). This includes the RN JS bundle and hashed assets, expo-updates' `app.manifest`,
+   *      expo-constants' `app.config`, and any other generated asset emitted by a host-side gradle
+   *      plugin. Forwarding the merged output (rather than picking specific generator tasks) makes
+   *      this future-proof: any new expo library that emits an asset on the `:app` side is picked
+   *      up automatically. Transitive dep: `mergeReleaseAssets` requires `createBundleReleaseJsAndAssets`
+   *      so the old `setupBundleDependencyForRelease` is no longer needed.
+   *
+   *   2. Every `<application>` `<meta-data>` entry from `:app/src/main/AndroidManifest.xml`,
+   *      written into a generated release-variant manifest that AGP merges into the consumer.
+   *      Covers expo-updates' `EXPO_UPDATE_URL`, expo-notifications' default icon/color, and
+   *      anything else a config plugin injects.
+   *
+   * @param brownfieldProject The brownfield project.
    */
-  internal fun setupBundleDependencyForRelease(brownfieldProject: Project) {
+  internal fun setupHostAppArtifactForwardingForRelease(brownfieldProject: Project) {
     val appProject = findAppProject(brownfieldProject)
+    val mergeAssetsTask = appProject.tasks.findByName("mergeReleaseAssets") ?: run {
+      brownfieldProject.logger.lifecycle(
+        "brownfield: \":${appProject.name}:mergeReleaseAssets\" task not found; " +
+          "skipping host-app asset forwarding."
+      )
+      return
+    }
+
+    val libraryExtension = getLibraryExtension(brownfieldProject)
+    val moduleBuildDir = brownfieldProject.layout.buildDirectory.get().asFile
+
+    val hostAssetsDir = File(moduleBuildDir, "generated/assets/hostApp/release")
+    val copyHostAssetsTask =
+      brownfieldProject.tasks.register("copyHostAppAssetsRelease", Copy::class.java) { task ->
+        task.dependsOn(mergeAssetsTask)
+        task.from(mergeAssetsTask.outputs.files)
+        task.into(hostAssetsDir)
+      }
+    libraryExtension.sourceSets.getByName("release").assets.srcDirs(hostAssetsDir)
+
+    val hostManifestFile =
+      File(moduleBuildDir, "generated/manifest/hostApp/release/AndroidManifest.xml")
+    val appManifest = File(appProject.projectDir, "src/main/AndroidManifest.xml")
+    val appStrings = File(appProject.projectDir, "src/main/res/values/strings.xml")
+
+    val generateHostManifestTask =
+      brownfieldProject.tasks.register("generateBrownfieldHostAppManifestRelease") { task ->
+        task.inputs.file(appManifest)
+        if (appStrings.exists()) {
+          task.inputs.file(appStrings)
+        }
+        task.outputs.file(hostManifestFile)
+        task.doLast {
+          hostManifestFile.parentFile.mkdirs()
+          hostManifestFile.writeText(buildForwardedApplicationManifest(appManifest, appStrings))
+        }
+      }
+    libraryExtension.sourceSets.getByName("release").manifest.srcFile(hostManifestFile)
+
     brownfieldProject.tasks.named("preReleaseBuild").configure { task ->
-      task.dependsOn(":${appProject.name}:createBundleReleaseJsAndAssets")
+      task.dependsOn(copyHostAssetsTask)
+      task.dependsOn(generateHostManifestTask)
     }
+    brownfieldProject.tasks
+      .matching { it.name == "processReleaseManifest" || it.name == "processReleaseMainManifest" }
+      .configureEach { task -> task.dependsOn(generateHostManifestTask) }
   }
 
   /**
@@ -266,7 +322,7 @@ class ExpoBrownfieldSetupPlugin : Plugin<Project> {
   /**
    * Add explicit dependency between the `sourceDebugJar` and `generateServiceApolloSources`
    * tasks in `expo-dev-launcher` project.
-   * 
+   *
    * @param brownfieldProject The brownfield project
    */
   private fun wireDevLauncherTasks(brownfieldProject: Project) {
@@ -275,7 +331,7 @@ class ExpoBrownfieldSetupPlugin : Plugin<Project> {
 
       val sourceDebugTask = devLauncherProject.tasks.findByName("sourceDebugJar")
       val apolloSourcesTask = devLauncherProject.tasks.findByName("generateServiceApolloSources")
-      
+
       if (sourceDebugTask == null || apolloSourcesTask == null) {
         brownfieldProject.logger.warn("WARNING: Application uses expo-dev-launcher but tasks: sourceDebugJar and generateServiceApolloSources")
         brownfieldProject.logger.warn("Skipping explicitly defining dependency between the tasks...")
@@ -284,7 +340,7 @@ class ExpoBrownfieldSetupPlugin : Plugin<Project> {
 
       sourceDebugTask.dependsOn(apolloSourcesTask)
     } catch (e: GradleException) {
-      // no-op  
+      // no-op
     }
   }
 }

packages/expo-brownfield/gradle-plugins/brownfield/src/main/kotlin/expo/modules/plugin/utils.kt

@@ -1,6 +1,11 @@
+@file:JvmName("BrownfieldSetupUtilsKt")
+
 package expo.modules.plugin
 
+import java.io.File
+import javax.xml.parsers.DocumentBuilderFactory
 import org.gradle.api.Project
+import org.w3c.dom.Element
 
 /**
  * Find the app project in the root project.
@@ -14,3 +19,103 @@ internal fun findAppProject(project: Project): Project {
     it.plugins.hasPlugin("com.android.application")
   } ?: throw IllegalStateException("App project not found in the root project")
 }
+
+/**
+ * Build a release-variant AndroidManifest.xml that forwards every `<application>`
+ * `<meta-data>` entry from the expo app's manifest into the brownfield library's release
+ * manifest, so AGP merges them into the consumer's manifest at AAR consumption time.
+ *
+ * This covers any expo library whose config plugin injects runtime configuration into
+ * the expo app's AndroidManifest at `expo prebuild` time (expo-updates, expo-notifications,
+ * etc.). Without forwarding, the brownfield library's runtime modules read empty meta-data
+ * and silently disable themselves.
+ *
+ * Value forms supported:
+ *   - Literal `android:value="..."` (preserved as-is).
+ *   - String resource refs `android:value="@string/foo"` are resolved against the expo
+ *     app's `res/values/strings.xml` and inlined. The brownfield AAR cannot share those
+ *     strings with the consumer because resources are not currently forwarded.
+ *   - `android:resource="@drawable/foo"` (or any other resource ref) is preserved as a
+ *     `resource` attribute. Note: for the consumer to actually resolve it, the referenced
+ *     resource needs to ship in the brownfield AAR (drawable, color, etc.).
+ */
+fun buildForwardedApplicationManifest(appManifest: File, appStrings: File): String {
+  val empty = """<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />
+"""
+  if (!appManifest.exists()) return empty
+
+  val factory = DocumentBuilderFactory.newInstance().apply { isNamespaceAware = false }
+  val doc = factory.newDocumentBuilder().parse(appManifest)
+  val applicationNodes = doc.getElementsByTagName("application")
+  if (applicationNodes.length == 0) return empty
+  val applicationEl = applicationNodes.item(0) as? Element ?: return empty
+
+  val strings = parseStringResources(appStrings)
+  val children = applicationEl.childNodes
+
+  data class MetaEntry(val name: String, val attr: String, val value: String)
+  val entries = mutableListOf<MetaEntry>()
+  for (i in 0 until children.length) {
+    val el = children.item(i) as? Element ?: continue
+    if (el.tagName != "meta-data") continue
+    val name = el.getAttribute("android:name")
+    if (name.isNullOrEmpty()) continue
+    val literalValue = el.getAttribute("android:value")
+    val resourceRef = el.getAttribute("android:resource")
+    when {
+      !literalValue.isNullOrEmpty() ->
+        entries.add(MetaEntry(name, "android:value", resolveResourceReference(literalValue, strings)))
+      !resourceRef.isNullOrEmpty() ->
+        entries.add(MetaEntry(name, "android:resource", resourceRef))
+    }
+  }
+  if (entries.isEmpty()) return empty
+
+  return buildString {
+    append("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")
+    append("<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\">\n")
+    append("  <application>\n")
+    entries.forEach { entry ->
+      append("    <meta-data android:name=\"")
+      append(escapeXmlAttribute(entry.name))
+      append("\" ")
+      append(entry.attr)
+      append("=\"")
+      append(escapeXmlAttribute(entry.value))
+      append("\" />\n")
+    }
+    append("  </application>\n")
+    append("</manifest>\n")
+  }
+}
+
+private fun parseStringResources(file: File): Map<String, String> {
+  if (!file.exists()) return emptyMap()
+  val factory = DocumentBuilderFactory.newInstance().apply { isNamespaceAware = false }
+  val doc = factory.newDocumentBuilder().parse(file)
+  val list = doc.getElementsByTagName("string")
+  val result = mutableMapOf<String, String>()
+  for (i in 0 until list.length) {
+    val el = list.item(i) as? Element ?: continue
+    val name = el.getAttribute("name") ?: continue
+    if (name.isEmpty()) continue
+    result[name] = el.textContent
+  }
+  return result
+}
+
+private fun resolveResourceReference(raw: String, strings: Map<String, String>): String {
+  if (raw.startsWith("@string/")) {
+    val key = raw.removePrefix("@string/")
+    return strings[key] ?: raw
+  }
+  return raw
+}
+
+private fun escapeXmlAttribute(value: String): String =
+  value.replace("&", "&amp;")
+    .replace("<", "&lt;")
+    .replace(">", "&gt;")
+    .replace("\"", "&quot;")
+    .replace("'", "&apos;")