import java.nio.file.Files import java.nio.file.Paths import java.util.regex.Pattern import java.util.stream.Stream class VersionComparator implements Comparator { static private final List SNAPSHOT_SUFFIXES = ["-SNAPSHOT", ".BUILD-SNAPSHOT"].asImmutable() int compare(String o1, String o2) { int result = 0 if (o1 == '*') { result = 1 } else if (o2 == '*') { result = -1 } else { def nums1 try { def tokens = deSnapshot(o1).split(/\./) tokens = tokens.findAll { String it -> it.trim() ==~ /\d+/ } nums1 = tokens*.toInteger() } catch (NumberFormatException e) { throw new Exception("Cannot compare versions, left side [$o1] is invalid: ${e.message}") } def nums2 try { def tokens = deSnapshot(o2).split(/\./) tokens = tokens.findAll { String it -> it.trim() ==~ /\d+/ } nums2 = tokens*.toInteger() } catch (NumberFormatException e) { throw new Exception("Cannot compare versions, right side [$o2] is invalid: ${e.message}") } boolean bigRight = nums2.size() > nums1.size() boolean bigLeft = nums1.size() > nums2.size() for (int i in 0.. i) { result = nums1[i].compareTo(nums2[i]) if (result != 0) { break } if (i == (nums1.size()-1) && bigRight) { if (nums2[i+1] != 0) result = -1; break } } else if (bigLeft) { if (nums1[i] != 0) result = 1; break } } } if (result == 0) { // Versions are equal, but one may be a snapshot. // A snapshot version is considered less than a non snapshot version def o1IsSnapshot = isSnapshot(o1) def o2IsSnapshot = isSnapshot(o2) if (o1IsSnapshot && !o2IsSnapshot) { result = -1 } else if (!o1IsSnapshot && o2IsSnapshot) { result = 1 } } result } boolean equals(obj) { false } /** * Removes any suffixes that indicate that the version is a kind of snapshot */ protected String deSnapshot(String version) { String suffix = SNAPSHOT_SUFFIXES.find { String it -> version?.endsWith(it) } if (suffix) { return version[0..-(suffix.size() + 1)] } else { return version } } protected boolean isSnapshot(String version) { SNAPSHOT_SUFFIXES.any { String it -> version?.endsWith(it) } } } class adxetools { static int compareVersion(String ver1, String ver2) { return new VersionComparator().compare(ver1, ver2); } static String[] findNDK(String ndkVer){ def allowNewerNdk = false if(ndkVer.endsWith('+')) { allowNewerNdk = true ndkVer = ndkVer.substring(0, ndkVer.length() - 1) } def ndkRoot = Paths.get("${System.env.ANDROID_NDK}") if(Files.exists(ndkRoot)) { ndkRoot = ndkRoot.toAbsolutePath().toString() def properties = new Properties() File propertiesFile = new File("$ndkRoot/source.properties") propertiesFile.withInputStream { properties.load(it) def foundNdkVer = properties['Pkg.Revision'] def ret = adxetools.compareVersion(foundNdkVer, ndkVer) if(ret == 0) { println("Using found ndk (revision=$foundNdkVer,path=$ndkRoot)") } else if(ret > 0){ if(allowNewerNdk) { println("Using found newer ndk (revision=$foundNdkVer,path=$ndkRoot), (minimum required is: ${ndkVer})") ndkVer = foundNdkVer } else { throw new GradleException("The ndk ${ndkVer} is required, but $foundNdkVer found!") } } else { throw new GradleException("The ndk ${ndkVer}+ is required, but $foundNdkVer found!") } } } else { ndkRoot = null println("No installed ndk found, the gradle will install ndk: $ndkVer automatically") } def rets = new String[2] rets[0] = ndkVer rets[1] = ndkRoot return rets } static String findCMake(String cmakeVer, rootProject) { def allowNewerCMake = false if(cmakeVer.endsWith('+')) { allowNewerCMake = true cmakeVer = cmakeVer.substring(0, cmakeVer.length() - 1) } def cmakeBinDirs = [] def cmakeBinDir = getCMakeBinFromLocal(rootProject) if(cmakeBinDir != null) { cmakeBinDirs.add(cmakeBinDir); } def sdkRoot = Paths.get("${System.env.ANDROID_SDK}") if(Files.exists(sdkRoot)) { sdkRoot = sdkRoot.toAbsolutePath().toString() def verList = ["3.10.2.4988404", "3.18.1"] for(foundVer in verList){ cmakeBinDir = sdkRoot + File.separator + "cmake" + File.separator + foundVer + File.separator + "bin" if(new File(cmakeBinDir).isDirectory()) { cmakeBinDirs.add(cmakeBinDir) } } } cmakeBinDir = getCMakeBinFromPath() if(cmakeBinDir != null) { cmakeBinDirs.add(cmakeBinDir) } // find in cmakeBinDirs def foundCMakeVer = null for(item in cmakeBinDirs) { foundCMakeVer = findCMakeFromBinDir(cmakeVer, item, allowNewerCMake) if(foundCMakeVer != null) { break } } if(foundCMakeVer == null) { println("No suitable cmake found, required $cmakeVer") } return foundCMakeVer } static boolean isWindows() { return System.getProperty("os.name").toLowerCase().contains("windows"); } static String getCMakeProgramName() { return isWindows() ? "cmake.exe" : "cmake" } static String getCMakeBinFromLocal(rootProject) { String programName = getCMakeProgramName(); Properties properties = new Properties() try { properties.load(rootProject.file("local.properties")) def cmakeDir = properties.getProperty("cmake.dir") if(cmakeDir != null) { def cmakeBin = "$cmakeDir/bin" if(new File("$cmakeBin/$programName").isFile()) return cmakeBin; } } catch(Exception) { } return null } static String getCMakeBinFromPath() { String cmakeExecName = getCMakeProgramName(); def foundBinPath = null Stream.of(System.getenv("PATH").split(Pattern.quote(File.pathSeparator))) .map(Paths::get) .anyMatch(path -> { def programPath = path.resolve(cmakeExecName); boolean fileExist = Files.exists(path.resolve(cmakeExecName)) if(fileExist) { foundBinPath = path.toAbsolutePath().toString() } return fileExist }); return foundBinPath } static String findCMakeFromBinDir(String cmakeVer, String cmakeBin, boolean allowNewerCMake) { def foundCMakeVer = null String ninjaName = isWindows() ? "ninja.exe" : "ninja" String ninjaPath = cmakeBin + File.separator + ninjaName if(!new File(ninjaPath).isFile()) { // check whether ninja in other location and in path def ninjaInstalled = false try { Process proc = Runtime.getRuntime().exec("ninja --version") proc.waitFor() int exitVal = proc.exitValue() ninjaInstalled = exitVal == 0 } catch(Exception) { } if (!ninjaInstalled) { throw new GradleException("Required $ninjaPath exists!") } } try { def programPath = cmakeBin + File.separator + getCMakeProgramName() Process proc = Runtime.getRuntime().exec("\"$programPath\" --version") proc.waitFor() int exitVal = proc.exitValue() if (exitVal == 0) { InputStream stdIn = proc.getInputStream(); InputStreamReader isr = new InputStreamReader(stdIn); BufferedReader br = new BufferedReader(isr); String verLine = br.readLine(); def verInfo = verLine.split("\\s") if (verInfo.length >= 3) { def foundVer = verInfo[2] def minusIdx = foundVer.indexOf('-') def canonVer = minusIdx == -1 ? foundVer : foundVer.substring(0, minusIdx) def ret = adxetools.compareVersion(canonVer, cmakeVer) if (ret == 0) { println("Using found cmake version: $canonVer") foundCMakeVer = canonVer } else if(ret > 0) { if(allowNewerCMake) { println("Using found newer cmake (version=$canonVer,path=$programPath), (minimum required is: ${cmakeVer})") foundCMakeVer = canonVer } else { println("The cmake ${cmakeVer} is required, but $canonVer found!") } } } } } catch(Exception ex) { } return foundCMakeVer } } ext.adxetools = adxetools