Add prototype against the new AGP API

* Add a separate Gradle source set, that is compiled against the new
  versions of AGP and Gradle

* Separate the public AGP API usages from the old internal API usages
  in KotlinPlugin.kt -- see AbstractAndroidProjectHandler

* Implement Android25ProjectHandler with the new AGP API, wired it
  to KotlinAndroidPlugin through reflection

(cherry picked from commit e6dbf54)

(cherry picked from commit 88e3d4b)

Author: h0tk3y

libraries/tools/kotlin-gradle-plugin/build.gradle

@@ -19,6 +19,13 @@ repositories {
     jcenter()
     mavenLocal()
     maven { url 'http://repository.jetbrains.com/utils/' }
+
+    // todo: remove this once the AGP artifacts get published
+    maven { url project.property("googlePreviewRepositoryPath") } // path to the local unpacked preview repo
+}
+
+configurations {
+    agp25CompileOnly
 }
 
 dependencies {
@@ -37,6 +44,10 @@ dependencies {
     compileOnly 'org.codehaus.groovy:groovy-all:2.3.9'
     compileOnly 'org.jetbrains.kotlin:gradle-api:2.2'
 
+    agp25CompileOnly 'com.android.tools.build:gradle:2.4.0-dev'
+    agp25CompileOnly 'org.codehaus.groovy:groovy-all:2.3.9'
+    agp25CompileOnly gradleApi()
+
     testCompile "org.jetbrains.kotlin:kotlin-build-common-test:$kotlin_version"
     testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
 }
@@ -54,12 +65,21 @@ sourceSets.main.compileClasspath += files(groovyClassesDir)
 compileGroovy.classpath = sourceSets.main.compileClasspath - files(groovyClassesDir)
 sourceSets.main.java.srcDirs += sourceSets.main.kotlin.srcDirs
 
+sourceSets {
+    agp25 {
+        compileClasspath += configurations.compile + configurations.agp25CompileOnly + sourceSets.main.output
+    }
+}
+
 processResources {
     expand(project.properties)
 }
 
+jar.dependsOn agp25Classes
+
 jar {
     from compileGroovy.destinationDir
+    from sourceSets.agp25.output.classesDir
 }
 
 test.executable = "${JDK_18}/bin/java"

libraries/tools/kotlin-gradle-plugin/src/agp25/kotlin/org/jetbrains/kotlin/gradle/plugin/android/Android25ProjectHandler.kt

@@ -0,0 +1,74 @@
+package org.jetbrains.kotlin.gradle.plugin
+
+import com.android.build.gradle.*
+import com.android.build.gradle.api.BaseVariant
+import com.android.build.gradle.api.SourceKind
+import com.android.build.gradle.api.TestVariant
+import com.android.build.gradle.api.UnitTestVariant
+import com.android.builder.model.SourceProvider
+import org.gradle.api.Project
+import org.gradle.api.tasks.compile.AbstractCompile
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import java.io.File
+
+@Suppress("unused")
+class Android25ProjectHandler(kotlinConfigurationTools: KotlinConfigurationTools)
+    : AbstractAndroidProjectHandler<BaseVariant>(kotlinConfigurationTools) {
+
+    override fun forEachVariant(project: Project, action: (BaseVariant) -> Unit) {
+        project.plugins.all { plugin ->
+            val androidExtension = project.extensions.getByName("android")
+            var testedExtension: TestedExtension? = null
+            when (plugin.javaClass) {
+                AppPlugin::class.java -> {
+                    (androidExtension as AppExtension).applicationVariants.all(action)
+                    testedExtension = androidExtension
+                }
+                LibraryPlugin::class.java -> {
+                    (androidExtension as LibraryExtension).libraryVariants.all(action)
+                    testedExtension = androidExtension
+                }
+                TestPlugin::class.java -> {
+                    (androidExtension as TestExtension).applicationVariants.all(action)
+                }
+            }
+            testedExtension?.apply {
+                testVariants.all(action)
+                unitTestVariants.all(action)
+            }
+        }
+    }
+
+    override fun getSourceProviders(variantData: BaseVariant): Iterable<SourceProvider> =
+            variantData.sourceSets
+
+    override fun getAllJavaSources(variantData: BaseVariant): Iterable<File> =
+            variantData.getSourceFolders(SourceKind.JAVA).map { it.dir }
+
+    override fun getVariantName(variant: BaseVariant): String = variant.name
+
+    override fun checkVariant(variant: BaseVariant) = Unit
+
+    override fun getTestedVariantData(variantData: BaseVariant): BaseVariant? = when (variantData) {
+        is TestVariant -> variantData.testedVariant
+        is UnitTestVariant -> variantData.testedVariant as? BaseVariant
+        else -> null
+    }
+
+    override fun getJavaTask(variantData: BaseVariant): AbstractCompile? =
+            @Suppress("DEPRECATION") // There is always a Java compile task -- the deprecation was for Jack
+            variantData.javaCompile
+
+    override fun addJavaSourceDirectoryToVariantModel(variantData: BaseVariant, javaSourceDirectory: File) =
+            variantData.addJavaSourceFoldersToModel(javaSourceDirectory)
+
+    override fun configureMultiProjectIc(project: Project,
+                                         variantData: BaseVariant,
+                                         javaTask: AbstractCompile,
+                                         kotlinTask: KotlinCompile,
+                                         kotlinAfterJavaTask: KotlinCompile?) {
+        //todo: No easy solution because of the absence of the output information in library modules
+        // Though it is affordable not to implement this for the first previews, because the impact is tolerable
+        // to some degree -- the dependent projects will rebuild non-incrementally when a library project changes
+    }
+}