mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
326 lines
12 KiB
Groovy
326 lines
12 KiB
Groovy
import org.apache.tools.ant.taskdefs.condition.Os
|
|
|
|
// You can add your native dependencies here
|
|
dependencies {
|
|
// implementation 'androidx.multidex:multidex:2.0.1'
|
|
// WebSocket transport for the g2mirror terminal-mirroring client.
|
|
implementation 'com.squareup.okhttp3:okhttp:4.12.0'
|
|
// WebViewCompat.addDocumentStartJavaScript, for injecting the EvenHub bridge
|
|
// shim into remotely hosted apps (developer "Load app from URL").
|
|
implementation 'androidx.webkit:webkit:1.12.1'
|
|
// Play Services' ML Kit code scanner, for the developer "Load app from QR
|
|
// code" entry. Scanner UI and camera live in Play Services, so Faceclaw
|
|
// needs no camera permission and no third-party scanner app.
|
|
implementation 'com.google.android.gms:play-services-code-scanner:16.1.0'
|
|
// Wearable Data Layer (MessageClient / DataClient / CapabilityClient) for
|
|
// the Wear OS watch remote; see FaceclawWearBridge and wear/.
|
|
implementation 'com.google.android.gms:play-services-wearable:19.0.0'
|
|
// On-device language identification and translation for the Microphones
|
|
// app's captions (translation models download on demand, per language).
|
|
implementation 'com.google.mlkit:language-id:17.0.6'
|
|
implementation 'com.google.mlkit:translate:17.0.3'
|
|
}
|
|
|
|
def faceclawSherpaOnnxVersion = "1.13.0"
|
|
def faceclawLibLc3Version = "1.1.3"
|
|
def faceclawAbi = "arm64-v8a"
|
|
def faceclawJniLibsDir = file("$projectDir/src/main/jniLibs/$faceclawAbi")
|
|
def faceclawNativeBuildDir = file("$buildDir/faceclaw-native")
|
|
|
|
def faceclawDownload = { String url, File destination ->
|
|
if (destination.exists() && destination.length() > 0) {
|
|
return
|
|
}
|
|
destination.parentFile.mkdirs()
|
|
println "Downloading $url"
|
|
destination.withOutputStream { output ->
|
|
new URL(url).withInputStream { input ->
|
|
output << input
|
|
}
|
|
}
|
|
}
|
|
|
|
def faceclawNdkHostTag = {
|
|
if (Os.isFamily(Os.FAMILY_MAC)) return "darwin-x86_64"
|
|
if (Os.isFamily(Os.FAMILY_WINDOWS)) return "windows-x86_64"
|
|
return "linux-x86_64"
|
|
}
|
|
|
|
// Host tools carry .exe on Windows. Call the binaries themselves: the NDK's
|
|
// target-prefixed clang wrappers are bash scripts (or .cmd files) that only add
|
|
// --target.
|
|
def faceclawHostExecutable = { File dir, String name ->
|
|
return file("$dir/$name${Os.isFamily(Os.FAMILY_WINDOWS) ? ".exe" : ""}")
|
|
}
|
|
|
|
def faceclawNdkTool = { File ndkRoot, String name ->
|
|
return faceclawHostExecutable(file("$ndkRoot/toolchains/llvm/prebuilt/${faceclawNdkHostTag()}/bin"), name)
|
|
}
|
|
|
|
def faceclawFindNdkRoot = {
|
|
def explicitNdk = System.getenv("ANDROID_NDK_HOME")
|
|
if (explicitNdk != null && file(explicitNdk).exists()) {
|
|
return file(explicitNdk)
|
|
}
|
|
def sdkRoot = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT")
|
|
if (sdkRoot != null) {
|
|
def ndkDir = file("$sdkRoot/ndk")
|
|
if (ndkDir.exists()) {
|
|
def installed = ndkDir.listFiles()?.findAll { it.isDirectory() }?.sort { a, b -> b.name <=> a.name }
|
|
if (installed && !installed.isEmpty()) {
|
|
return installed[0]
|
|
}
|
|
}
|
|
}
|
|
try {
|
|
return android.ndkDirectory
|
|
} catch (Throwable ignored) {
|
|
return null
|
|
}
|
|
}
|
|
|
|
tasks.register("prepareFaceclawNativeLibs") {
|
|
outputs.files(
|
|
file("$faceclawJniLibsDir/libonnxruntime.so"),
|
|
file("$faceclawJniLibsDir/libsherpa-onnx-jni.so"),
|
|
file("$faceclawJniLibsDir/libfaceclaw_lc3.so")
|
|
)
|
|
|
|
doLast {
|
|
faceclawJniLibsDir.mkdirs()
|
|
|
|
def downloadsDir = file("$faceclawNativeBuildDir/downloads")
|
|
def sherpaArchive = file("$downloadsDir/sherpa-onnx-v${faceclawSherpaOnnxVersion}-android.tar.bz2")
|
|
faceclawDownload(
|
|
"https://github.com/k2-fsa/sherpa-onnx/releases/download/v${faceclawSherpaOnnxVersion}/sherpa-onnx-v${faceclawSherpaOnnxVersion}-android.tar.bz2",
|
|
sherpaArchive
|
|
)
|
|
copy {
|
|
from tarTree(resources.bzip2(sherpaArchive))
|
|
include "**/jniLibs/$faceclawAbi/libonnxruntime.so"
|
|
include "**/jniLibs/$faceclawAbi/libsherpa-onnx-jni.so"
|
|
eachFile { details -> details.path = details.name }
|
|
includeEmptyDirs = false
|
|
into faceclawJniLibsDir
|
|
}
|
|
|
|
def lc3Archive = file("$downloadsDir/liblc3-v${faceclawLibLc3Version}.tar.gz")
|
|
faceclawDownload(
|
|
"https://github.com/google/liblc3/archive/refs/tags/v${faceclawLibLc3Version}.tar.gz",
|
|
lc3Archive
|
|
)
|
|
def lc3ExtractDir = file("$faceclawNativeBuildDir/liblc3")
|
|
if (!file("$lc3ExtractDir/liblc3-${faceclawLibLc3Version}/src/lc3.c").exists()) {
|
|
delete lc3ExtractDir
|
|
copy {
|
|
from tarTree(resources.gzip(lc3Archive))
|
|
into lc3ExtractDir
|
|
}
|
|
}
|
|
|
|
def ndkRoot = faceclawFindNdkRoot()
|
|
if (ndkRoot == null || !ndkRoot.exists()) {
|
|
throw new GradleException("Android NDK is required to build libfaceclaw_lc3.so")
|
|
}
|
|
def clang = faceclawNdkTool(ndkRoot, "clang")
|
|
if (!clang.exists()) {
|
|
throw new GradleException("Could not find Android clang at $clang")
|
|
}
|
|
|
|
def lc3Root = file("$lc3ExtractDir/liblc3-${faceclawLibLc3Version}")
|
|
def lc3Sources = [
|
|
"attdet.c", "bits.c", "bwdet.c", "energy.c", "lc3.c", "ltpf.c",
|
|
"mdct.c", "plc.c", "sns.c", "spec.c", "tables.c", "tns.c"
|
|
].collect { file("$lc3Root/src/$it").absolutePath }
|
|
|
|
exec {
|
|
commandLine([
|
|
clang.absolutePath,
|
|
"--target=aarch64-linux-android24",
|
|
"-shared",
|
|
"-fPIC",
|
|
"-O3",
|
|
"-DLC3_PLUS=0",
|
|
"-DLC3_PLUS_HR=0",
|
|
"-I${file("$lc3Root/include").absolutePath}",
|
|
file("$projectDir/src/main/native/faceclaw_lc3_decoder.c").absolutePath
|
|
] + lc3Sources + [
|
|
"-lm",
|
|
"-Wl,-z,max-page-size=16384",
|
|
"-Wl,-z,common-page-size=16384",
|
|
"-o",
|
|
file("$faceclawJniLibsDir/libfaceclaw_lc3.so").absolutePath
|
|
])
|
|
}
|
|
}
|
|
}
|
|
|
|
// On-phone assistant model: build llama.cpp (pinned release) + our JNI shim
|
|
// into libfaceclaw_llama.so. CPU-only, arm64, armv8.2 dotprod+fp16 baseline
|
|
// (Tensor G2 floor; no i8mm). The first build compiles llama.cpp (~2-4 min);
|
|
// afterwards the cached .so short-circuits everything.
|
|
def faceclawLlamaCppTag = "b10333"
|
|
|
|
def faceclawFindSdkCmakeDir = {
|
|
def sdkRoot = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT")
|
|
if (sdkRoot == null) return null
|
|
def cmakeRoot = file("$sdkRoot/cmake")
|
|
if (!cmakeRoot.exists()) return null
|
|
def installed = cmakeRoot.listFiles()?.findAll { it.isDirectory() }?.sort { a, b -> b.name <=> a.name }
|
|
return (installed && !installed.isEmpty()) ? installed[0] : null
|
|
}
|
|
|
|
tasks.register("prepareFaceclawLlama") {
|
|
def llamaSo = file("$faceclawJniLibsDir/libfaceclaw_llama.so")
|
|
inputs.files(
|
|
file("$projectDir/src/main/native/llama/faceclaw_llama.cpp"),
|
|
file("$projectDir/src/main/native/llama/CMakeLists.txt")
|
|
)
|
|
outputs.files(llamaSo)
|
|
|
|
doLast {
|
|
def llamaBuildDir = file("$faceclawNativeBuildDir/llama-build")
|
|
def builtSo = file("$llamaBuildDir/libfaceclaw_llama.so")
|
|
|
|
def downloadsDir = file("$faceclawNativeBuildDir/downloads")
|
|
def llamaArchive = file("$downloadsDir/llama.cpp-${faceclawLlamaCppTag}.tar.gz")
|
|
faceclawDownload(
|
|
"https://github.com/ggml-org/llama.cpp/archive/refs/tags/${faceclawLlamaCppTag}.tar.gz",
|
|
llamaArchive
|
|
)
|
|
def llamaSourceDir = file("$faceclawNativeBuildDir/llama.cpp-${faceclawLlamaCppTag}")
|
|
if (!file("$llamaSourceDir/CMakeLists.txt").exists()) {
|
|
copy {
|
|
from tarTree(resources.gzip(llamaArchive))
|
|
into faceclawNativeBuildDir
|
|
}
|
|
}
|
|
|
|
def ndkRoot = faceclawFindNdkRoot()
|
|
if (ndkRoot == null || !ndkRoot.exists()) {
|
|
throw new GradleException("Android NDK is required to build libfaceclaw_llama.so")
|
|
}
|
|
def cmakeDir = faceclawFindSdkCmakeDir()
|
|
if (cmakeDir == null) {
|
|
throw new GradleException("Android SDK cmake package is required to build libfaceclaw_llama.so")
|
|
}
|
|
def cmake = faceclawHostExecutable(file("$cmakeDir/bin"), "cmake")
|
|
def ninja = faceclawHostExecutable(file("$cmakeDir/bin"), "ninja")
|
|
def march = "-march=armv8.2-a+dotprod+fp16"
|
|
|
|
// Configure once; afterwards the ninja no-op build keeps this cheap while
|
|
// still picking up JNI source edits.
|
|
if (!file("$llamaBuildDir/build.ninja").exists()) {
|
|
exec {
|
|
commandLine([
|
|
cmake.absolutePath,
|
|
"-S", file("$projectDir/src/main/native/llama").absolutePath,
|
|
"-B", llamaBuildDir.absolutePath,
|
|
"-G", "Ninja",
|
|
"-DCMAKE_MAKE_PROGRAM=${ninja.absolutePath}",
|
|
"-DCMAKE_TOOLCHAIN_FILE=${file("$ndkRoot/build/cmake/android.toolchain.cmake").absolutePath}",
|
|
"-DANDROID_ABI=arm64-v8a",
|
|
"-DANDROID_PLATFORM=android-24",
|
|
"-DCMAKE_BUILD_TYPE=Release",
|
|
"-DLLAMA_CPP_SOURCE_DIR=${llamaSourceDir.absolutePath}",
|
|
"-DCMAKE_C_FLAGS=$march",
|
|
"-DCMAKE_CXX_FLAGS=$march",
|
|
])
|
|
}
|
|
}
|
|
exec {
|
|
commandLine([cmake.absolutePath, "--build", llamaBuildDir.absolutePath, "-j", "8"])
|
|
}
|
|
|
|
faceclawJniLibsDir.mkdirs()
|
|
copy {
|
|
from builtSo
|
|
into faceclawJniLibsDir
|
|
}
|
|
// The static-linked lib carries llama.cpp's full debug info (~50MB);
|
|
// strip it so the APK only pays for the code (~8MB).
|
|
def llvmStrip = faceclawNdkTool(ndkRoot, "llvm-strip")
|
|
if (llvmStrip.exists()) {
|
|
exec {
|
|
commandLine([llvmStrip.absolutePath, "--strip-unneeded", llamaSo.absolutePath])
|
|
}
|
|
} else {
|
|
logger.warn("Could not find llvm-strip at $llvmStrip; packaging an unstripped libfaceclaw_llama.so (~50MB)")
|
|
}
|
|
}
|
|
}
|
|
|
|
// versionName tracks FACECLAW_VERSION in app/version.ts, the single source of
|
|
// truth for the Faceclaw version. The gradle root project is platforms/android,
|
|
// so the repo root is two levels up from rootDir.
|
|
def faceclawVersionName = "0.0"
|
|
def faceclawVersionFile = file("$rootDir/../../app/version.ts")
|
|
if (faceclawVersionFile.exists()) {
|
|
def faceclawVersionMatch = (faceclawVersionFile.text =~ /FACECLAW_VERSION = "([^"]+)"/)
|
|
if (faceclawVersionMatch.find()) {
|
|
faceclawVersionName = faceclawVersionMatch.group(1)
|
|
}
|
|
}
|
|
def faceclawVersionCode = {
|
|
// Prerelease labels belong in versionName, not the numeric versionCode.
|
|
def parts = (faceclawVersionName.split('-')[0].tokenize('.') + ["0", "0"]).take(3)*.toInteger()
|
|
return parts[0] * 10000 + parts[1] * 100 + parts[2]
|
|
}()
|
|
|
|
android {
|
|
compileSdkVersion 35
|
|
buildToolsVersion "35"
|
|
// ndkVersion ""
|
|
|
|
sourceSets.main {
|
|
jniLibs.srcDirs += ["$projectDir/src/main/jniLibs"]
|
|
// Shared Kotlin is packaged by the local @faceclaw/kotlin plugin.
|
|
}
|
|
|
|
defaultConfig {
|
|
minSdkVersion 24
|
|
targetSdkVersion 35
|
|
ndk {
|
|
// The NativeScript platform build.gradle has already added all four
|
|
// ABIs by the time app.gradle is applied, and abiFilters is additive,
|
|
// so the set must be cleared for this filter to take effect. Only
|
|
// arm64 devices are supported (all our own JNI libs are arm64-only).
|
|
abiFilters.clear()
|
|
abiFilters "arm64-v8a"
|
|
}
|
|
|
|
// Version Information (derived from app/version.ts above)
|
|
versionCode faceclawVersionCode
|
|
versionName faceclawVersionName
|
|
|
|
generatedDensities = []
|
|
}
|
|
|
|
aaptOptions {
|
|
additionalParameters "--no-version-vectors"
|
|
}
|
|
}
|
|
|
|
// NativeScript can retain deleted App_Resources sources in its generated
|
|
// project. Remove the former copy before Kotlin compilation after this move.
|
|
def removeLegacyKotlinBridgeSource = tasks.register("removeLegacyKotlinBridgeSource", Delete) {
|
|
delete file("$projectDir/src/main/java/com/faceclaw/shared/KotlinBridge.kt")
|
|
// Explicit, reviewed source moves: never infer deletions from class names.
|
|
def migrations = new groovy.json.JsonSlurper().parse(file("$rootDir/../../native/kotlin/migrated-java-sources.json"))
|
|
migrations.each { migration ->
|
|
if (!file("$rootDir/../../${migration.kotlin}").isFile()) {
|
|
throw new GradleException("Missing Kotlin replacement: ${migration.kotlin}")
|
|
}
|
|
delete file("$projectDir/src/main/java/${migration.java}")
|
|
}
|
|
}
|
|
tasks.matching { it.name.startsWith("compile") && it.name.endsWith("Kotlin") }.configureEach {
|
|
dependsOn removeLegacyKotlinBridgeSource
|
|
}
|
|
|
|
tasks.matching { it.name == "preBuild" }.configureEach {
|
|
dependsOn removeLegacyKotlinBridgeSource
|
|
dependsOn tasks.named("prepareFaceclawNativeLibs")
|
|
dependsOn tasks.named("prepareFaceclawLlama")
|
|
}
|