build.gradle

import java.nio.file.Paths
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

apply plugin: "io.gitlab.arturbosch.detekt"

buildscript {
  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
  def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['DdSdkReactNative_kotlinVersion']

  repositories {
    mavenCentral()
    google()
    gradlePluginPortal()
  }

  dependencies {
    classpath 'com.android.tools.build:gradle:7.3.1'
    // noinspection DifferentKotlinGradleVersion
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    classpath "org.jlleitschuh.gradle:ktlint-gradle:11.5.1"
    classpath "io.gitlab.arturbosch.detekt:detekt-gradle-plugin:1.23.8"
    classpath 'com.github.bjoernq:unmockplugin:0.7.9'
// Uncomment here and in settings.gradle for getting rid of IDE errors for new architecture:
//    classpath "com.facebook.react:react-native-gradle-plugin"
  }
}


apply plugin: 'de.mobilej.unmock'

def isNewArchitectureEnabled() {
  return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
}

apply plugin: 'com.android.library'
if (isNewArchitectureEnabled()) {
  apply plugin: 'com.facebook.react'
}
apply plugin: 'kotlin-android'
apply plugin: 'org.jlleitschuh.gradle.ktlint'


/**
 * Finds the path of the installed npm package with the given name using Node's
 * module resolution algorithm, which searches "node_modules" directories up to
 * the file system root.
 * This enables us to handle monorepos without requiring the node executable.
 *
 * The search begins at the given base directory (a File object). The returned
 * path is a string.
 */
static def findNodeModulePath(baseDir, packageName) {
    def basePath = baseDir.toPath().normalize()
    // Node's module resolution algorithm searches up to the root directory,
    // after which the base path will be null
    while (basePath) {
        def candidatePath = Paths.get(basePath.toString(), "node_modules", packageName)
        if (candidatePath.toFile().exists()) {
            return candidatePath.toString()
        }
        basePath = basePath.getParent()
    }
    return null
}

def resolveReactNativeDirectory() {
  def reactNativeLocation = rootProject.hasProperty("reactNativeDir") ? rootProject.getProperty("reactNativeDir") : null

  if (reactNativeLocation != null) {
    return file(reactNativeLocation)
  }

  def reactNativePath = findNodeModulePath(projectDir, "react-native")

  if (reactNativePath != null) {
    return file(reactNativePath)
  }

  throw new Exception(
    "${project.name}: Failed to resolve 'react-native' in the project. " +
    "Altenatively, you can specify 'reactNativeDir' with the path to 'react-native' in your 'gradle.properties' file."
  )
}

def reactNativeRootDir = resolveReactNativeDirectory()
def reactProperties = new Properties()
file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }

def reactNativeVersion = reactProperties.getProperty("VERSION_NAME")
def (reactNativeMajorVersion, reactNativeMinorVersion) = reactNativeVersion.split("\\.").collect { it.isInteger() ? it.toInteger() : it }

def getExtOrDefault(name) {
  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['DdSdkReactNative_' + name]
}

def getExtOrIntegerDefault(name) {
  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['DdSdkReactNative_' + name]).toInteger()
}

android {
  compileSdk getExtOrIntegerDefault('compileSdkVersion')
  compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
  buildToolsVersion getExtOrDefault('buildToolsVersion')

  def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION

  if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
    namespace = "com.datadog.reactnative"
  }

  if (agpVersion.tokenize('.')[0].toInteger() >= 8) {
    buildFeatures {
      buildConfig = true
    }
  }

  if (agpVersion.tokenize('.')[0].toInteger() < 8) {
    compileOptions {
      sourceCompatibility JavaVersion.VERSION_11
      targetCompatibility JavaVersion.VERSION_11
    }
    kotlinOptions {
      jvmTarget = JavaVersion.VERSION_11.majorVersion
    }
  }

  defaultConfig {
    compileSdk getExtOrIntegerDefault('compileSdkVersion')
    minSdkVersion getExtOrIntegerDefault('minSdkVersion')
    targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
    versionCode 1
    versionName "1.0"
    buildConfigField("boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString())
  }

  sourceSets {
    main {
      if (isNewArchitectureEnabled()) {
        java.srcDirs += ['src/newarch/kotlin']
      } else {
        java.srcDirs += ['src/oldarch/kotlin']
      }
    }
    test {
      java.srcDir("src/test/kotlin")
    }
  }

  testOptions {
    unitTests {
      returnDefaultValues = true
    }
  }

  buildTypes {
    release {
      minifyEnabled false
    }
  }
  lintOptions {
    disable 'GradleCompatible'
  }
}

repositories {
  mavenCentral()
  google()
  maven { url "https://jitpack.io" }
  mavenLocal()

  if (reactNativeMajorVersion == 0 && reactNativeMinorVersion < 71) {
    def androidSourcesDir = file("$reactNativeRootDir/android")
    def androidSourcesName = "React Native sources"

    if (androidSourcesDir.exists()) {
      maven {
        url androidSourcesDir.toString()
        name androidSourcesName
      }
    }
  }
}

def kotlin_version = getExtOrDefault('kotlinVersion')

dependencies {
  if (reactNativeMajorVersion == 0 && reactNativeMinorVersion < 71) {
    // noinspection GradleDynamicVersion
    api 'com.facebook.react:react-native:+'
  } else {
    // We specify the $reactNativeVersion, like it's done on the react-native-gradle-plugin, as the plugin is not applied in tests.
    // There is no impact for apps as we apply the same logic:
    // https://github.com/facebook/react-native/blob/e1a1e6aa8030bf11d691c3dcf7abd13b25175027/packages/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/utils/DependencyUtils.kt
    api "com.facebook.react:react-android:$reactNativeVersion"
  }
  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
  compileOnly "com.squareup.okhttp3:okhttp:3.12.13"
 // dd-sdk-android-rum requires androidx.metrics:metrics-performance.
 // From 2.21.0, it uses 1.0.0-beta02, which requires Gradle 8.6.0.
 // This breaks builds if the React Native target is below 0.76.0. as it relies on Gradle 8.5.0.
 // To avoid this, we enforce 1.0.0-beta01 on RN < 0.76.0
 if (reactNativeMinorVersion < 76) {
      implementation("com.datadoghq:dd-sdk-android-rum:3.12.1") {
          exclude group: "androidx.metrics", module: "metrics-performance"
      }
      implementation "androidx.metrics:metrics-performance:1.0.0-beta01"
      // dd-sdk-android requires androidx.core:core and androidx.core:core-ktx
      // From 3.8.0, it uses 1.15.0, which requires compileSdk 35.
      // However, React Native versions below 0.76.0 use compileSdk 34,
      // so we pin 1.13.1 on those, since it's the last version compatible with compileSdk 34.
      // Use dependency constraints (strictly) so this requirement propagates to consumers.
      implementation("androidx.core:core") {
          version {
              strictly("1.13.1")
          }
      }
      implementation("androidx.core:core-ktx") {
          version {
              strictly("1.13.1")
          }
      }
  } else {
      implementation "com.datadoghq:dd-sdk-android-rum:3.12.1"
  }
  implementation "com.datadoghq:dd-sdk-android-logs:3.12.1"
  implementation "com.datadoghq:dd-sdk-android-trace:3.12.1"
  implementation "com.datadoghq:dd-sdk-android-webview:3.12.1"
  implementation "com.datadoghq:dd-sdk-android-ndk:3.12.1"
  implementation "com.datadoghq:dd-sdk-android-flags:3.12.1"
  implementation "com.datadoghq:dd-sdk-android-internal:3.12.1"
  implementation "com.datadoghq:dd-sdk-android-rum-prelaunch:3.12.1"
  implementation "com.google.code.gson:gson:2.11.0"
  testImplementation "org.junit.platform:junit-platform-launcher:1.6.2"
  testImplementation "org.junit.jupiter:junit-jupiter-api:5.6.2"
  testImplementation "org.junit.jupiter:junit-jupiter-engine:5.6.2"
  testImplementation "org.junit.jupiter:junit-jupiter-params:5.6.2"
  testImplementation "org.mockito:mockito-junit-jupiter:3.4.6"
  testImplementation "org.assertj:assertj-core:3.18.1"
  testImplementation "com.github.xgouchet.Elmyr:core:1.3.1"
  testImplementation "com.github.xgouchet.Elmyr:inject:1.3.1"
  testImplementation "com.github.xgouchet.Elmyr:junit5:1.3.1"
  testImplementation "com.github.xgouchet.Elmyr:jvm:1.3.1"
  testImplementation "org.mockito.kotlin:mockito-kotlin:5.1.0"
  testImplementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
  testImplementation("org.mockito:mockito-inline:5.2.0")

  unmock 'org.robolectric:android-all:4.4_r1-robolectric-r2'
  detektPlugins "io.gitlab.arturbosch.detekt:detekt-formatting:1.23.8"
  detektPlugins "io.gitlab.arturbosch.detekt:detekt-rules-libraries:1.23.8"
}

unMock {
  keep("android.os.Looper")
  keep("android.os.MessageQueue")
  keep("android.os.SystemProperties")
  keep("android.view.Choreographer")
  keep("android.view.DisplayEventReceiver")
  keepStartingWith("org.json.")
}

tasks.withType(Test) {
  useJUnitPlatform {
    includeEngines("spek", "junit-jupiter", "junit-vintage")
  }
  jvmArgs(
    "--add-opens=java.base/java.lang.reflect=ALL-UNNAMED",
    "--add-opens=java.base/java.util.concurrent=ALL-UNNAMED"
  )
  reports {
    junitXml.required.set(true)
    html.required.set(true)
  }
}

tasks.named("check") {
  dependsOn("ktlintCheck")
  dependsOn("detekt")
}

ktlint {
  debug.set(false)
  android.set(true)
  outputToConsole.set(true)
  ignoreFailures.set(false)
  enableExperimentalRules.set(false)
  filter {
    exclude("**/generated/**")
    include("**/kotlin/**")
  }
}

detekt {
  input = files("$projectDir/src/main/kotlin")
  config = files("$projectDir/detekt.yml")
  reports {
    xml {
      enabled = true
      destination = file("build/reports/detekt.xml")
    }
  }
}

// This is needed to make unmock work. Choreographer class was loaded from android.jar of Android SDK
// (which contains only public API and no internals), which with unmock plugin it should be loaded from the special jar provided by unmock.
// The code below is from the unmock plugin. It seems like something (from RN tooling maybe?) overwrites the location of Choreographer
// to the default one, so we apply the unmock code once again
project.afterEvaluate {
  def outputJarPath = "${project.buildDir}/intermediates/unmocked-android${project.name}.jar"
  def unMockTask = project.tasks.findByName("unMock")
  def outputJarDependency = project.files(outputJarPath).builtBy(unMockTask)

  project.android.unitTestVariants.all { variant ->
    variant.registerPreJavacGeneratedBytecode(outputJarDependency)
  }
}