apply plugin: 'com.android.library'

apply plugin: "maven-publish"

apply plugin: "signing"

apply plugin: "com.google.devtools.ksp"

import org.gradle.internal.logging.text.StyledTextOutputFactory

import static org.gradle.internal.logging.text.StyledTextOutput.Style

import java.nio.file.Files

import java.nio.file.Paths

import static java.nio.file.StandardCopyOption.REPLACE_EXISTING

def log = services.get(StyledTextOutputFactory).create("sqlcipher")

android {

compileSdkVersion 37

namespace "net.zetetic.database"

defaultConfig {

minSdkVersion "${rootProject.ext.minSdkVersion}"

targetSdkVersion 37

versionCode 1

versionName "${rootProject.ext.libraryVersion}"

testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'

// The following argument makes the Android Test Orchestrator run its

// "pm clear" command after each test invocation. This command ensures

// that the app's state is completely cleared between tests.

testInstrumentationRunnerArguments clearPackageData: 'true'

consumerProguardFiles 'consumer-rules.pro'

}

base {

archivesName = "sqlcipher-android-${rootProject.ext.libraryVersion}"

}

testOptions {

execution 'ANDROIDX_TEST_ORCHESTRATOR'

}

buildTypes {

release {

minifyEnabled false

}

releaseNoX86 {

minifyEnabled false

ndk {

abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86_64'

}

}

debug {

minifyEnabled false

debuggable true

jniDebuggable true

ndk {

// Building with NDK_DEBUG=1 for mips crashes the compiler in ndk 14.

abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'

}

}

}

//sourceSets.main.jni.srcDirs = [] //disable automatic ndk-build call

externalNativeBuild {

ndkBuild {

path 'src/main/jni/Android.mk'

}

}

ndkVersion "${rootProject.ext.androidNdkVersion}"

java {

toolchain {

languageVersion = JavaLanguageVersion.of(17)

}

}

publishing {

singleVariant('release') {

withSourcesJar()

withJavadocJar()

}

}

}

static def shellCmd(String workingDirectory,

String... arguments) {

if (!arguments || arguments.length == 0) {

throw new IllegalArgumentException("At least one argument is required")

}

def command = ["sh", "-c", 'exec "$@"', "sh", *arguments]

def processBuilder = new ProcessBuilder(command)

processBuilder.directory(new File(workingDirectory))

def process = processBuilder.start()

process.inputStream.eachLine { println it }

process.errorStream.eachLine { System.err.println(it) }

process.waitFor()

}

def generateAmalgamation = tasks.register("generateAmalgamation") {

description = "Generate SQLCipher amalgamation source files"

group = "SQLCipher"

def sqlcipherDir = new File("${project.rootDir}/sqlcipher/src/main/jni/sqlcipher/")

def sqlcipherSourceDir = new File(sqlcipherDir.absolutePath, "src/")

def sqlcipherReadMe = new File(sqlcipherSourceDir.absolutePath, "README.md")

def amalgamationSource = new File(sqlcipherDir.absolutePath, "sqlite3.c")

def amalgamationHeader = new File(sqlcipherDir.absolutePath, "sqlite3.h")

doLast {

if(!sqlcipherReadMe.exists()) {

log.withStyle(Style.Info).println('SQLCipher README missing, initializing submodule')

shellCmd(project.rootDir.absolutePath, "git", "submodule", "update", "--init")

}

log.withStyle(Style.Info).println('SQLCipher amalgamation not found, generating.')

shellCmd(sqlcipherSourceDir.absolutePath, "./configure", "--with-tempstore=yes", "--disable-tcl")

shellCmd(sqlcipherSourceDir.absolutePath, "make", "clean")

shellCmd(sqlcipherSourceDir.absolutePath, "make", "sqlite3.c")

def filesToMove = ["sqlite3.c", "sqlite3.h"]

filesToMove.each {

def sourcePath = Paths.get(sqlcipherSourceDir.absolutePath, it)

def targetPath = Paths.get(sqlcipherDir.absolutePath, it)

def moveResult = Files.move(sourcePath, targetPath, REPLACE_EXISTING)

if(moveResult == null){

throw new GradleException("Faile to move ${sourcePath} to ${targetPath}")

}

}

}

onlyIf {

return !(amalgamationSource.exists()

&& amalgamationHeader.exists())

}

}

tasks.matching { it.name == "preBuild" }.configureEach {

dependsOn generateAmalgamation

}

def cleanAmalgamation = tasks.register("cleanAmalgamation") {

description = "Cleans SQLCipher amalgamation source files"

group = "SQLCipher"

def amalgamationSource = file("${project.rootDir}/sqlcipher/src/main/jni/sqlcipher/sqlite3.c")

def amalgamationHeader = file("${project.rootDir}/sqlcipher/src/main/jni/sqlcipher/sqlite3.h")

doLast {

println "Clean SQLCipher amalgamation"

delete(amalgamationSource, amalgamationHeader)

}

onlyIf {

return amalgamationSource.exists()

|| amalgamationHeader.exists()

}

}

tasks.named("clean") {

dependsOn(cleanAmalgamation)

}

dependencies {

implementation fileTree(include: ['*.jar'], dir: 'libs')

// Needed for the Support API interfaces

implementation "androidx.sqlite:sqlite:${rootProject.ext.androidXSQLiteVersion}"

// Needed for the Room library in tests

def room_version = "3.0.1"

androidTestImplementation "androidx.room3:room3-runtime:$room_version"

kspAndroidTest "androidx.room3:room3-compiler:$room_version"

// Needed for roomDatabase.getSupportWrapper() tests

androidTestImplementation "androidx.room3:room3-sqlite-wrapper:$room_version"

// Needed for runTest

androidTestImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.11.0"

// Needed for supporting tests

androidTestImplementation 'androidx.test.ext:junit:1.3.0'

androidTestImplementation 'androidx.test:rules:1.7.0'

androidTestImplementation 'androidx.test:core:1.7.0'

androidTestImplementation 'org.hamcrest:hamcrest-library:3.0'

testImplementation 'junit:junit:4.13.2'

androidTestUtil 'androidx.test:orchestrator:1.6.1'

}

allprojects {

repositories {

// The order in which you list these repositories matter.

google()

}

}

static def getReleaseRepositoryUrl() {

return "https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/"

}

def getRepositoryUsername() {

return hasProperty('nexusUsername') ? nexusUsername : ""

}

def getRepositoryPassword() {

return hasProperty('nexusPassword') ? nexusPassword : ""

}

gradle.taskGraph.whenReady { taskGraph ->

if (taskGraph.allTasks.any { it instanceof Sign }) {

allprojects { ext."signing.keyId" = "${signingKeyId}" }

allprojects { ext."signing.secretKeyRingFile" = "${signingKeyRingFile}" }

allprojects { ext."signing.password" = "${signingKeyPassword}" }

}

}

afterEvaluate {

publishing {

publications {

mavenJava(MavenPublication) {

groupId = "net.zetetic"

artifactId = "sqlcipher-android"

version = "${rootProject.ext.mavenVersionName}"

from components.release

pom {

name = "sqlcipher-android"

packaging = "aar"

description = "SQLCipher for Android a library that provides full database encryption."

url = "https://www.zetetic.net/sqlcipher"

scm {

url = "https://github.com/sqlcipher/sqlcipher-android.git"

connection = "scm:git:https://github.com/sqlcipher/sqlcipher-android.git"

developerConnection = "scm:git:https://github.com/sqlcipher/sqlcipher-android.git"

}

licenses {

license {

url = "https://www.zetetic.net/sqlcipher/license/"

}

}

developers {

developer {

name = "Zetetic Support"

email = "support@zetetic.net"

organization = "Zetetic LLC"

organizationUrl = "https://www.zetetic.net"

}

}

}

}

}

repositories {

maven {

def repoUrl = getReleaseRepositoryUrl()

url = repoUrl

credentials {

username = getRepositoryUsername()

password = getRepositoryPassword()

}

}

}

}

signing {

required { gradle.taskGraph.hasTask("publish") }

sign publishing.publications.mavenJava

}

}