feat: android plugin build will use its own plugin dependencies to build

This allow a Nativescript plugin to depend on another nativescript native plugin code

Author: farfromrefug

lib/services/android-plugin-build-service.ts

@@ -258,7 +258,8 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 			await this.setupGradle(
 				pluginTempDir,
 				options.platformsAndroidDirPath,
-				options.projectDir
+				options.projectDir,
+				options.pluginName
 			);
 			await this.buildPlugin({
 				gradlePath: options.gradlePath,
@@ -398,7 +399,8 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 	private async setupGradle(
 		pluginTempDir: string,
 		platformsAndroidDirPath: string,
-		projectDir: string
+		projectDir: string,
+		pluginName: string
 	): Promise<void> {
 		const gradleTemplatePath = path.resolve(
 			path.join(__dirname, "../../vendor/gradle-plugin")
@@ -419,6 +421,11 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 			buildGradlePath,
 			runtimeGradleVersions.gradleAndroidPluginVersion
 		);
+		this.replaceFileContent(
+			buildGradlePath,
+			"{{pluginName}}",
+			pluginName
+		);
 	}
 
 	private async getRuntimeGradleVersions(

lib/services/android-project-service.ts

@@ -48,6 +48,25 @@ import { IInjector } from "../common/definitions/yok";
 import { injector } from "../common/yok";
 import { INotConfiguredEnvOptions } from "../common/definitions/commands";
 
+
+
+interface NativeDependency {
+	name: string;
+	directory: string;
+	dependencies: string[];
+}
+function treeSort(obj: NativeDependency[], start:NativeDependency[], depth = 0):NativeDependency[] {
+	const processed = obj.reduce((a,b,i) => {
+	  if (b.dependencies.every(Array.prototype.includes, a.map(n=>n.name))) {
+		  a.push(b);
+	  }
+	  return  a;
+	}, start);
+	const nextNames = obj.filter(n => !processed.includes(n));
+	const goAgain = nextNames.length && depth <= obj.length;
+	return goAgain ? treeSort(nextNames, processed, depth + 1) : processed;
+}
+
 export class AndroidProjectService extends projectServiceBaseLib.PlatformProjectServiceBase {
 	private static VALUES_DIRNAME = "values";
 	private static VALUES_VERSION_DIRNAME_PREFIX =
@@ -635,10 +654,10 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 	public async beforePrepareAllPlugins(
 		projectData: IProjectData,
 		dependencies?: IDependencyData[]
-	): Promise<void> {
+	): Promise<IDependencyData[]> {
 		if (dependencies) {
 			dependencies = this.filterUniqueDependencies(dependencies);
-			this.provideDependenciesJson(projectData, dependencies);
+			return this.provideDependenciesJson(projectData, dependencies);
 		}
 	}
 
@@ -666,7 +685,7 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 	private provideDependenciesJson(
 		projectData: IProjectData,
 		dependencies: IDependencyData[]
-	): void {
+	): IDependencyData[] {
 		const platformDir = path.join(
 			projectData.platformsDir,
 			AndroidProjectService.ANDROID_PLATFORM_NAME
@@ -675,15 +694,21 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 			platformDir,
 			constants.DEPENDENCIES_JSON_NAME
 		);
-		const nativeDependencies = dependencies
-			.filter(AndroidProjectService.isNativeAndroidDependency)
-			.map(({ name, directory }) => ({
+		let nativeDependencyDatas = dependencies
+			.filter(AndroidProjectService.isNativeAndroidDependency);
+		
+		let nativeDependencies = nativeDependencyDatas.map(({ name, directory, dependencies }) => ({
 				name,
 				directory: path.relative(platformDir, directory),
-			}));
+				dependencies:dependencies.filter(d=>nativeDependencyDatas.findIndex(nd=>nd.name===d) !== -1)
+			} as NativeDependency));
+		nativeDependencies = treeSort(nativeDependencies, []);
 		const jsonContent = JSON.stringify(nativeDependencies, null, 4);
 
 		this.$fs.writeFile(dependenciesJsonPath, jsonContent);
+		return dependencies.sort(function(a, b){  
+			return nativeDependencies.findIndex(n => n.name === a.name) - nativeDependencies.findIndex(n => n.name === b.name);
+		});
 	}
 
 	private static isNativeAndroidDependency({

lib/services/ios-project-service.ts

@@ -29,8 +29,9 @@ import {
 	IIOSNativeTargetService,
 	IValidatePlatformOutput,
 } from "../definitions/project";
+
 import { IBuildData } from "../definitions/build";
-import { IXcprojService, IXcconfigService, IOptions } from "../declarations";
+import { IXcprojService, IXcconfigService, IDependencyData, IOptions } from "../declarations";
 import { IPluginData, IPluginsService } from "../definitions/plugins";
 import {
 	IFileSystem,
@@ -976,8 +977,11 @@ export class IOSProjectService extends projectServiceBaseLib.PlatformProjectServ
 		await this.addExtensions(projectData, pluginsData);
 	}
 
-	public beforePrepareAllPlugins(): Promise<void> {
-		return Promise.resolve();
+	public beforePrepareAllPlugins(
+		projectData: IProjectData,
+		dependencies?: IDependencyData[]
+	): Promise<IDependencyData[]> {
+		return Promise.resolve(dependencies);
 	}
 
 	public async checkForChanges(

lib/services/webpack/webpack.d.ts

@@ -163,7 +163,7 @@ declare global {
 		beforePrepareAllPlugins(
 			projectData: IProjectData,
 			dependencies?: IDependencyData[]
-		): Promise<void>;
+		): Promise<IDependencyData[]>;
 
 		handleNativeDependenciesChange(
 			projectData: IProjectData,

lib/tools/node-modules/node-modules-builder.ts

@@ -18,10 +18,10 @@ export class NodeModulesBuilder implements INodeModulesBuilder {
 		platformData,
 		projectData,
 	}: IPrepareNodeModulesData): Promise<void> {
-		const dependencies = this.$nodeModulesDependenciesBuilder.getProductionDependencies(
+		let dependencies = this.$nodeModulesDependenciesBuilder.getProductionDependencies(
 			projectData.projectDir, projectData.ignoredDependencies
 		);
-		await platformData.platformProjectService.beforePrepareAllPlugins(
+		dependencies = await platformData.platformProjectService.beforePrepareAllPlugins(
 			projectData,
 			dependencies
 		);

test/stubs.ts

@@ -49,6 +49,9 @@ import {
 	IDeviceDebugService,
 	IDebugResultInfo,
 } from "../lib/definitions/debug";
+import {
+	IDependencyData,
+} from "../lib/declarations";
 import { IBuildData } from "../lib/definitions/build";
 import {
 	IFileSystem,
@@ -827,8 +830,11 @@ export class PlatformProjectServiceStub
 		return Promise.resolve();
 	}
 
-	async beforePrepareAllPlugins(): Promise<void> {
-		return Promise.resolve();
+	async beforePrepareAllPlugins(
+		projectData: IProjectData,
+		dependencies?: IDependencyData[]
+	): Promise<IDependencyData[]> {
+		return Promise.resolve(dependencies);
 	}
 
 	async cleanDeviceTempFolder(deviceIdentifier: string): Promise<void> {

vendor/gradle-plugin/build.gradle

@@ -12,7 +12,11 @@ def computeTargetSdkVersion = { -> project.hasProperty("targetSdk") ? targetSdk
 def computeBuildToolsVersion = { ->
     project.hasProperty("buildToolsVersion") ? buildToolsVersion : "31.0.0"
 }
+
 buildscript {
+    def getDepPlatformDir = { dep ->
+        file("${project.ext.USER_PROJECT_ROOT}/${project.ext.PLATFORMS_ANDROID}/${dep.directory}/$PLATFORMS_ANDROID")
+    }
     def computeKotlinVersion = { -> project.hasProperty("kotlinVersion") ? kotlinVersion : "1.6.0" }
     def kotlinVersion = computeKotlinVersion()
     repositories {
@@ -28,10 +32,18 @@ buildscript {
     }
 
     // Set up styled logger
+    project.ext.getDepPlatformDir = getDepPlatformDir
     project.ext.outLogger = services.get(StyledTextOutputFactory).create("colouredOutputLogger")
 
     project.ext.USER_PROJECT_ROOT = "$rootDir/../../.."
-
+    project.ext.PLATFORMS_ANDROID = "platforms/android"
+    project.ext.PLUGIN_NAME = "{{pluginName}}"
+
+    // the build script will not work with previous versions of the CLI (3.1 or earlier)
+    def dependenciesJson = file("${project.ext.USER_PROJECT_ROOT}/${project.ext.PLATFORMS_ANDROID}/dependencies.json")
+    def appDependencies = new JsonSlurper().parseText(dependenciesJson.text)
+    def pluginData = appDependencies.find { it.name == project.ext.PLUGIN_NAME }
+    project.ext.nativescriptDependencies = appDependencies.findAll{pluginData.dependencies.contains(it.name)}
     project.ext.getAppPath = { ->
         def relativePathToApp = "app"
         def nsConfigFile = file("$USER_PROJECT_ROOT/nsconfig.json")
@@ -90,6 +102,15 @@ buildscript {
             apply from: pathToBuildScriptGradle, to: buildscript
         }
 
+        nativescriptDependencies.each { dep ->
+            def pathToPluginBuildScriptGradle = "${getDepPlatformDir(dep)}/buildscript.gradle"
+            def pluginBuildScriptGradle = file(pathToPluginBuildScriptGradle)
+            if (pluginBuildScriptGradle.exists()) {
+                outLogger.withStyle(Style.SuccessHeader).println "\t + applying user-defined buildscript from dependency ${pluginBuildScriptGradle}"
+                apply from: pathToPluginBuildScriptGradle, to: buildscript
+            }
+        }
+
         def pathToPluginBuildScriptGradle = "$rootDir/buildscript.gradle"
         def pluginBuildScriptGradle = file(pathToPluginBuildScriptGradle)
         if (pluginBuildScriptGradle.exists()) {
@@ -101,23 +122,48 @@ buildscript {
 
 }
 
+def pluginDependencies
+
 allprojects {
     repositories {
+        // used for local *.AAR files
+        pluginDependencies = nativescriptDependencies.collect {
+            getDepPlatformDir(it)
+        }
+
+        // some plugins may have their android dependencies in a /libs subdirectory
+        pluginDependencies.addAll(nativescriptDependencies.collect {
+            "${getDepPlatformDir(it)}/libs"
+        })
         mavenLocal()
         mavenCentral()
         maven {
             url 'https://maven.google.com/'
             name 'Google'
         }
         jcenter()
+        if (pluginDependencies.size() > 0) {
+            flatDir {
+                dirs pluginDependencies
+            }
+        }
     }
 }
 
 android {
+    def applyPluginGradleConfigurations = { ->
+        nativescriptDependencies.each { dep ->
+            def includeGradlePath = "${getDepPlatformDir(dep)}/include.gradle"
+            if (file(includeGradlePath).exists()) {
+                apply from: includeGradlePath
+            }
+        }
+    }
     kotlinOptions {
         jvmTarget = '1.8'
     }
     applyBeforePluginGradleConfiguration()
+    applyPluginGradleConfigurations()
 
     compileSdkVersion computeCompileSdkVersion()
     buildToolsVersion computeBuildToolsVersion()
@@ -164,4 +210,27 @@ tasks.whenTaskAdded({ DefaultTask currentTask ->
             currentTask.exclude '**/R.class', '**/R$*.class'
         }
     }
-})
+})
+
+
+
+task addDependenciesFromNativeScriptPlugins {
+    nativescriptDependencies.each { dep ->
+        def aarFiles = fileTree(dir: getDepPlatformDir(dep), include: ["**/*.aar"])
+        aarFiles.each { aarFile ->
+            def length = aarFile.name.length() - 4
+            def fileName = aarFile.name[0..<length]
+            outLogger.withStyle(Style.SuccessHeader).println "\t + adding aar plugin dependency: " + aarFile.getAbsolutePath()
+            project.dependencies.add("implementation", [name: fileName, ext: "aar"])
+        }
+
+        def jarFiles = fileTree(dir: getDepPlatformDir(dep), include: ["**/*.jar"])
+        jarFiles.each { jarFile ->
+            def jarFileAbsolutePath = jarFile.getAbsolutePath()
+            outLogger.withStyle(Style.SuccessHeader).println "\t + adding jar plugin dependency: $jarFileAbsolutePath"
+            pluginsJarLibraries.add(jarFile.getAbsolutePath())
+        }
+
+        project.dependencies.add("implementation", jarFiles)
+    }
+}