build.gradle

/*
 * Gradle file to build the Jar Resolver Unity plugin.
 */
buildscript {
    repositories {
        jcenter()
        mavenLocal()
    }
}

/*
 * Project level variables
 */
project.ext {
    sdk_root = System.getProperty("ANDROID_HOME")
    if (sdk_root == null || sdk_root.isEmpty()) {
        sdk_root = System.getenv("ANDROID_HOME")
    }

    unity_search_dir_excludes_string = System.getProperty("UNITY_EXCLUDES")
    unity_search_dir_excludes =
        unity_search_dir_excludes_string ?
            unity_search_dir_excludes_string.tokenize(";") :
            ["**/PackageManager/Editor"]

    // Determine the current OS.
    os_name = System.getProperty("os.name").toLowerCase();
    os_osx = os_name.contains("mac os x");
    os_windows = os_name.contains("windows");
    os_linux = os_name.contains("linux");

    // Search for the Unity editor executable.
    // The Unity editor is required to package the plug-in.
    unity_exe = System.getProperty("UNITY_EXE")
    if (unity_exe == null || unity_exe.isEmpty()) {
        unity_exe = System.getenv("UNITY_EXE")
    }
    if (unity_exe == null || unity_exe.isEmpty()) {
      // TODO: Should probably also search the path using Exec / which / where.
      if (os_osx) {
        unity_exe ='/Applications/Unity/Unity.app/Contents/MacOS/Unity'
      } else if (os_windows) {
        unity_exe = 'C:\\Program Files\\Unity\\Editor\\Unity.exe'
      } else if (os_linux) {
        unity_exe = '/opt/Unity/Editor/Unity'
      }
    }
    unity_exe_found = (new File(unity_exe)).exists();
    if (!unity_exe_found) {
      logger.warn('Unity editor executable not found, plug-in packaging ' +
                  'may fail.')
    }

    // find the unity root directory by working up from the executable.
    // not, perfect, but pretty close, work up the tree until the
    // name starts with unity.
    unity_root = (new File(unity_exe)).getParentFile().getParentFile();
    while (!unity_root.name.toLowerCase().startsWith("unity")) {
        if (unity_root.getParentFile() != null) {
            unity_root = unity_root.getParentFile();
        } else {
            break;
        }
    }

    logger.info( "Unity root is $unity_root")

    // find unity engine dll
    unity_dll_path =  findUnityPath("UNITY_DLL_PATH", true,
                            fileTree(dir: unity_root).matching {
                                include '**/Managed/UnityEngine.dll'
                                exclude unity_search_dir_excludes
                            });

    if (unity_dll_path == null || !unity_dll_path.exists()) {
        logger.warn('Unity Editor and Runtime DLLs not found, compilation may fail!')
    } else {
        logger.info("Unity Engine DLL path is $unity_dll_path")
    }

    // ios runtime dll.  This is with the playback engine, so the
    // structure is different for MacOS and the others.
    unity_ios_dll_path = findUnityPath("UNITY_IOS_PLAYBACK_PATH", true,
        fileTree(dir: os_osx ? unity_root.parentFile : unity_root, includes: [
            '**/PlaybackEngines/iOSSupport/UnityEditor.iOS.Extensions.dll',
            '**/PlaybackEngines/iossupport/UnityEditor.iOS.Extensions.dll'
        ], exclude: unity_search_dir_excludes))

    if (unity_ios_dll_path == null || !unity_ios_dll_path.exists()) {
        logger.warn('Unity iOS Playback engine not found, compilation may fail!')
    } else {
        logger.info("Unity iOS Playback engine is $unity_ios_dll_path")
    }


    // find the NUnit framework dll.
    unity_nunit_dll_path = findUnityPath("UNITY_NUNIT_PATH", true,
                                fileTree(dir: unity_root).matching {
                                    include '**/nunit.framework.dll'
                                    exclude unity_search_dir_excludes
                                })

    if (unity_nunit_dll_path == null || !unity_nunit_dll_path.exists()) {
        logger.warn('Unity NUnit framework not found, compilation may fail!')
    } else {
        logger.info("Unity NUnity framework found in  $unity_nunit_dll_path")
    }

// xbuild is used to build the dlls.
    if (os_windows) {
        xbuild_exe = findUnityPath("XBUILD_EXE", false,
            fileTree(dir: unity_root).matching {
                include '**/Mono/bin/xbuild.bat'
                exclude unity_search_dir_excludes
            })
    } else if (os_osx || os_linux) {
        xbuild_exe = findUnityPath("XBUILD_EXE", false,
            fileTree(dir: unity_root).matching {
                include '**/xbuild'
                exclude unity_search_dir_excludes
            })
    }
    if (xbuild_exe == null || !xbuild_exe.exists()) {
        logger.warn("xbuild command not found, compilation may fail.")
        xbuild_exe = null
    } else {
        logger.info("xbuild found at $xbuild_exe")
    }

// nunit-console is used to run tests.
    if (os_windows) {
        nunit_console_exe = findUnityPath("NUNIT_CONSOLE_EXE", false,
            fileTree(dir: unity_root).matching {
                include '**/Mono/bin/nunit-console2.bat'
                exclude unity_search_dir_excludes
            })
    } else if (os_osx || os_linux) {
        nunit_console_exe = findUnityPath("NUNIT_CONSOLE_EXE", false,
            fileTree(dir: unity_root).matching {
                include '**/nunit-console2'
                exclude unity_search_dir_excludes
            })
    }
    if (nunit_console_exe == null || !nunit_console_exe.exists()) {
        logger.warn("nunit_console command not found, compilation may fail.")
        nunit_console_exe = null
    } else {
        logger.info("nunit_console found at $nunit_console_exe")
    }

    pluginSrc = file('plugin').absolutePath
    pluginProj = file('build/PluginSrc').absolutePath
    buildPath = file('build').absolutePath
    exportPath = file('build/plugin.unitypackage').absolutePath
    dllDir = 'Assets/PlayServicesResolver/Editor'
    pluginVersion = '1.2.71.0'
    currentPluginPath = file('.').absolutePath
    currentPluginBasename = 'play-services-resolver'
    currentPluginName = (currentPluginBasename + '-' + pluginVersion +
                         '.unitypackage')
}

task compile_resolverTests(type: Exec) {
  description 'Compile the tests for the Mono framework component.'
  workingDir 'source'
  commandLine "${xbuild_exe}", '/target:JarResolverTests',
        "/property:NUnityHintPath=$unity_nunit_dll_path.absolutePath"
  ext.remoteTaskPhase = 'build'
}

task test_resolverLib(type: Exec, dependsOn: compile_resolverTests) {
  description 'Runs the tests.'
  workingDir 'source'
  commandLine "$nunit_console_exe",
              "JarResolverTests/bin/Debug/JarResolverTests.dll"
  ext.remoteTaskPhase = 'build'
}

task compile_packageManagerTests(type: Exec) {
  description 'Compile the tests for the Mono framework component.'
  workingDir 'source'
  commandLine "${xbuild_exe}", '/target:PackageManagerTests',
        "/property:NUnityHintPath=$unity_nunit_dll_path.absolutePath"
  ext.remoteTaskPhase = 'build'
}

task test_packageManager(type: Exec, dependsOn: compile_packageManagerTests) {
  description 'Runs the tests.'
  workingDir 'source'
  commandLine "$nunit_console_exe",
              "PackageManagerTests/bin/Debug/PackageManagerTests.dll"
  ext.remoteTaskPhase = 'build'
}

/// find paths within the Unity file tree used for building.
def findUnityPath(propertyKey, wantDirectory, fileTree) {

    def propValue;
    def fileValue;

    propValue = System.getProperty(propertyKey)
    if (propValue == null || propValue.isEmpty()) {
        propValue = System.getenv(propertyKey)
    }
    // convert string to file object
    if (propValue != null) {
        fileValue = file(propValue)
    } else {
        fileValue = null
    }

    if (fileValue == null || !fileValue.exists()) {
        // take the shortest path location.
        fileValue = null
        fileTree.files.each { p ->
            if (fileValue == null ||
                    fileValue.absolutePath.length() > p.absolutePath.length()) {
                fileValue = p;
            }
        }
    }

    if (wantDirectory) {
        return fileValue != null ? fileValue.parentFile : null;
    } else {
        return fileValue
    }
}

// Construct the name of a versioned asset from the source filename and version
// string.
// The encoded string takes the form...
// ${filename}_v${version}_.${extension}
// where extension is derived from the specified filename.
def versionedAssetName(filename, version) {
  def extensionIndex = filename.lastIndexOf('.')
  def basename = filename.substring(0, extensionIndex)
  def extension = filename.substring(extensionIndex)
  // Encode the DLL version and target names into the DLL in the form...
  // ${dllname}_t${hypen_separated_target_names}_v${version}.dll
  def targetName = basename
  if (version != null && !version.isEmpty()) {
    targetName += '_v' + version
  }
  return targetName + extension
}

// Generate the tasks to compile a plugin DLL and copy it to the Unity
// plugin packaging folder.
def build_pluginDll(projectName, assemblyDllBasename, shouldVersionFilename) {
  def version = "${pluginVersion}"
  def projectPath = 'source/' + projectName + '/' + projectName + '.csproj'
  def assemblyDll = versionedAssetName(assemblyDllBasename, version)

  def compileTask = tasks.create(name: "compile_" + projectName,
                                 type: Exec,
                                 description: 'Compile ' + projectName
                                )
  compileTask.workingDir('source')
  compileTask.commandLine(["${xbuild_exe}", "/target:" + projectName,
        "/property:UnityHintPath=$unity_dll_path.absolutePath",
        "/property:UnityIosPath=$unity_ios_dll_path.absolutePath"
    ])

  compileTask.ext.remoteTaskPhase = "build"
  def assemblyDllSource = file("source/" + projectName + "/bin/Debug/" +
                               assemblyDllBasename)

  def dllMetaBasename = assemblyDllBasename + ".meta"
  def dllMeta = "${pluginSrc}/${dllDir}/" + dllMetaBasename
  def dllMetaVersioned = assemblyDll + ".meta"
  def copyTask = tasks.create(name: "copy_" + projectName,
                              type: Copy,
                              description: ('Copy ' + projectName +
                                            ' to the Unity packaging folder'),
                              dependsOn: [compileTask, clean_pluginProjDir])
  copyTask.from(files(assemblyDllSource, dllMeta))
  copyTask.into("${pluginProj}/${dllDir}")
  copyTask.duplicatesStrategy('include')
  if (shouldVersionFilename) {
    copyTask.rename({
                      String fn ->
                        if (fn.endsWith(dllMetaBasename)) {
                          return fn.replace(dllMetaBasename, dllMetaVersioned)
                        } else if (fn.endsWith(assemblyDllBasename)) {
                          return fn.replace(assemblyDllBasename, assemblyDll)
                        }
                        return fn
                    })
  }
}

task clean_pluginProjDir(type: Delete) {
  delete pluginProj
}

build_pluginDll("PlayServicesResolver", "Google.JarResolver.dll", true)
build_pluginDll("VersionHandler", "Google.VersionHandler.dll", false)
build_pluginDll("VersionHandlerImpl", "Google.VersionHandlerImpl.dll", true)
build_pluginDll("IOSResolver", "Google.IOSResolver.dll", true)
build_pluginDll("PackageManager", "Google.PackageManager.dll", true)

task update_metadataForVersion() {
  description 'Update plugin metadata if the plugin version changed.'
  if (!file(currentPluginName).exists()) {
    for (fileobj in fileTree("${pluginSrc}")) {
      def lines = fileobj.text.split('\n')
      def outputLines = []
      for (line in lines) {
        if (line.contains('guid:')) {
          line = (
            'guid: ' + java.util.UUID.randomUUID().toString().replace('-', ''))
        }
        outputLines.add(line)
      }
      fileobj.write(outputLines.join('\n') + '\n')
    }
  }
}

task copy_pluginTemplate(type: Copy, dependsOn: [update_metadataForVersion,
                                                 clean_pluginProjDir]) {
  description 'Copy the template project into the Unity plugin packaging dir.'
  from "${pluginSrc}"
  into "${pluginProj}"
  exclude '**/*.dll.*', '**/*.txt.meta'
  duplicatesStrategy 'include'
  ext.remoteTaskPhase = 'build'
}

task inject_versionIntoMetaFiles(dependsOn: [copy_pluginTemplate,
                                             'copy_PlayServicesResolver',
                                             'copy_VersionHandler',
                                             'copy_VersionHandlerImpl',
                                             'copy_IOSResolver',
                                             clean_pluginProjDir]) {
  description 'Inject the version number into the plugin\'s meta files.'
  ext.remoteTaskPhase = 'build'
  doLast {
    for (fileobj in fileTree("${pluginProj}")) {
      if (fileobj.path.endsWith('.meta')) {
        def lines = fileobj.text.split('\n')
        def outputLines = []
        for (line in lines) {
          outputLines.add(line)
          if (line.contains('labels:')) {
            outputLines.add("- gvh_v${pluginVersion}")
          }
        }
        fileobj.write(outputLines.join('\n') + '\n')
      }
    }
  }
}

task copy_manifestMetadata(type: Copy, dependsOn: clean_pluginProjDir) {
  def manifestBasename = versionedAssetName(
    currentPluginBasename + '.txt', null) + '.meta'
  description 'Copy .meta file for the plugin manifest.'
  from file("${pluginSrc}/${dllDir}/" + manifestBasename)
  into file("${pluginProj}/${dllDir}/")
  rename {
    String fn ->
      return fn.replace(manifestBasename,
                        versionedAssetName(currentPluginBasename + '.txt',
                                           "${pluginVersion}") +
                        '.meta')
  }
}

task generate_manifest(dependsOn: ['copy_manifestMetadata',
                                   'inject_versionIntoMetaFiles',
                                   clean_pluginProjDir]) {
  description 'Generate a manifest for the files in the plug-in.'
  doLast {
    def dir = file("${pluginProj}/Assets")
    def list = []
    dir.eachFileRecurse(groovy.io.FileType.FILES) { filename ->
      def path = filename.path
      if (!(path.toLowerCase().endsWith('.meta') ||
            path.toLowerCase().endsWith('.txt'))) {
        list << filename.path.replace("${pluginProj}/", '')
      }
    }
    def manifest = file("${pluginProj}/${dllDir}/" +
                        versionedAssetName(currentPluginBasename + '.txt',
                                           "${pluginVersion}"))
    manifest.write(list.join('\n') + '\n')
  }
  ext.remoteTaskPhase = 'build'
}

task tests(dependsOn: ['test_resolverLib','test_packageManager'])

task export_package(dependsOn: 'generate_manifest') {
  description 'Creates and exports the Plugin unity package.'
  doLast {
    def argv = ["-g.building",
                "-buildTarget",
                "android",
                "-batchmode",
                "-projectPath",
                "${pluginProj}",
                "-logFile",
                "build/unity.log",
                "-exportPackage",
                "Assets/PlayServicesResolver",
                "${exportPath}",
                "-gvh_disable",
                "-quit"]
    exec {
      executable "${unity_exe}"
      args argv
    }
  }
  ext.remoteTaskPhase = 'build'

  dependsOn tests
}

task copy_plugin() {
  description 'Copy plugin to the current-build directory'
  doFirst {
    delete fileTree(dir: currentPluginPath +"/exploded")
    delete fileTree(dir: currentPluginPath,
                    includes: [currentPluginBasename + "-*.unitypackage"])

    copy {
      from file(exportPath)
      into file(currentPluginPath)
      rename ('plugin.unitypackage', currentPluginName)
    }
  }
  doLast {
    copy {
      from file("${pluginProj}")
      into file(currentPluginPath +"/exploded")
      include "Assets/PlayServicesResolver/**/*"
    }
  }
  ext.remoteTaskPhase = 'postbuild'
}

task build_unityPackage(dependsOn: 'copy_plugin') {
  description "Top level task for building the unity package."
  doLast { println "Packaging Complete!" }
  ext.remoteTaskPhase = 'build'
  dependsOn {
    tasks.findAll { task -> task.name.startsWith('PackageSample') }
  }
}

task test_downloadArtifacts(type: GradleBuild) {
  description "Run tests for the download_artifacts.gradle script."
  ext.remoteTaskPhase = "build"
  buildFile "source/PlayServicesResolver/scripts/download_artifacts_test.gradle"
}

task clean() {
    doFirst {
        delete 'build'
        file("source").listFiles().each { f ->
            if (file("$f/obj").exists()) {
                delete "$f/obj"
            }
            if (file("$f/bin").exists()) {
                delete "$f/bin"
            }
        }
     }
}

defaultTasks = ['prebuild', 'build', 'postbuild']
for (phase in defaultTasks) {
  if (!tasks.findByName(phase)) {
    def build_phase_name = 'Local ' + phase
    tasks.create(name: phase,
                 action: { println(build_phase_name) },
                 description: build_phase_name,
                 dependsOn: project.tasks.findAll {
                   task -> task.ext.has('remoteTaskPhase') &&
                   task.ext.remoteTaskPhase == phase
                 })
  }
}
project.defaultTasks = defaultTasks