Support building SQLCipher with LTC by default within project

Author: developernotes

Makefile

@@ -19,15 +19,6 @@ build-release:
 	-PsqlcipherAndroidVersion="$(SQLCIPHER_ANDROID_VERSION)" \
 	assembleRelease
 
-publish-snapshot-to-local-maven:
-	@ $(collect-signing-info) \
-	$(GRADLE) \
-	-PpublishSnapshot=true \
-	-Psigning.keyId="$$gpgKeyId" \
-	-Psigning.secretKeyRingFile="$$gpgKeyRingFile" \
-	-Psigning.password="$$gpgPassword" \
-	publishReleasePublicationToMavenLocal
-
 publish-remote-release:
 	@ $(collect-signing-info) \
 	$(collect-nexus-info) \

build.gradle

@@ -33,7 +33,7 @@ project.ext {
     if(project.hasProperty('sqlcipherAndroidVersion') && "${sqlcipherAndroidVersion}") {
         libraryVersion = "${sqlcipherAndroidVersion}"
     } else {
-        libraryVersion = "undefined"
+        libraryVersion = "4.14.0"
     }
     minSdkVersion = 21
     androidXSQLiteVersion = "2.2.0"
@@ -64,20 +64,20 @@ project.ext {
     nexusStagingProfileId = project.hasProperty('nexusStagingProfileId') ? "${nexusStagingProfileId}" : ""
 }
 
-task generateReadMe {
+def generateReadMe = tasks.register('generateReadMe') {
     def readme = new File("README.md")
     def engine = new SimpleTemplateEngine()
     def reader = new FileReader("README.md.template")
     def binding = [
-                    libraryVersion: project.ext.libraryVersion,
-                    androidXSQLiteVersion: project.ext.androidXSQLiteVersion,
-                    androidNdkVersion: project.ext.androidNdkVersion,
-                    minSdkVersion: project.ext.minSdkVersion,
-                  ]
+            libraryVersion       : project.ext.libraryVersion,
+            androidXSQLiteVersion: project.ext.androidXSQLiteVersion,
+            androidNdkVersion    : project.ext.androidNdkVersion,
+            minSdkVersion        : project.ext.minSdkVersion,
+    ]
     def template = engine.createTemplate(reader).make(binding)
     readme.write(template.toString())
 }
 
 project.afterEvaluate {
-    build.dependsOn generateReadMe
+    build.dependsOn(generateReadMe)
 }

sqlcipher/build.gradle

@@ -2,6 +2,14 @@ apply plugin: 'com.android.library'
 apply plugin: "maven-publish"
 apply plugin: "signing"
 
+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 34
     namespace "net.zetetic.database"
@@ -69,6 +77,75 @@ android {
 
 }
 
+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 submoduleDir = new File(sqlcipherDir.absolutePath, "src/")
+    def amalgamationSource = new File(sqlcipherDir.absolutePath, "sqlite3.c")
+    def amalgamationHeader = new File(sqlcipherDir.absolutePath, "sqlite3.h")
+    doLast {
+        if(!submoduleDir.exists()) {
+            log.withStyle(Style.Failure).println('SQLCipher submodule missing, exiting')
+            throw new GradleException("SQLCipher submodule missing: please run git submodule update --init")
+        }
+        log.withStyle(Style.Info).println('SQLCipher amalgamation not found, generating.')
+        shellCmd(submoduleDir.absolutePath, "./configure", "--with-tempstore=yes", "--disable-tcl")
+        shellCmd(submoduleDir.absolutePath, "make", "clean")
+        shellCmd(submoduleDir.absolutePath, "make", "sqlite3.c")
+        def filesToMove = ["sqlite3.c", "sqlite3.h"]
+        filesToMove.each {
+            def sourcePath = Paths.get(submoduleDir.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}")
+            }
+        }
+    }
+    outputs.upToDateWhen {
+        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)
+    }
+    outputs.upToDateWhen {
+        return !amalgamationSource.exists()
+                && !amalgamationHeader.exists()
+    }
+}
+
+tasks.named("clean") {
+    dependsOn(cleanAmalgamation)
+}
+
 dependencies {
     implementation fileTree(include: ['*.jar'], dir: 'libs')