blob: 29fca279b71d2d49b0912f26efe5fee47c046db4 [file] [log] [blame]
/*
* Copyright 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// The SampleGenPlugin source is in the buildSrc directory.
import com.example.android.samples.build.SampleGenPlugin
apply plugin: SampleGenPlugin
// Add a preflight task that depends on the "refresh" task that gets
// added by the SampleGenPlugin.
task preflight {
project.afterEvaluate({preflight.dependsOn(project.refresh)})
}
String outPath(String buildType) {
/*
def repoInfo = "repo info platform/developers/build".execute().text
def buildPath = (repoInfo =~ /Mount path: (.*)/)[0][1]
*/
return "${samplegen.pathToBuild}/out/${buildType}/${samplegen.targetSampleName()}";
}
/**
* Collapse a path "IntelliJ-style" by putting dots rather than slashes between
* path components that have only one child. So the two paths
*
* com/example/android/foo/bar.java
* com/example/android/bar/foo.java
*
* Become
* com.example.android/foo/bar.java
* com.example.android/bar/foo.java
*
* @param path
* @param roots
* @return
*/
Map<String,String> collapsePaths(FileTree path, List<String> roots) {
Map result = new HashMap<String,String>();
println ("******************** Collapse *************************")
path.visit { FileVisitDetails f ->
if (f.isDirectory()) return;
StringBuilder collapsedPath = new StringBuilder("${f.name}");
File current = f.file;
//
// Starting at this file, walk back to the root of the path and
// substitute dots for any directory that has only one child.
//
// Don't substitute a dot for the separator between the end of the
// path and the filename, even if there's only one file in the directory.
if (!f.isDirectory()) {
current = current.parentFile;
collapsedPath.insert(0, "${current.name}/")
}
// For everything else, use a dot if there's only one child and
// a slash otherwise. Filter out the root paths, too--we only want
// the relative path. But wait, Groovy/Gradle is capricious and
// won't return the proper value from a call to roots.contains(String)!
// I'm using roots.sum here instead of tracking down why a list of
// strings can't return true from contains() when given a string that
// it quite obviously does contain.
current = current.parentFile;
while((current != null)
&& (roots.sum {String r-> return r.equals(current.absolutePath) ? 1 : 0 } == 0)) {
char separator = current.list().length > 1 ? '/' : '.';
collapsedPath.insert(0, "${current.name}${separator}");
current = current.parentFile;
}
result.put(f.file.path, collapsedPath.toString());
}
println ("******************** Collapse results *********************")
result.each {entry -> println("- ${entry}");}
return result
}
task emitAnt(type:Copy) {
def outputPath = outPath("ant");
def inputPath = "${project.projectDir}/${samplegen.targetSampleModule()}"
into outputPath
includeEmptyDirs
["main", "common", "template"].each { input ->
[[ "java", "src"], ["res", "res"]].each { filetype ->
def srcPath = "${inputPath}/src/${input}/${filetype[0]}"
into("${filetype[1]}") {
from(srcPath)
}
}
}
from("${inputPath}/src/main") { include "AndroidManifest.xml" }
from("${inputPath}/src/template") { include "project.properties" }
}
task emitGradle(type:Copy) {
dependsOn(preflight)
def outputPath = outPath("gradle")
def inputPath = "${project.projectDir}"
// Copy entire sample into output -- since it's already in Gradle format, we'll explicitly exclude content that
// doesn't belong here.
into outputPath
from("${inputPath}") {
// Paths to exclude from output
exclude ".gradle"
exclude "_index.jd"
exclude "bin"
exclude "buildSrc"
exclude "local.properties"
exclude "template-params.xml"
exclude "*.iml"
exclude "**/.idea"
exclude "**/build"
exclude "**/proguard-project.txt"
exclude "${samplegen.targetSampleModule()}/**/README*.txt"
exclude "**/README-*.txt"
// src directory needs to be consolidated, will be done in next section
exclude "${samplegen.targetSampleModule()}/src/"
}
// Consolidate source directories
["main", "common", "template"].each { input ->
["java", "res", "assets", "rs"].each { filetype ->
def srcPath = "${inputPath}/${samplegen.targetSampleModule()}/src/${input}/${filetype}"
into("${samplegen.targetSampleModule()}/src/main/${filetype}") {
from(srcPath)
}
}
}
// Copy AndroidManifest.xml
into ("${samplegen.targetSampleModule()}/src/main") {
from("${inputPath}/${samplegen.targetSampleModule()}/src/main/AndroidManifest.xml")
}
// Remove BEGIN_EXCLUDE/END_EXCLUDE blocks from source files
eachFile { file ->
if (file.name.endsWith(".gradle") || file.name.endsWith(".java")) {
// TODO(trevorjohns): Outputs a blank newline for each filtered line. Replace with java.io.FilterReader impl.
boolean outputLines = true;
def removeExcludeBlocksFilter = { line ->
if (line ==~ /\/\/ BEGIN_EXCLUDE/) {
outputLines = false;
} else if (line ==~ /\/\/ END_EXCLUDE/) {
outputLines = true;
} else if (outputLines) {
return line;
}
return ""
}
filter(removeExcludeBlocksFilter)
}
}
}
task emitBrowseable(type:Copy) {
def outputPathRoot = outPath("browseable")
def modules = project.childProjects.keySet()
def hasMultipleModules = modules.size() > 1
println "---------------- modules found in sample: ${modules}"
into outputPathRoot
from("${project.projectDir}/_index.jd")
modules.each { moduleName ->
// For single module samples (default), we emit the module contents
// directly to the root of the browseable sample:
def outputPath = "."
if (hasMultipleModules) {
// For multi module samples, we need an extra directory level
// to separate modules:
outputPath = "${moduleName}"
}
println "\n---------------- processing MODULE ${moduleName} to outputPath ${outputPath}"
def inputPath = "${project.projectDir}/${moduleName}"
def srcDirs = ["main", "common", "template"].collect {input -> "${inputPath}/src/${input}" };
def javaDirs = srcDirs.collect { input -> "${input}/java"}
FileTree javaTree = null;
javaDirs.each { dir ->
FileTree tree = project.fileTree("${dir}")
javaTree = (javaTree == null) ? tree : javaTree.plus(tree)}
Map collapsedPaths = collapsePaths(javaTree, javaDirs)
srcDirs.each { srcPath ->
print "** Copying source ${srcPath}...";
duplicatesStrategy = 'fail'
into("${outputPath}/src") {
def javaPath = "${srcPath}/java";
from(javaPath)
include(["**/*.java", "**/*.xml"])
eachFile { FileCopyDetails fcd ->
if (fcd.file.isFile()) {
def filename = fcd.name;
String collapsed = collapsedPaths.get(fcd.file.path);
fcd.path = "${outputPath}/src/${collapsed}";
} else {fcd.exclude()}
}
println "done"
}
into("${outputPath}/res") {
from("${srcPath}/res")
}
into("${outputPath}/src/rs") {
from("${srcPath}/rs")
}
into("${outputPath}") {from("${srcPath}/AndroidManifest.xml")}
}
}
}
task emitGradleZip(dependsOn: [emitBrowseable, emitGradle], type:Zip) {
def outputPath = "${samplegen.pathToBuild}/out/browseable"
def folderName = "${samplegen.targetSampleName()}"
archiveName = "${samplegen.targetSampleName()}.zip"
def inputPath = outPath("gradle")
from inputPath
into folderName
include "**"
def outDir = project.file(outputPath)
destinationDir = outDir
}