react-native-screens/android/build.gradle

import com.android.Version
import groovy.json.JsonSlurper

buildscript {
    ext {
        rnsDefaultTargetSdkVersion = 34
        rnsDefaultCompileSdkVersion = 34
        rnsDefaultMinSdkVersion = 21
        rnsDefaultKotlinVersion = '1.8.0'
    }
    ext.safeExtGet = {prop, fallback ->
        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
    }
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath('com.android.tools.build:gradle:4.2.2')
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', rnsDefaultKotlinVersion)}"
        classpath "com.diffplug.spotless:spotless-plugin-gradle:6.11.0"
    }
}

def isRunningInContextOfScreensRepo() {
    return project == rootProject
}

def isNewArchitectureEnabled() {
    // To opt-in for the New Architecture, you can either:
    // - Set `newArchEnabled` to true inside the `gradle.properties` file
    // - Invoke gradle with `-newArchEnabled=true`
    // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
}

// spotless is only accessible within react-native-screens repo
if (isRunningInContextOfScreensRepo()) {
    apply from: 'spotless.gradle'
}

if (isNewArchitectureEnabled()) {
    apply plugin: "com.facebook.react"
}
apply plugin: 'com.android.library'
apply plugin: 'kotlin-android'

def reactNativeArchitectures() {
    def value = project.getProperties().get("reactNativeArchitectures")
    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
}

def safeAppExtGet(prop, fallback) {
    def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
    appProject?.ext?.has(prop) ? appProject.ext.get(prop) : fallback
}

def resolveReactNativeDirectory() {
    def reactNativeLocation = safeAppExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
    if (reactNativeLocation != null) {
        return file(reactNativeLocation)
    }

    def reactNativeFromAppNodeModules = file("${projectDir}/../../react-native")
    if (!isRunningInContextOfScreensRepo() && reactNativeFromAppNodeModules.exists()) {
        return reactNativeFromAppNodeModules
    }

    def reactNativeFromProjectNodeModules = file("${rootProject.projectDir}/../node_modules/react-native")
    if (reactNativeFromProjectNodeModules.exists()) {
        return reactNativeFromProjectNodeModules
    }

    throw new GradleException(
        "[RNScreens] Unable to resolve react-native location in node_modules. You should add project extension property (in `app/build.gradle`) `REACT_NATIVE_NODE_MODULES_DIR` with path to react-native."
    )
}

def reactNativeRootDir = resolveReactNativeDirectory()
def reactProperties = new Properties()
file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 1000 : REACT_NATIVE_VERSION.split("\\.")[1].toInteger()

android {
    compileSdkVersion safeExtGet('compileSdkVersion', rnsDefaultCompileSdkVersion)
    def agpVersion = Version.ANDROID_GRADLE_PLUGIN_VERSION
    if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
        namespace "com.swmansion.rnscreens"
        buildFeatures {
            buildConfig true
        }
    }

    // Used to override the NDK path/version on internal CI or by allowing
    // users to customize the NDK path/version from their root project (e.g. for M1 support)
    if (rootProject.hasProperty("ndkPath")) {
        ndkPath rootProject.ext.ndkPath
    }
    if (rootProject.hasProperty("ndkVersion")) {
        ndkVersion rootProject.ext.ndkVersion
    }

    defaultConfig {
        minSdkVersion safeExtGet('minSdkVersion', rnsDefaultMinSdkVersion)
        targetSdkVersion safeExtGet('targetSdkVersion', rnsDefaultTargetSdkVersion)
        versionCode 1
        versionName "1.0"
        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
        ndk {
            abiFilters (*reactNativeArchitectures())
        }
        externalNativeBuild {
            cmake {
                arguments "-DANDROID_STL=c++_shared"
            }
        }
    }
    if (REACT_NATIVE_MINOR_VERSION >= 71) {
        buildFeatures {
            prefab true
        }
        externalNativeBuild {
            cmake {
                path "CMakeLists.txt"
            }
        }
    }
    lintOptions {
        abortOnError false
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    packagingOptions {
        // For some reason gradle only complains about the duplicated version of libreact_render libraries
        // while there are more libraries copied in intermediates folder of the lib build directory, we exclude
        // only the ones that make the build fail (ideally we should only include librnscreens_modules but we
        // are only allowed to specify exclude patterns)
        excludes = [
                "META-INF",
                "META-INF/**",
                "**/libjsi.so",
                "**/libc++_shared.so",
                "**/libreact_render*.so"
        ]
    }
    sourceSets.main {
        ext.androidResDir = "src/main/res"
        java {
            if (isNewArchitectureEnabled()) {
                srcDirs += [
                    "src/fabric/java",
                ]
            } else {
                srcDirs += [
                    "src/paper/java",
                ]
            }
        }
        res {
            if (safeExtGet('compileSdkVersion', rnsDefaultCompileSdkVersion) >= 33) {
                srcDirs = ["${androidResDir}/base", "${androidResDir}/v33"]
            } else {
                srcDirs = ["${androidResDir}/base"]
            }
        }
    }
}

repositories {
    maven {
        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
        // Matches the RN Hello World template
        // https://github.com/facebook/react-native/blob/1e8f3b11027fe0a7514b4fc97d0798d3c64bc895/local-cli/templates/HelloWorld/android/build.gradle#L21
        url "$projectDir/../node_modules/react-native/android"
    }
    mavenCentral()
    mavenLocal()
    google()
}

dependencies {
    implementation 'com.facebook.react:react-native:+'
    implementation 'androidx.appcompat:appcompat:1.4.2'
    implementation 'androidx.fragment:fragment:1.3.6'
    implementation 'androidx.coordinatorlayout:coordinatorlayout:1.2.0'
    implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
    implementation 'com.google.android.material:material:1.6.1'
    implementation "androidx.core:core-ktx:1.8.0"

    constraints {
        implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1") {
            because("on older React Native versions this dependency conflicts with react-native-screens")
        }
    }
}

def isScreensExampleApp() {
    return project.hasProperty('isScreensExampleApp') && project.property('isScreensExampleApp') == "true"
}

def getAbsoluteCodegenArtifactsPaperDestination() {
    if (!project.hasProperty('codegenArtifactsPaperDestination')) {
        throw new Exception('[RNScreens] Please fill codegenArtifactsPaperDestination variable in android/gradle.properties correct path to paper paper destination')
    }

    return "${project.rootDir}/../../${project.property('codegenArtifactsPaperDestination')}"
}

def getAbsoluteCodegenArtifactsSource() {
    if (!project.hasProperty('codegenArtifactsSource')) {
        throw new Exception('[RNScreens] Please fill codegenArtifactsSource variable in android/gradle.properties correct path to codegenerated artifacts')
    }

    return "${project.rootDir}/../../${project.property('codegenArtifactsSource')}"
}


tasks.register("copyCodegenArtifacts") {
    group 'After build tasks'
    description 'Tasks which copy codegen artifacts to paper architecture'
    
    if (!isScreensExampleApp() || !isNewArchitectureEnabled()) {
        return
    }

    dependsOn tasks.generateCodegenArtifactsFromSchema

    doLast {

        def absoluteCodegenArtifactsPaperDestination = getAbsoluteCodegenArtifactsPaperDestination()
        def absoluteCodegenArtifactsSource = getAbsoluteCodegenArtifactsSource()

        def existingFiles = fileTree(absoluteCodegenArtifactsPaperDestination).matching {
            include '**/*.java'
        }

        def generatedFiles = fileTree(absoluteCodegenArtifactsSource).matching {
            include '**/*.java'
        }

        def existingFilesMap = [:]

        existingFiles.forEach { existingFile ->
            existingFilesMap[existingFile.name] = 1
        }

        generatedFiles.forEach { generatedFile -> 
            if (!existingFilesMap.containsKey(generatedFile.name)) {
                logger.warn("[RNScreens] ${generatedFile.name} not found in paper dir, if it's used in Android you need to copy it manually and implement yourself before using auto-copy feature")
            }
        }

        if (existingFiles.size() == 0) {
            logger.warn("[RNScreens] Paper destination with codegen interfaces is empty. This might be okay if you don't have any interfaces/delegates used in Android, if that's not the case please check if codegenArtifactsPaperDestination in android/gradle.properties is correct")
        }

        if (existingFiles.size() > generatedFiles.size()) {
            throw new Exception("[RNScreens] Number od generated artifacts should be greather then or equal to paper interfaces. Please check if codegenArtifactsSource in android/gradle.properties is correct")
        }

        copy {
            from absoluteCodegenArtifactsSource
            include existingFiles.collect { it.name }
            into absoluteCodegenArtifactsPaperDestination
        }
    }
}

if (isScreensExampleApp() && isNewArchitectureEnabled()) {
    tasks.generateCodegenArtifactsFromSchema.finalizedBy('copyCodegenArtifacts')
}