apply plugin: 'com.android.library'
apply plugin: 'maven-publish'

android {
    compileSdkVersion rootProject.ext.compileSdkVersion

    defaultConfig {
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
    }

    buildTypes {
        debug {}
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation "com.android.support:support-v4:${rootProject.ext.supportLibVersion}"
    implementation "com.android.support:appcompat-v7:${rootProject.ext.supportLibVersion}"

    implementation 'com.amplitude:android-sdk:2.14.1'
    implementation 'com.dropbox.core:dropbox-core-sdk:3.0.8'
    api 'com.facebook.react:react-native:+'

    implementation project(':react-native-background-timer')
    implementation project(':react-native-calendar-events')
    implementation(project(':react-native-fast-image')) {
        exclude group: 'com.android.support'
    }
    implementation(project(":react-native-google-signin")) {
        exclude group: 'com.google.android.gms'
        exclude group: 'com.android.support'
    }
    implementation project(':react-native-immersive')
    implementation project(':react-native-keep-awake')
    implementation project(':react-native-linear-gradient')
    implementation project(':react-native-sound')
    implementation project(':react-native-vector-icons')
    implementation project(':react-native-webrtc')

    testImplementation 'junit:junit:4.12'
}


// Here we bundle all assets, resources and React files. We cannot use the
// react.gradle file provided by react-native because it's designed to be used
// in an application (it taps into applicationVariants, but the SDK is a library
// so we need libraryVariants instead).
android.libraryVariants.all { def variant ->
    // Create variant and target names
    def targetName = variant.name.capitalize()
    def targetPath = variant.dirName

    // React js bundle directories
    def jsBundleDir = file("$buildDir/generated/assets/react/${targetPath}")
    def resourcesDir = file("$buildDir/generated/res/react/${targetPath}")

    def jsBundleFile = file("$jsBundleDir/index.android.bundle")

    def currentBundleTask = tasks.create(
            name: "bundle${targetName}JsAndAssets",
            type: Exec) {
        group = "react"
        description = "bundle JS and assets for ${targetName}."

        // Create dirs if they are not there (e.g. the "clean" task just ran)
        doFirst {
            jsBundleDir.deleteDir()
            jsBundleDir.mkdirs()
            resourcesDir.deleteDir()
            resourcesDir.mkdirs()
        }

        // Set up inputs and outputs so gradle can cache the result
        def reactRoot = file("${projectDir}/../../")
        inputs.files fileTree(dir: reactRoot, excludes: ["android/**", "ios/**"])
        outputs.dir jsBundleDir
        outputs.dir resourcesDir

        // Set up the call to the react-native cli
        workingDir reactRoot

        // Set up dev mode
        def devEnabled = !targetName.toLowerCase().contains("release")

        // Run the bundler
        commandLine(
                "node",
                "node_modules/react-native/local-cli/cli.js",
                "bundle",
                "--platform", "android",
                "--dev", "${devEnabled}",
                "--reset-cache",
                "--entry-file", "index.android.js",
                "--bundle-output", jsBundleFile,
                "--assets-dest", resourcesDir)

        // Disable bundling on dev builds
        enabled !devEnabled
    }

    currentBundleTask.ext.generatedResFolders = files(resourcesDir).builtBy(currentBundleTask)
    currentBundleTask.ext.generatedAssetsFolders = files(jsBundleDir).builtBy(currentBundleTask)
    variant.registerGeneratedResFolders(currentBundleTask.generatedResFolders)

    def mergeAssetsTask = variant.mergeAssetsProvider.get()
    def mergeResourcesTask = variant.mergeResourcesProvider.get()

    mergeAssetsTask.dependsOn(currentBundleTask)
    mergeResourcesTask.dependsOn(currentBundleTask)

    mergeAssetsTask.doLast {
        def assetsDir = mergeAssetsTask.outputDir

        // Bundle fonts
        //
        copy {
            from("${projectDir}/../../fonts/jitsi.ttf")
            into("${assetsDir}/fonts")
        }

        // Bundle sounds
        //
        copy {
            from("${projectDir}/../../sounds/incomingMessage.wav")
            from("${projectDir}/../../sounds/joined.wav")
            from("${projectDir}/../../sounds/left.wav")
            from("${projectDir}/../../sounds/outgoingRinging.wav")
            from("${projectDir}/../../sounds/outgoingStart.wav")
            from("${projectDir}/../../sounds/recordingOn.mp3")
            from("${projectDir}/../../sounds/recordingOff.mp3")
            from("${projectDir}/../../sounds/rejected.wav")
            into("${assetsDir}/sounds")
        }

        // Copy React assets
        //
        if (currentBundleTask.enabled) {
            copy {
                from(jsBundleFile)
                into(assetsDir)
            }
        }
    }

    mergeResourcesTask.doLast {
        // Copy React resources
        //
        if (currentBundleTask.enabled) {
            copy {
                from(resourcesDir)
                into(mergeResourcesTask.outputDir)
            }
        }
    }
}


publishing {
    publications {
        aarArchive(MavenPublication) {
            groupId 'org.jitsi.react'
            artifactId 'jitsi-meet-sdk'
            version project.sdkVersion

            artifact("${project.buildDir}/outputs/aar/${project.name}-release.aar") {
                extension "aar"
            }
            pom.withXml {
                def pomXml = asNode()
                pomXml.appendNode('name', 'jitsi-meet-sdk')
                pomXml.appendNode('description', 'Jitsi Meet SDK for Android')
                def dependencies = pomXml.appendNode('dependencies')
                configurations.getByName('releaseCompileClasspath').getResolvedConfiguration().getFirstLevelModuleDependencies().each {
                    // The (third-party) React Native modules that we depend on
                    // are in source code form and do not have groupId. That is
                    // why we have a dedicated groupId for them. But the other
                    // dependencies come through Maven and, consequently, have
                    // groupId.
                    def groupId = it.moduleGroup
                    def artifactId = it.moduleName

                    if (artifactId.startsWith('react-native-')
                            && groupId.equals('jitsi-meet')) {
                        groupId = rootProject.ext.moduleGroupId
                    }

                    def dependency = dependencies.appendNode('dependency')
                    dependency.appendNode('groupId', groupId)
                    dependency.appendNode('artifactId', artifactId)
                    dependency.appendNode('version', it.moduleVersion)
                }
            }
        }

    }
    repositories {
        maven { url "file:${rootProject.ext.mavenRepo}" }
    }
}