apply plugin: 'com.android.library'
apply plugin: 'maven-publish'

def jniLibsDir = System.properties['jniLibsDir']
def buildDir = System.properties['buildDir']
def headersDir = System.properties['headersDir']
def publishDir = System.properties['publishDir']
def minSdkVer = System.properties['minSdkVer']
def targetSdkVer = System.properties['targetSdkVer']
boolean enableTrainingApis = (System.properties['ENABLE_TRAINING_APIS'] ?: "0") == "1"
def releaseVersionSuffix = System.properties['releaseVersionSuffix'] ?: ""
// Expected format for qnnVersion: major.minor.patch (e.g., 2.26.0)
// QNN package version does not follow Semantic Versioning (SemVer) format.
// For non qnn builds, qnnVersion will be null
def qnnVersion = System.properties['qnnVersion']

// Since Android requires higher numbers indicating more recent versions
// This function assumes ORT version number will be in the format of A.B.C[-rc/beta/alpha.D] such as 1.20.0 or 1.20.0-rc.1
// We generate version code A[0{0,1}]B[0{0,1}]C[0{0,1}]{1,2,3,4}D[01-99]
// for example '1.20.0' -> 12000400, '1.20.0-rc.1 ' -> 12000301
// '1.20.0-beta.1' -> 12000201, '1.20.0-alpha.1' -> 12000101
def getVersionCode(String version) {
	String[] versionAndRelSufx = version.split('-')
	String[] codes = versionAndRelSufx[0].split('\\.')
	// This will have problem if we have 3 digit [sub]version number, such as 1.7.199
	// but it is highly unlikely to happen
	String versionCodeStr  = String.format("%d%02d%02d", codes[0] as int, codes[1] as int, codes[2] as int)

	if (versionAndRelSufx.length > 1) {
		String suffixType = versionAndRelSufx[1].split('\\.')[0]
		String suffixNumber = versionAndRelSufx[1].split('\\.')[1]
		def suffixMap = ['alpha': '1', 'beta': '2', 'rc': '3']
		versionCodeStr += suffixMap[suffixType] + String.format("%02d", suffixNumber as int)
	} else {
		versionCodeStr += "400" // For a normal release version without suffix, get the highest version code
	}
	println "Version code for $version is $versionCodeStr"
	return versionCodeStr as int
}

project.buildDir = buildDir
def project_version = rootProject.file('../VERSION_NUMBER').text.trim()
project.version = releaseVersionSuffix ? "${project_version}${releaseVersionSuffix}" : project_version
project.group = "com.microsoft.onnxruntime"

def tmpArtifactId = enableTrainingApis ? project.name + "-training" : project.name
def mavenArtifactId = tmpArtifactId + '-android' + (qnnVersion != null ? '-qnn' : '')

//should the mavenArtifactId be read from the packageName variable as
//that's how it's used in the build_aar_copy_artifacts.sh while copying the artifacts

def defaultDescription = 'ONNX Runtime is a performance-focused inference engine for ONNX (Open Neural Network ' +
	'Exchange) models. This package contains the Android (aar) build of ONNX Runtime. It includes support for all ' +
	'types and operators, for ONNX format models. All standard ONNX models can be executed with this package.'
def trainingDescription = 'The onnxruntime-training android package is designed to efficiently train and infer a ' +
	'wide range of ONNX models on edge devices, such as mobile phones, tablets, and other portable devices with ' +
	'a focus on minimizing resource usage and maximizing accuracy.' +
	'See https://github.com/microsoft/onnxruntime-training-examples/tree/master/on_device_training for more details.'
def qnnDescription = 'ONNX Runtime is a performance-focused inference engine for ONNX (Open Neural Network ' +
	'Exchange) models. This package contains the Android (aar) build of ONNX Runtime with the QNN Execution Provider.' +
	'It includes support for all types and operators, for ONNX format models. All standard ONNX models can be executed' +
	'with this package.'

buildscript {
	repositories {
		google()
		mavenCentral()
	}
	dependencies {
		classpath 'com.android.tools.build:gradle:7.4.2'

		// NOTE: Do not place your application dependencies here; they belong
		// in the individual module build.gradle files
	}
}

allprojects {
	repositories {
		google()
		mavenCentral()
	}
}

android {
	compileSdkVersion 34

	defaultConfig {
		minSdkVersion minSdkVer
		targetSdkVersion targetSdkVer
		versionCode = getVersionCode(project.version)
		versionName = project.version

		testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
	}

	android {
		lintOptions {
			abortOnError false
		}
	}

	buildTypes {
		release {
			minifyEnabled false
			debuggable false
			proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
		}
	}

	compileOptions {
		sourceCompatibility = JavaVersion.VERSION_17
		targetCompatibility = JavaVersion.VERSION_17
	}

	sourceSets {
		main {
			jniLibs.srcDirs = [jniLibsDir]
			java {
				srcDirs = ['src/main/java', 'src/main/android']
			}
		}
	}

	namespace 'ai.onnxruntime'
}

task sourcesJar(type: Jar) {
	archiveClassifier = "sources"
	from android.sourceSets.main.java.srcDirs
}

task javadoc(type: Javadoc) {
	source = android.sourceSets.main.java.srcDirs
	classpath += project.files(android.getBootClasspath())
}

task javadocJar(type: Jar, dependsOn: javadoc) {
	archiveClassifier = 'javadoc'
	from javadoc.destinationDir
}

artifacts {
	archives javadocJar
	archives sourcesJar
}

dependencies {
	testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
	testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
	testImplementation 'com.google.protobuf:protobuf-java:3.25.5'
}

publishing {
	publications {
		maven(MavenPublication) {
			groupId = project.group
			artifactId = mavenArtifactId
			version = project.version

			// Three artifacts, the `aar`, the sources and the javadoc
			artifact("$buildDir/outputs/aar/${project.name}-release.aar")
			artifact javadocJar
			artifact sourcesJar

			pom {
				name = qnnVersion != null ? 'onnxruntime-qnn' : (enableTrainingApis ? 'onnxruntime-training' : 'onnx-runtime')
				description = qnnVersion != null ? qnnDescription : (enableTrainingApis ? trainingDescription : defaultDescription)

				url = 'https://microsoft.github.io/onnxruntime/'
				licenses {
					license {
						name = 'MIT License'
						url = 'https://opensource.org/licenses/MIT'
					}
				}
				organization {
					name = 'Microsoft'
					url = 'http://www.microsoft.com'
				}
				scm {
					connection = 'scm:git:git://github.com:microsoft/onnxruntime.git'
					developerConnection = 'scm:git:ssh://github.com/microsoft/onnxruntime.git'
					url = 'http://github.com/microsoft/onnxruntime'
				}
				developers {
					developer {
						id = 'onnxruntime'
						name = 'ONNX Runtime'
						email = 'onnxruntime@microsoft.com'
					}
				}

				if (qnnVersion != null) {
					println "Modifying the POM XML to include QNN dependency"
					withXml {
						def dependencynode = asNode().appendNode('dependencies').appendNode('dependency')
						dependencynode.appendNode('groupId', 'com.qualcomm.qti')
						dependencynode.appendNode('artifactId', 'qnn-runtime')
						dependencynode.appendNode('version', qnnVersion)
					}
				}
			}
		}
	}

	//publish to filesystem repo
	repositories{
		maven {
			url "$publishDir"
		}
	}
}

// Add ORT C and C++ API headers to the AAR package, after task bundleDebugAar or bundleReleaseAar
// Such that developers using ORT native API can extract libraries and headers from AAR package without building ORT
tasks.whenTaskAdded { task ->
	if (task.name.startsWith("bundle") && task.name.endsWith("Aar")) {
		doLast {
			addFolderToAar("addHeadersTo" + task.name, task.archivePath, headersDir, 'headers')
		}
	}
}

def addFolderToAar(taskName, aarPath, folderPath, folderPathInAar) {
	def tmpDir = file("${buildDir}/${taskName}")
	tmpDir.mkdir()
	def tmpDirFolder = file("${tmpDir.path}/${folderPathInAar}")
	tmpDirFolder.mkdir()
	copy {
		from zipTree(aarPath)
		into tmpDir
	}
	copy {
		from fileTree(folderPath)
		into tmpDirFolder
	}
	ant.zip(destfile: aarPath) {
		fileset(dir: tmpDir.path)
	}
	delete tmpDir
}