build.gradle

import java.util.regex.Pattern

allprojects {
  ext {
      airshipProperties = new Properties()
      airshipProperties.load(new FileInputStream("airship.properties"))
  }
}

configurations {
    plugin
}

repositories {
    google()
    ivy {
        url 'https://github.com'
        patternLayout {
            artifact '[organisation]/[module]/archive/[revision].[ext]'
        }
        metadataSources {
            artifact()
        }
    }
}

dependencies {
    plugin "googlesamples:unity-jar-resolver:${airshipProperties.playServicesResolver}@zip"
}

task preparePlugin(dependsOn: 'unity-plugin:assembleRelease') {
    doFirst {
        delete {
            "$buildDir"
        }
    }

    doLast {
        // Copy Android plugin
        copy {
            from file("unity-plugin/build/outputs/aar/unity-plugin-release.aar")
            into file("$buildDir/unity-plugin/Assets/Plugins/Android/")
            rename("unity-plugin-release.aar", "airship-unity-plugin.aar")
        }

        // Copy unity jar resolver
        copy {
            def zipPath = project.configurations.plugin.find {it.name.startsWith("unity-jar-resolver") }
            def zipFile = file(zipPath)
            def outputDir = file("${buildDir}/packages")
            from zipTree(zipFile)
            into outputDir
            include "*/*.unitypackage"
        }

        // Copy the Assets, exclude PluginInfo.cs and UADependencies.xml so we can copy and replace the version placeholder
        copy {
            from file("Assets")
            into file("$buildDir/unity-plugin/Assets/")
            exclude "UrbanAirship/PluginInfo.cs"
            exclude "UrbanAirship/Editor/UADependencies.xml"
            // exclude unit tests
            exclude "UrbanAirship/Tests"
            exclude "UrbanAirship/Platforms/AssemblyInfo.cs"
            exclude "UrbanAirship/Platforms/UrbanAirship.asmdef"
        }

        // Copy PluginInfo.cs and replace the version placeholders
        copy {
            from file("Assets")
            into file("$buildDir/unity-plugin/Assets/")
            include "UrbanAirship/PluginInfo.cs"
            filter { String line -> line.replaceAll(Pattern.quote("__PLUGIN_VERSION__"), airshipProperties.version) }
            filter { String line -> line.replaceAll(Pattern.quote("__ANDROID_AIRSHIP_VERSION__"), airshipProperties.androidAirshipVersion) }
            filter { String line -> line.replaceAll(Pattern.quote("__IOS_AIRSHIP_VERSION__"), airshipProperties.iosAirshipVersion) }
        }

        // Copy UADependencies.xml and replace the version placeholders
        copy {
            from file("Assets")
            into file("$buildDir/unity-plugin/Assets/")
            include "UrbanAirship/Editor/UADependencies.xml"
            filter { String line -> line.replaceAll(Pattern.quote("__PLUGIN_VERSION__"), airshipProperties.version) }
            filter { String line -> line.replaceAll(Pattern.quote("__ANDROID_AIRSHIP_VERSION__"), airshipProperties.androidAirshipVersion) }
            filter { String line -> line.replaceAll(Pattern.quote("__ANDROID_ANNOTATIONS_VERSION__"), airshipProperties.androidxAnnotationVersion) }
            filter { String line -> line.replaceAll(Pattern.quote("__IOS_AIRSHIP_VERSION__"), airshipProperties.iosAirshipVersion) }
        }
    }
}

task build(dependsOn: 'preparePlugin') {
    doLast {
        // Add each package
        def packages = fileTree("${buildDir}/packages") {
            include '**/*.unitypackage'
        }
        packages.each { file ->
            def addPackageOptions = [
                    "-g.building",
                    "-gvh_disable",
                    "-batchmode",
                    "-nographics",
                    "-createProject", "$buildDir/unity-plugin",
                    "-logFile", "$buildDir/package-${file.name}.log",
                    "-importPackage", "$file",
                    "-quit"
            ]

            exec {
                workingDir "$buildDir/unity-plugin"
                executable "${getUnityExePath()}"
                args addPackageOptions
            }
        }

        // Export the plugin
        def exportPackageOptions = [
                "-g.building",
                "-batchmode",
                "-nographics",
                "-gvh_disable",
                "-projectPath", "$buildDir/unity-plugin",
                "-logFile", "$buildDir/package.log",
                "-exportPackage",
                    "Assets/PlayServicesResolver",
                    "Assets/ExternalDependencyManager",
                    "Assets/UrbanAirship",
                    "Assets/Plugins/iOS",
                    "Assets/Plugins/Android/urbanairship-resources.androidlib",
                    "Assets/Plugins/Android",
                    "Assets/Scripts",
                file("build/urbanairship-${airshipProperties.version}.unitypackage").absolutePath,
                "-quit"
              ]

        exec {
            workingDir "$buildDir/unity-plugin"
            executable "${getUnityExePath()}"
            args exportPackageOptions
        }
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}


task getUnityVersion() {
    doLast {
        println airshipProperties.unityVersion
    }
}

task getPluginVersion() {
    doLast {
        println airshipProperties.version
    }
}


def getUnityExePath() {
    def unityExe = System.getProperty("UNITY_EXE")
    if (unityExe == null || unityExe.isEmpty()) {
        unityExe = System.getenv("UNITY_EXE")
    }

    if (unityExe == null || unityExe.isEmpty() || !file(unityExe).exists()) {
        unityExe = "/Applications/Unity/Hub/Editor/$airshipProperties.unityVersion/Unity.app/Contents/MacOS/Unity"
    }

    if (unityExe == null || unityExe.isEmpty() || !file(unityExe).exists()) {
        throw new GradleException('Unable to find Unity executable.')
    }

    return unityExe
}