| /* |
| * Copyright 2015 The Go Authors. All rights reserved. |
| * Use of this source code is governed by a BSD-style |
| * license that can be found in the LICENSE file. |
| */ |
| |
| package org.golang.mobile |
| |
| import org.gradle.api.DefaultTask |
| import org.gradle.api.GradleException |
| import org.gradle.api.Project |
| import org.gradle.api.Plugin |
| import org.gradle.api.Task |
| import org.gradle.api.file.FileCollection; |
| import org.gradle.api.tasks.InputDirectory |
| import org.gradle.api.tasks.Optional |
| import org.gradle.api.tasks.OutputFile |
| import org.gradle.api.tasks.OutputDirectory |
| import org.gradle.api.tasks.TaskAction |
| import org.gradle.api.tasks.compile.JavaCompile |
| |
| import org.golang.mobile.OutputFileTask |
| import org.golang.mobile.AARPublishArtifact |
| |
| /* |
| * GobindPlugin configures the default project that builds .AAR file |
| * from a go package, using gomobile bind command. |
| * For gomobile bind command, see https://golang.org/x/mobile/cmd/gomobile |
| * |
| * If the project has the android or android library plugin loaded, GobindPlugin |
| * hooks into the android build lifecycle in two steps. First, the Java classes are |
| * generated and registered with the android plugin. Then, when the databinding |
| * classes and the R classes are generated and compiled, the GobindPlugin generates |
| * the JNI libraries. By splitting the binding in two steps, the Android databinding |
| * machinery can resolve Go classes, and Go code can access the resulting databinding |
| * classes as well as the R resource classes. |
| */ |
| class GobindPlugin implements Plugin<Project> { |
| void apply(Project project) { |
| project.extensions.create('gobind', GobindExtension) |
| // If the android or android library plugin is loaded, integrate |
| // directly with the android build cycle |
| if (project.plugins.hasPlugin("android") || |
| project.plugins.hasPlugin("com.android.application")) { |
| project.android.applicationVariants.all { variant -> |
| handleVariant(project, variant) |
| } |
| return |
| } |
| if (project.plugins.hasPlugin("android-library") || |
| project.plugins.hasPlugin("com.android.library")) { |
| project.android.libraryVariants.all { variant -> |
| handleVariant(project, variant) |
| } |
| return |
| } |
| |
| // Library mode: generate and declare the .aar file for parent |
| // projects to include. |
| project.configurations.create("default") |
| |
| Task gomobileTask = project.tasks.create("gobind", GomobileTask) |
| gomobileTask.outputFile = project.file(project.name+".aar") |
| project.artifacts.add("default", new AARPublishArtifact( |
| 'mylib', |
| null, |
| gomobileTask)) |
| |
| Task cleanTask = project.tasks.create("clean", { |
| project.delete(project.name+".aar") |
| }) |
| } |
| |
| private static void handleVariant(Project project, def variant) { |
| File outputDir = project.file("$project.buildDir/generated/source/gobind/$variant.dirName") |
| // First, generate the Java classes with the gobind tool. |
| Task bindTask = project.tasks.create("gobind${variant.name.capitalize()}", GobindTask) |
| bindTask.outputDir = outputDir |
| bindTask.javaCompile = variant.javaCompile |
| bindTask.bootClasspath = variant.javaCompile.options.bootClasspath |
| // TODO: Detect when updating the Java classes is redundant. |
| bindTask.outputs.upToDateWhen { false } |
| variant.registerJavaGeneratingTask(bindTask, new File(outputDir, "java")) |
| // Then, generate the JNI libraries with the gomobile tool. |
| Task libTask = project.tasks.create("gomobile${variant.name.capitalize()}", GomobileTask) |
| libTask.bootClasspath = variant.javaCompile.options.bootClasspath |
| libTask.javaCompile = variant.javaCompile |
| // Dump the JNI libraries in the known project jniLibs directory. |
| // TODO: Use a directory below build for the libraries instead. Adding a jni directory to the jniLibs |
| // property of android.sourceSets only works, but only if the directory changes every build. |
| libTask.libsDir = project.file("src/main/jniLibs") |
| // TODO: Detect when building the existing JNI libraries is redundant. |
| libTask.outputs.upToDateWhen { false } |
| libTask.dependsOn(bindTask) |
| // Ensure gomobile bind completes before depending on its output. |
| variant.javaCompile.dependsOn(libTask) |
| } |
| } |
| |
| class BindTask extends DefaultTask { |
| String bootClasspath |
| |
| def run(String cmd, String cmdPath, List<String> cmdArgs) { |
| def pkg = project.gobind.pkg.trim() |
| def gopath = (project.gobind.GOPATH ?: System.getenv("GOPATH"))?.trim() |
| if (!pkg || !gopath) { |
| throw new GradleException('gobind.pkg and gobind.GOPATH must be set') |
| } |
| |
| def paths = (gopath.split(File.pathSeparator).collect{ "$it/bin" } + |
| System.getenv("PATH").split(File.pathSeparator)).flatten() |
| // Default installation path of go distribution. |
| if (isWindows()) { |
| paths = paths + "c:\\Go\\bin" |
| } else { |
| paths = paths + "/usr/local/go/bin" |
| } |
| |
| def exe = (cmdPath ?: findExecutable(cmd, paths))?.trim() |
| def gobin = (project.gobind.GO ?: findExecutable("go", paths))?.trim() |
| def gomobileFlags = project.gobind.GOMOBILEFLAGS?.trim() |
| |
| if (!exe || !gobin) { |
| throw new GradleException('failed to find ${cmd}/go tools. Set gobind.GOBIND, gobind.GOMOBILE, and gobind.GO') |
| } |
| |
| paths = [findDir(exe), findDir(gobin), paths].flatten() |
| |
| def androidHome = "" |
| try { |
| Properties properties = new Properties() |
| properties.load(project.rootProject.file('local.properties').newDataInputStream()) |
| androidHome = properties.getProperty('sdk.dir') |
| } catch (all) { |
| logger.info("failed to load local.properties.") |
| } |
| if (!androidHome?.trim()) { |
| // fallback to ANDROID_HOME |
| androidHome = System.getenv("ANDROID_HOME") |
| } |
| |
| project.exec { |
| executable(exe) |
| |
| if (bootClasspath) |
| cmdArgs.addAll(["-bootclasspath", bootClasspath]) |
| if (gomobileFlags) { |
| cmdArgs.addAll(gomobileFlags.split(" ")) |
| } |
| cmdArgs.addAll(pkg.split(" ")) |
| |
| args(cmdArgs) |
| if (!androidHome?.trim()) { |
| throw new GradleException('Neither sdk.dir or ANDROID_HOME is set') |
| } |
| environment("GOPATH", gopath) |
| environment("GOOS", "android") |
| environment("PATH", paths.join(File.pathSeparator)) |
| environment("ANDROID_HOME", androidHome) |
| } |
| } |
| |
| def isWindows() { |
| return System.getProperty("os.name").startsWith("Windows") |
| } |
| |
| def findExecutable(String name, ArrayList<String> paths) { |
| if (isWindows() && !name.endsWith(".exe")) { |
| name = name + ".exe" |
| } |
| for (p in paths) { |
| def f = new File(p + File.separator + name) |
| if (f.exists()) { |
| return p + File.separator + name |
| } |
| } |
| throw new GradleException('binary ' + name + ' is not found in $PATH (' + paths + ')') |
| } |
| |
| def findDir(String binpath) { |
| if (!binpath) { |
| return "" |
| } |
| |
| def f = new File(binpath) |
| return f.getParentFile().getAbsolutePath(); |
| } |
| } |
| |
| class GobindTask extends BindTask { |
| @OutputDirectory |
| File outputDir |
| |
| JavaCompile javaCompile |
| |
| @TaskAction |
| def gobind() { |
| run("gobind", project.gobind.GOBIND, ["-lang", "java", "-classpath", javaCompile.classpath.join(File.pathSeparator), "-outdir", outputDir.getAbsolutePath()]) |
| } |
| } |
| |
| class GomobileTask extends BindTask implements OutputFileTask { |
| @Optional |
| @OutputFile |
| File outputFile |
| |
| @Optional |
| @OutputDirectory |
| File libsDir |
| |
| JavaCompile javaCompile |
| |
| @TaskAction |
| def gomobile() { |
| if (outputFile == null) { |
| outputFile = File.createTempFile("gobind-", ".aar") |
| } |
| def cmd = ["bind", "-i"] |
| // Add the generated R and databinding classes to the classpath. |
| if (javaCompile) { |
| def classpath = project.files(javaCompile.classpath, javaCompile.destinationDir) |
| cmd << "-classpath" |
| cmd << classpath.join(File.pathSeparator) |
| } |
| cmd << "-o" |
| cmd << outputFile.getAbsolutePath() |
| cmd << "-target" |
| def goarch = project.gobind.GOARCH?.trim() |
| if (goarch) { |
| cmd = cmd+goarch.split(" ").collect{ 'android/'+it }.join(",") |
| } else { |
| cmd << "android" |
| } |
| run("gomobile", project.gobind.GOMOBILE, cmd) |
| // If libsDir is set, unpack (only) the JNI libraries to it. |
| if (libsDir != null) { |
| project.delete project.fileTree(dir: libsDir, include: '*/libgojni.so') |
| def zipFile = new java.util.zip.ZipFile(outputFile) |
| zipFile.entries().findAll { !it.directory && it.name.startsWith("jni/") }.each { |
| def libFile = new File(libsDir, it.name.substring(4)) |
| libFile.parentFile.mkdirs() |
| zipFile.getInputStream(it).withStream { |
| libFile.append(it) |
| } |
| } |
| outputFile.delete() |
| } |
| } |
| } |
| |
| class GobindExtension { |
| // Package to bind. Separate multiple packages with spaces. (required) |
| def String pkg = "" |
| |
| // GOPATH: necessary for gomobile tool. (required) |
| def String GOPATH = System.getenv("GOPATH") |
| |
| // GOARCH: (List of) GOARCH to include. |
| def String GOARCH = "" |
| |
| // GO: path to go tool. (can omit if 'go' is in the paths visible by Android Studio) |
| def String GO = "" |
| |
| // GOMOBILE: path to gomobile binary. (can omit if 'gomobile' is under GOPATH) |
| def String GOMOBILE = "" |
| |
| // GOBIND: path to gobind binary. (can omit if 'gobind' is under GOPATH) |
| def String GOBIND = "" |
| |
| // GOMOBILEFLAGS: extra flags to be passed to gomobile command. (optional) |
| def String GOMOBILEFLAGS = "" |
| } |
