expo-modules-autolinking 3.1.0-canary-20251210-1f163e3 → 3.1.0-canary-20251211-7da85ea

package/CHANGELOG.md

@@ -43,6 +43,7 @@
 
 - Refactor test suite and file discovery implementation to drop `glob` ([#40601](https://github.com/expo/expo/pull/40601) by [@kitten](https://github.com/kitten))
 - Improve recursive dependency resolution performance ([#40651](https://github.com/expo/expo/pull/40651) by [@kitten](https://github.com/kitten))
+- Add `expo-max-sdk-override-plugin` gradle plugin to change the default manifest merger behaviour for `android:maxSdkVersion` conflicts. ([#40973](https://github.com/expo/expo/pull/40973) by [@behenate](https://github.com/behenate))
 
 ## 3.0.19 - 2025-10-23
 

package/android/expo-gradle-plugin/expo-autolinking-settings-plugin/src/main/kotlin/expo/modules/plugin/ExpoAutolinkingSettingsPlugin.kt

@@ -3,9 +3,13 @@ package expo.modules.plugin
 import expo.modules.plugin.gradle.addBuildCache
 import expo.modules.plugin.gradle.beforeRootProject
 import expo.modules.plugin.gradle.loadLocalProperties
+import expo.modules.plugin.text.Colors
+import expo.modules.plugin.text.withColor
 import expo.modules.plugin.utils.getPropertiesPrefixedBy
 import org.gradle.api.Plugin
+import org.gradle.api.UnknownProjectException
 import org.gradle.api.initialization.Settings
+import org.gradle.internal.cc.base.logger
 import java.io.File
 import java.util.Properties
 
@@ -28,7 +32,10 @@ open class ExpoAutolinkingSettingsPlugin : Plugin<Settings> {
         rootProject
           .buildscript
           .dependencies
-          .add("classpath", "expo.modules:expo-autolinking-plugin")
+          .apply {
+            add("classpath", "expo.modules:expo-autolinking-plugin")
+            add("classpath", "expo.modules:expo-max-sdk-override-plugin")
+          }
       }
 
       // Includes the `expo-gradle-plugin` subproject.
@@ -36,6 +43,8 @@ open class ExpoAutolinkingSettingsPlugin : Plugin<Settings> {
         expoGradlePluginsFile.absolutePath
       )
     }
+
+    configureMaxSdkOverridePlugin(settings)
   }
 
   private fun getExpoGradlePluginsFile(settings: Settings): File {
@@ -52,4 +61,22 @@ open class ExpoAutolinkingSettingsPlugin : Plugin<Settings> {
       "android/expo-gradle-plugin"
     )
   }
+
+  private fun configureMaxSdkOverridePlugin(settings: Settings) {
+    settings.gradle.beforeRootProject { rootProject ->
+      try {
+        rootProject.project(":app") { appProject ->
+          appProject.pluginManager.withPlugin("com.android.application") {
+            appProject.pluginManager.apply("expo-max-sdk-override-plugin")
+          }
+        }
+      } catch (e: UnknownProjectException) {
+        logger.error(
+          " ℹ️  Failed to apply gradle plugin ".withColor(Colors.RESET)
+            + "'expo-max-sdk-override-plugin'".withColor(Colors.GREEN)
+            + ". Plugin has failed to find the ':app' project. It will not be applied.".withColor(Colors.RESET)
+        )
+      }
+    }
+  }
 }

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/build.gradle.kts

@@ -0,0 +1,44 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+  kotlin("jvm")
+  id("java-gradle-plugin")
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation(project(":expo-autolinking-plugin-shared"))
+  implementation(gradleApi())
+  compileOnly("com.android.tools.build:gradle:8.5.0")
+
+  testImplementation("junit:junit:4.13.2")
+  testImplementation("com.google.truth:truth:1.1.2")
+  testImplementation(gradleTestKit())
+}
+
+java {
+  sourceCompatibility = JavaVersion.VERSION_11
+  targetCompatibility = JavaVersion.VERSION_11
+}
+
+tasks.withType<KotlinCompile> {
+  compilerOptions {
+    jvmTarget.set(JvmTarget.JVM_11)
+  }
+}
+
+group = "expo.modules"
+
+gradlePlugin {
+  plugins {
+    create("expoMaxSdkOverridePlugin") {
+      id = "expo-max-sdk-override-plugin"
+      implementationClass = "expo.modules.plugin.ExpoMaxSdkOverridePlugin"
+    }
+  }
+}

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/src/main/kotlin/expo/modules/plugin/AnalyzeManifestReport.kt

@@ -0,0 +1,69 @@
+package expo.modules.plugin
+
+import expo.modules.plugin.utils.extractPathFromLine
+
+/**
+ * Analyzes the manifest merge report content to find permissions that may be defined with android:maxSdkVersion,
+ * where one AndroidManifest.xml defines the permission with the aforementioned annotation and another one without.
+ *
+ * This method should be used to reduce the search scope for `findPermissionsToOverride` method.
+ *
+ * @param reportContent The content of the manifest merge report to analyze.
+ * @return A map of suspicious permission names to their corresponding PermissionInfo objects.
+ */
+internal fun analyzeManifestReport(reportContent: String): Map<String, PermissionInfo> {
+  val allPermissionInfo = mutableMapOf<String, PermissionInfo>()
+  var currentPermission: String? = null
+  var lastAttributeWasMaxSdk = false
+
+  for (line in reportContent.lines()) {
+    val trimmedLine = line.trimStart()
+
+    // This line starts a new permission definition
+    if (line.startsWith("uses-permission#")) {
+      currentPermission = line.substringAfter("uses-permission#").trim()
+      allPermissionInfo.getOrPut(currentPermission) {
+        PermissionInfo()
+      }
+      lastAttributeWasMaxSdk = false
+    } else if (currentPermission != null) {
+      when {
+        trimmedLine.startsWith("android:maxSdkVersion") -> {
+          lastAttributeWasMaxSdk = true
+        }
+
+        // Source of maxSdkVersion annotation
+        line.startsWith("\t") && (trimmedLine.startsWith("ADDED from") || trimmedLine.startsWith("MERGED from")) -> {
+          if (lastAttributeWasMaxSdk) {
+            extractPathFromLine(line)?.let { source ->
+              allPermissionInfo[currentPermission]?.maxSdkSources?.add(source)
+            }
+          }
+          lastAttributeWasMaxSdk = false
+        }
+
+        // Source of the permission definition
+        !line.startsWith("\t") && (trimmedLine.startsWith("ADDED from") || trimmedLine.startsWith("MERGED from")) -> {
+          extractPathFromLine(line)?.let { path ->
+            allPermissionInfo[currentPermission]?.manifestPaths?.add(path)
+          }
+          lastAttributeWasMaxSdk = false
+        }
+
+        else -> {
+          lastAttributeWasMaxSdk = false
+        }
+      }
+    }
+  }
+
+  // Permissions which may have maxSdkConflicts, happen when there is more than one
+  // source fora a permission and the permission is annotated with maxSdkVersion
+  val problematicPermissions = allPermissionInfo.filter { (permission, info) ->
+    val multipleDefinitions = info.manifestPaths.size > 1
+    val maxSdkDefined = info.maxSdkSources.isNotEmpty()
+    multipleDefinitions && maxSdkDefined
+  }
+
+  return problematicPermissions.toMap()
+}

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/src/main/kotlin/expo/modules/plugin/ExpoMaxSdkOverridePlugin.kt

@@ -0,0 +1,44 @@
+package expo.modules.plugin
+
+import com.android.build.api.artifact.SingleArtifact
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import com.android.build.api.variant.ApplicationAndroidComponentsExtension
+import expo.modules.plugin.text.Colors
+import expo.modules.plugin.text.Emojis
+import expo.modules.plugin.text.withColor
+import org.gradle.internal.cc.base.logger
+
+/**
+ * Plugin, which registers ExpoMaxSdkOverrideTask and schedules it to run with `app:processDebugManifest`.
+ *
+ * The task finds all permissions declared with `android:maxSdkVersion`. If the permission was declared in more than one place, and one of the places
+ * defines the task without `android:maxSdkVersion` the task will remove the `android:maxSdkVersion` from the final merged manifest
+ */
+class ExpoMaxSdkOverridePlugin : Plugin<Project> {
+  override fun apply(project: Project) {
+    val androidComponents = project.extensions.getByType(ApplicationAndroidComponentsExtension::class.java)
+    logger.quiet(" ${Emojis.INFORMATION}  ${"Applying gradle plugin".withColor(Colors.YELLOW)} '${"expo-max-sdk-override-plugin".withColor(Colors.GREEN)}'")
+    logger.quiet("  [expo-max-sdk-override-plugin] This plugin will find all permissions declared with `android:maxSdkVersion`. If there exists a declaration with the `android:maxSdkVersion` annotation and another one without, the plugin will remove the annotation from the final merged manifest. In order to see a log with the changes run a clean build of the app.")
+
+    androidComponents.onVariants(androidComponents.selector().all()) { variant ->
+      val taskName = "expo${variant.name.replaceFirstChar { it.uppercase() }}OverrideMaxSdkConflicts"
+      val blameReportPath = "outputs/logs/manifest-merger-${variant.name}-report.txt"
+      val reportFile = project.layout.buildDirectory.file(blameReportPath)
+      val fixTaskProvider = project.tasks.register(
+        taskName,
+        FixManifestMaxSdkTask::class.java
+      ) { task ->
+        task.blameReportFile.set(reportFile)
+      }
+
+      variant.artifacts
+        .use(fixTaskProvider)
+        .wiredWithFiles(
+          FixManifestMaxSdkTask::mergedManifestIn,
+          FixManifestMaxSdkTask::modifiedManifestOut
+        )
+        .toTransform(SingleArtifact.MERGED_MANIFEST)
+    }
+  }
+}

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/src/main/kotlin/expo/modules/plugin/ExpoMaxSdkOverrideTask.kt

@@ -0,0 +1,129 @@
+package expo.modules.plugin
+
+import expo.modules.plugin.text.Colors
+import expo.modules.plugin.text.withColor
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+import java.io.File
+import javax.xml.parsers.DocumentBuilderFactory
+import javax.xml.transform.OutputKeys
+import javax.xml.transform.TransformerFactory
+import javax.xml.transform.dom.DOMSource
+import javax.xml.transform.stream.StreamResult
+
+/**
+ * This task reads the manifest merge report, finds conflicting permissions, and removes 'android:maxSdkVersion' from them in the final merged manifest.
+ */
+abstract class FixManifestMaxSdkTask : DefaultTask() {
+  @get:InputFile
+  abstract val blameReportFile: RegularFileProperty
+
+  @get:InputFile
+  abstract val mergedManifestIn: RegularFileProperty
+
+  @get:OutputFile
+  abstract val modifiedManifestOut: RegularFileProperty
+
+  @TaskAction
+  fun taskAction() {
+    val blameFile = blameReportFile.get().asFile
+    val inManifest = mergedManifestIn.get().asFile
+    val outManifest = modifiedManifestOut.get().asFile
+
+    logger.quiet("---------- Expo Max Sdk Override Plugin ----------".withColor(Colors.YELLOW))
+
+    if (!blameFile.exists()) {
+      logger.warn("Manifest blame report not found: ${blameFile.absolutePath}. Skipping `android:maxSdkVersion` permission conflict check.")
+      inManifest.copyTo(outManifest, overwrite = true)
+      logNoChanges()
+      return
+    }
+
+    val reportContents = blameFile.readText()
+    val potentialProblems = analyzeManifestReport(reportContents)
+
+    if (potentialProblems.isEmpty()) {
+      inManifest.copyTo(outManifest, overwrite = true)
+      logNoChanges()
+      return
+    }
+
+    val brokenPermissions = findPermissionsToOverride(potentialProblems)
+
+    if (brokenPermissions.isEmpty()) {
+      inManifest.copyTo(outManifest, overwrite = true)
+      logNoChanges()
+      return
+    }
+
+    logger.quiet(">>> WARNING: Found ${brokenPermissions.size} permission(s) with conflicting 'android:maxSdkVersion' declarations.".withColor(Colors.YELLOW))
+    brokenPermissions.forEach { (permission, info) ->
+      val sourcesWithoutMaxSdk = info.manifestPaths.subtract(info.maxSdkSources)
+      logger.quiet("    - $permission".withColor(Colors.YELLOW))
+      logger.quiet("      > Defined WITH `android:maxSdkVersion` in: ${info.maxSdkSources.joinToString()}".withColor(Colors.YELLOW))
+      logger.quiet("      > Defined WITHOUT `android:maxSdkVersion` in: ${sourcesWithoutMaxSdk.joinToString()}".withColor(Colors.YELLOW))
+    }
+    logger.quiet(">>> Removing 'android:maxSdkVersion' from these permissions in the final manifest to prevent runtime issues.".withColor(Colors.YELLOW))
+
+    tryFixManifest(inManifest, outManifest, brokenPermissions)
+
+    logger.quiet("--------------------------------------------------".withColor(Colors.YELLOW))
+  }
+
+  private fun logNoChanges() {
+    logger.quiet(">>> No 'android:maxSdkVersion' conflicts found".withColor(Colors.GREEN))
+    logger.quiet("--------------------------------------------------".withColor(Colors.YELLOW))
+  }
+
+  private fun tryFixManifest(inManifest: File, outManifest: File, brokenPermissions: Map<String, PermissionInfo>) {
+    try {
+      val factory = DocumentBuilderFactory.newInstance().apply {
+        isNamespaceAware = true
+      }
+      val builder = factory.newDocumentBuilder()
+
+      val doc = builder.parse(inManifest)
+      val permissionNodes = doc.getElementsByTagName(ManifestConstants.USES_PERMISSION_TAG)
+      var modificationsMade = 0
+
+      val nodesToProcess = (0 until permissionNodes.length)
+        .map { permissionNodes.item(it) }
+        .filterIsInstance<org.w3c.dom.Element>()
+
+      for (element in nodesToProcess) {
+        val permissionName = element.getAttribute(ManifestConstants.ANDROID_NAME_ATTRIBUTE)
+
+        if (brokenPermissions.containsKey(permissionName) && element.hasAttribute(ManifestConstants.ANDROID_MAX_SDK_VERSION_ATTRIBUTE)) {
+          element.removeAttribute(ManifestConstants.ANDROID_MAX_SDK_VERSION_ATTRIBUTE)
+          modificationsMade++
+        }
+      }
+
+      if (modificationsMade > 0) {
+        logger.quiet(">>> Removed 'android:maxSdkVersion' from $modificationsMade instance(s) in the final manifest.".withColor(Colors.YELLOW))
+      }
+
+      TransformerFactory.newInstance().newTransformer().apply {
+        setOutputProperty(OutputKeys.INDENT, "yes")
+        setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4")
+        setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no")
+        setOutputProperty(OutputKeys.ENCODING, "UTF-8")
+        transform(DOMSource(doc), StreamResult(outManifest))
+      }
+    } catch (e: Exception) {
+      logger.error("Failed to parse and fix merged manifest: ${e.message}".withColor(Colors.RESET), e)
+      logger.quiet(">>> Restored the original merged manifest.".withColor(Colors.YELLOW))
+
+      inManifest.copyTo(outManifest, overwrite = true)
+    }
+  }
+}
+
+private object ManifestConstants {
+  const val USES_PERMISSION_TAG = "uses-permission"
+  const val ANDROID_NAME_ATTRIBUTE = "android:name"
+  const val ANDROID_MAX_SDK_VERSION_ATTRIBUTE = "android:maxSdkVersion"
+}

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/src/main/kotlin/expo/modules/plugin/FindPermissionsToOverride.kt

@@ -0,0 +1,62 @@
+package expo.modules.plugin
+
+import org.gradle.internal.cc.base.logger
+import java.io.File
+import javax.xml.parsers.DocumentBuilderFactory
+
+/**
+ * Based on a map of `String` and `PermissionInfo` read and parse manifest files, finds cases where
+ * a permission is defined in one place with `android:maxSdkVersion` and in another without that annotation.
+ *
+ * @param problematicPermissions A Map of `String` and `PermissionInfo` obtained with analyzeManifestReport
+ */
+internal fun findPermissionsToOverride(problematicPermissions: Map<String, PermissionInfo>): Map<String, PermissionInfo> {
+  val factory = DocumentBuilderFactory.newInstance()
+  factory.isNamespaceAware = true
+
+  // Basic security
+  factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true) // Disallow parsing <!DOCTYPE> files
+  factory.setFeature("http://xml.org/sax/features/external-general-entities", false) // Prevent external general entities
+  factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false) // Prevent external paramater entities
+
+  val builder = factory.newDocumentBuilder()
+  val brokenPermissions = mutableMapOf<String, PermissionInfo>()
+
+  problematicPermissions.forEach { permission, info ->
+    // Not actually a problematic permission
+    if (info.maxSdkSources.size == 0) {
+      return@forEach
+    }
+
+    info.manifestPaths.forEach { manifestPath ->
+      try {
+        val file = File(manifestPath)
+        if (!file.exists() || !file.canRead()) {
+          logger.error("Failed to open manifest file at: $manifestPath")
+          return@forEach
+        }
+
+        val doc = builder.parse(file)
+        val permissionNodes = doc.getElementsByTagName("uses-permission")
+
+        for (i in 0 until permissionNodes.length) {
+          val permissionNode = permissionNodes.item(i)
+
+          if (permissionNode.nodeType == org.w3c.dom.Node.ELEMENT_NODE) {
+            val element = permissionNode as org.w3c.dom.Element
+            val permissionName = element.getAttribute("android:name")
+
+            if (permissionName == permission && !element.hasAttribute("android:maxSdkVersion")) {
+              brokenPermissions[permission] = info
+              return@forEach
+            }
+          }
+        }
+      } catch (e: Exception) {
+        logger.error("Failed to parse manifest at ${manifestPath}", e)
+      }
+    }
+  }
+
+  return brokenPermissions
+}

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/src/main/kotlin/expo/modules/plugin/PermissionInfo.kt

@@ -0,0 +1,6 @@
+package expo.modules.plugin
+
+internal data class PermissionInfo(
+  val maxSdkSources: MutableSet<String> = mutableSetOf(),
+  val manifestPaths: MutableSet<String> = mutableSetOf()
+)

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/src/main/kotlin/expo/modules/plugin/utils/ExtractPathFromLine.kt

@@ -0,0 +1,16 @@
+package expo.modules.plugin.utils
+
+/**
+ * Extracts a single file path from one line of an AndroidManifest merge log.
+ *
+ * @param line The raw single-line string from the build log.
+ * @return A String containing the absolute file path to the manifest, or null if no path is found.
+ */
+fun extractPathFromLine(line: String): String? {
+  // Regex to find a path starting with '/' and ending just before
+  // the line/column numbers (e.g., :11:3)
+  val regex = Regex("(/.*?):\\d+:\\d+.*")
+  val match = regex.find(line)
+
+  return match?.groups?.get(1)?.value
+}

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/src/test/java/expo/modules/plugin/AnalyzeManifestReportTest.kt

@@ -0,0 +1,102 @@
+package expo.modules.plugin
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class AnalyzeManifestReportTest {
+
+  @Test
+  fun `finds permission with conflict`() {
+    val reportContent = """
+            uses-permission#android.permission.READ_CONTACTS
+              MERGED from /Users/user/project/app/src/main/AndroidManifest.xml:11:3-33
+              MERGED from /Users/user/project/library/src/main/AndroidManifest.xml:15:3-83
+            	android:maxSdkVersion
+            		ADDED from /Users/user/project/library/src/main/AndroidManifest.xml:16:7-34
+        """.trimIndent()
+
+    val problems = analyzeManifestReport(reportContent)
+
+    assertThat(problems).hasSize(1)
+    assertThat(problems).containsKey("android.permission.READ_CONTACTS")
+
+    val info = problems["android.permission.READ_CONTACTS"]
+    assertThat(info).isNotNull()
+
+    info?.let {
+      assertThat(info.manifestPaths).containsExactly(
+        "/Users/user/project/app/src/main/AndroidManifest.xml",
+        "/Users/user/project/library/src/main/AndroidManifest.xml"
+      )
+      assertThat(info.maxSdkSources).containsExactly(
+        "/Users/user/project/library/src/main/AndroidManifest.xml"
+      )
+    }
+  }
+
+  @Test
+  fun `ignores permission with no conflict`() {
+    val reportContent = """
+            uses-permission#android.permission.READ_CONTACTS
+              MERGED from /Users/user/project/app/src/main/AndroidManifest.xml:11:3-33
+              MERGED from /Users/user/project/library/src/main/AndroidManifest.xml:15:3-83
+        """.trimIndent()
+
+    val problems = analyzeManifestReport(reportContent)
+    assertThat(problems).isEmpty()
+  }
+
+  @Test
+  fun `ignores permission with only one source`() {
+    val reportContent = """
+            uses-permission#android.permission.READ_CONTACTS
+              MERGED from /Users/user/project/app/src/main/AndroidManifest.xml:11:3-33
+            	android:maxSdkVersion
+            		ADDED from /Users/user/project/app/src/main/AndroidManifest.xml:12:7-34
+        """.trimIndent()
+
+    val problems = analyzeManifestReport(reportContent)
+
+    assertThat(problems).isEmpty()
+  }
+
+  @Test
+  fun `handles multiple permissions`() {
+    val reportContent = """
+            uses-permission#android.permission.READ_CONTACTS
+              MERGED from /Users/user/project/app/src/main/AndroidManifest.xml:11:3-33
+              MERGED from /Users/user/project/library/src/main/AndroidManifest.xml:15:3-83
+            	android:maxSdkVersion
+            		ADDED from /Users/user/project/library/src/main/AndroidManifest.xml:16:7-34
+            
+            uses-permission#android.permission.WRITE_EXTERNAL_STORAGE
+              MERGED from /Users/user/project/app/src/main/AndroidManifest.xml:13:3-33
+            
+            uses-permission#android.permission.READ_EXTERNAL_STORAGE
+              MERGED from /Users/user/project/app/src/main/AndroidManifest.xml:14:3-33
+              MERGED from /Users/user/project/otherlib/src/main/AndroidManifest.xml:9:3-83
+            	android:maxSdkVersion
+            		ADDED from /Users/user/project/app/src/main/AndroidManifest.xml:15:7-34
+        """.trimIndent()
+
+    val problems = analyzeManifestReport(reportContent)
+
+    assertThat(problems).hasSize(2)
+    assertThat(problems).containsKey("android.permission.READ_CONTACTS")
+    assertThat(problems).containsKey("android.permission.READ_EXTERNAL_STORAGE")
+
+    val readContactsInfo = problems["android.permission.READ_CONTACTS"]!!
+    assertThat(readContactsInfo.maxSdkSources).containsExactly(
+      "/Users/user/project/library/src/main/AndroidManifest.xml"
+    )
+
+    val readStorageInfo = problems["android.permission.READ_EXTERNAL_STORAGE"]!!
+    assertThat(readStorageInfo.manifestPaths).containsExactly(
+      "/Users/user/project/app/src/main/AndroidManifest.xml",
+      "/Users/user/project/otherlib/src/main/AndroidManifest.xml"
+    )
+    assertThat(readStorageInfo.maxSdkSources).containsExactly(
+      "/Users/user/project/app/src/main/AndroidManifest.xml"
+    )
+  }
+}

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/src/test/java/expo/modules/plugin/ExtractPathFromLineTest.kt

@@ -0,0 +1,35 @@
+package expo.modules.plugin.utils
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class ExtractPathFromLineTest {
+
+  @Test
+  fun `extracts path from a standard merge log line`() {
+    val line = "\tMERGED from /Users/user/project/app/src/main/AndroidManifest.xml:11:3-33"
+    val path = extractPathFromLine(line)
+    assertThat(path).isEqualTo("/Users/user/project/app/src/main/AndroidManifest.xml")
+  }
+
+  @Test
+  fun `extracts path from an ADDED line`() {
+    val line = "  ADDED from /Users/user/project/library/build/intermediates/merged_manifest/debug/AndroidManifest.xml:23:7-77"
+    val path = extractPathFromLine(line)
+    assertThat(path).isEqualTo("/Users/user/project/library/build/intermediates/merged_manifest/debug/AndroidManifest.xml")
+  }
+
+  @Test
+  fun `extracts path from an ADDED line with space`() {
+    val line = "  ADDED from /Users/happy user/project/library/build/intermediates/merged_manifest/debug/AndroidManifest.xml:23:7-77"
+    val path = extractPathFromLine(line)
+    assertThat(path).isEqualTo("/Users/happy user/project/library/build/intermediates/merged_manifest/debug/AndroidManifest.xml")
+  }
+
+  @Test
+  fun `returns null if no path is found`() {
+    val line = "\tandroid:maxSdkVersion"
+    val path = extractPathFromLine(line)
+    assertThat(path).isNull()
+  }
+}

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/src/test/java/expo/modules/plugin/FindPermissionsToOverrideTest.kt

@@ -0,0 +1,91 @@
+package expo.modules.plugin
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+class FindPermissionsToOverrideTest {
+
+  @get:Rule
+  val tempFolder = TemporaryFolder()
+
+  private lateinit var manifestWithMaxSdk: File
+  private lateinit var manifestWithoutMaxSdk: File
+
+  @Before
+  fun setup() {
+    manifestWithMaxSdk = File(tempFolder.root, "max_sdk_manifest.xml")
+    manifestWithMaxSdk.writeText("""
+            <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+                <uses-permission 
+                    android:name="android.permission.READ_CONTACTS" 
+                    android:maxSdkVersion="28" />
+            </manifest>
+        """.trimIndent())
+
+    manifestWithoutMaxSdk = File(tempFolder.root, "no_max_sdk_manifest.xml")
+    manifestWithoutMaxSdk.writeText("""
+            <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+                <uses-permission android:name="android.permission.READ_CONTACTS" />
+                <uses-permission android:name="android.permission.WRITE_CALENDAR" />
+            </manifest>
+        """.trimIndent())
+  }
+
+  @Test
+  fun `finds permission that needs to be overridden`() {
+    val permissionInfo = PermissionInfo(
+      maxSdkSources = mutableSetOf(manifestWithMaxSdk.absolutePath),
+      manifestPaths = mutableSetOf(
+        manifestWithMaxSdk.absolutePath,
+        manifestWithoutMaxSdk.absolutePath
+      )
+    )
+    val problems = mapOf("android.permission.READ_CONTACTS" to permissionInfo)
+    val overrides = findPermissionsToOverride(problems)
+
+    assertThat(overrides).hasSize(1)
+    assertThat(overrides).containsKey("android.permission.READ_CONTACTS")
+  }
+
+  @Test
+  fun `does not find override if no conflict exists`() {
+    val manifestWithMaxSdk2 = File(tempFolder.root, "max_sdk_manifest_2.xml")
+    manifestWithMaxSdk2.writeText("""
+            <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+                <uses-permission android:name="android.permission.READ_CONTACTS" android:maxSdkVersion="28" />
+            </manifest>
+        """.trimIndent())
+
+    val permissionInfo = PermissionInfo(
+      maxSdkSources = mutableSetOf(manifestWithMaxSdk.absolutePath, manifestWithMaxSdk2.absolutePath),
+      manifestPaths = mutableSetOf(
+        manifestWithMaxSdk.absolutePath,
+        manifestWithMaxSdk2.absolutePath
+      )
+    )
+    val problems = mapOf("android.permission.READ_CONTACTS" to permissionInfo)
+    val overrides = findPermissionsToOverride(problems)
+
+    assertThat(overrides).isEmpty()
+  }
+
+  @Test
+  fun `ignores permission if file does not exist`() {
+    val nonExistentPath = "/path/to/nothing.xml"
+    val permissionInfo = PermissionInfo(
+      maxSdkSources = mutableSetOf(manifestWithMaxSdk.absolutePath),
+      manifestPaths = mutableSetOf(
+        manifestWithMaxSdk.absolutePath,
+        nonExistentPath
+      )
+    )
+    val problems = mapOf("android.permission.READ_CONTACTS" to permissionInfo)
+    val overrides = findPermissionsToOverride(problems)
+
+    assertThat(overrides).isEmpty()
+  }
+}

package/android/expo-gradle-plugin/expo-max-sdk-override-plugin/src/test/java/expo/modules/plugin/FixManifestMaxSdkTaskTest.kt

@@ -0,0 +1,107 @@
+package expo.modules.plugin
+
+import com.google.common.truth.Truth.assertThat
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+class FixManifestMaxSdkTaskTest {
+  @get:Rule
+  val tempFolder = TemporaryFolder()
+
+  private lateinit var blameReportFile: File
+  private lateinit var mergedManifestIn: File
+  private lateinit var modifiedManifestOut: File
+
+  private lateinit var manifest1: File
+  private lateinit var manifest2: File
+
+  @Before
+  fun setup() {
+    val projectDir = tempFolder.root
+    blameReportFile = File(projectDir, "blame-report.txt")
+    mergedManifestIn = File(projectDir, "merged-manifest-in.xml")
+    modifiedManifestOut = File(projectDir, "modified-manifest-out.xml")
+
+    val manifestDir1 = File(projectDir, "lib1/src/main").apply { mkdirs() }
+    val manifestDir2 = File(projectDir, "app/src/main").apply { mkdirs() }
+
+    manifest1 = File(manifestDir1, "AndroidManifest.xml")
+    manifest1.writeText("""
+            <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+                <uses-permission android:name="android.permission.READ_CONTACTS" android:maxSdkVersion="28" />
+            </manifest>
+        """.trimIndent())
+
+    manifest2 = File(manifestDir2, "AndroidManifest.xml")
+    manifest2.writeText("""
+            <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+                <uses-permission android:name="android.permission.READ_CONTACTS" />
+            </manifest>
+        """.trimIndent())
+
+    blameReportFile.writeText("""
+            uses-permission#android.permission.READ_CONTACTS
+              MERGED from ${manifest2.absolutePath}:5:3-33
+              MERGED from ${manifest1.absolutePath}:3:3-83
+            	android:maxSdkVersion
+            		ADDED from ${manifest1.absolutePath}:4:7-34
+        """.trimIndent())
+
+    mergedManifestIn.writeText("""
+            <?xml version="1.0" encoding="utf-8"?>
+            <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+                package="com.example.app">
+            
+                <uses-permission android:name="android.permission.READ_CONTACTS" android:maxSdkVersion="28" />
+                <uses-permission android:name="android.permission.INTERNET" />
+            
+            </manifest>
+        """.trimIndent())
+  }
+
+  @Test
+  fun `task removes maxSdkVersion from conflicting permission`() {
+    val project = ProjectBuilder.builder().withProjectDir(tempFolder.root).build()
+    val task = project.tasks.register("testFixTask", FixManifestMaxSdkTask::class.java).get()
+
+    task.blameReportFile.set(blameReportFile)
+    task.mergedManifestIn.set(mergedManifestIn)
+    task.modifiedManifestOut.set(modifiedManifestOut)
+
+    task.taskAction()
+
+    val outputContent = modifiedManifestOut.readText()
+
+    assertThat(outputContent).contains("<uses-permission android:name=\"android.permission.READ_CONTACTS\"/>")
+    assertThat(outputContent).doesNotContain("maxSdkVersion")
+    assertThat(outputContent).contains("<uses-permission android:name=\"android.permission.INTERNET\"/>")
+  }
+
+  @Test
+  fun `task copies file directly if no conflicts are found`() {
+    val project = ProjectBuilder.builder().withProjectDir(tempFolder.root).build()
+    val task = project.tasks.register("testFixTask", FixManifestMaxSdkTask::class.java).get()
+
+    blameReportFile.writeText("""
+            uses-permission#android.permission.READ_CONTACTS
+              MERGED from /app/src/main/AndroidManifest.xml:5:3-33
+        """.trimIndent())
+
+    val originalContent = mergedManifestIn.readText()
+
+    task.blameReportFile.set(blameReportFile)
+    task.mergedManifestIn.set(mergedManifestIn)
+    task.modifiedManifestOut.set(modifiedManifestOut)
+
+    task.taskAction()
+
+    val outputContent = modifiedManifestOut.readText()
+
+    assertThat(outputContent).isEqualTo(originalContent)
+    assertThat(outputContent).contains("maxSdkVersion=\"28\"")
+  }
+}

package/android/expo-gradle-plugin/settings.gradle.kts

@@ -9,7 +9,8 @@ pluginManagement {
 include(
   ":expo-autolinking-plugin-shared",
   ":expo-autolinking-settings-plugin",
-  ":expo-autolinking-plugin"
+  ":expo-autolinking-plugin",
+  ":expo-max-sdk-override-plugin"
 )
 
 rootProject.name = "expo-gradle-plugin"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-autolinking",
-  "version": "3.1.0-canary-20251210-1f163e3",
+  "version": "3.1.0-canary-20251211-7da85ea",
   "description": "Scripts that autolink Expo modules.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -34,7 +34,7 @@
   "license": "MIT",
   "homepage": "https://github.com/expo/expo/tree/main/packages/expo-modules-autolinking#readme",
   "devDependencies": {
-    "expo-module-scripts": "5.1.0-canary-20251210-1f163e3",
+    "expo-module-scripts": "5.1.0-canary-20251211-7da85ea",
     "memfs": "^3.2.0"
   },
   "dependencies": {