@glassly/bluetooth-sdk 0.1.0-dev.26

package/android/build.gradle

@@ -0,0 +1,450 @@
+import groovy.json.JsonSlurper
+import java.security.MessageDigest
+
+apply plugin: 'com.android.library'
+apply plugin: 'maven-publish'
+apply plugin: 'signing'
+
+def packageJson = new JsonSlurper().parse(file("../package.json"))
+def mavenGroupId = 'com.glassly'
+def mavenPublishVersion = (findProperty('glasslyMavenVersion') ?: System.getenv('MAVEN_VERSION') ?: packageJson.version).toString()
+def publicMavenSdk = (findProperty('glasslyPublicSdk') ?: System.getenv('PUBLIC_SDK') ?: 'false').toString().toBoolean()
+
+// Download Sherpa-ONNX Android AAR from the upstream GitHub release and stage
+// it as a Maven artifact in a tiny on-disk repository under libs/maven/.
+// Why this shape:
+//   - Jitpack stopped publishing for v1.13.2+ (their build step fails because
+//     the AAR asset isn't present when its install-file step runs).
+//   - We can't just `implementation files("…aar")` because AGP refuses local
+//     .aar deps from library modules ("Direct local .aar file dependencies
+//     are not supported when building an AAR"). Maven-coord deps are fine.
+// The SHA-256 is pinned (computed from the upstream release asset for v1.13.4;
+// upstream ships no checksum.txt for this tag) so a tampered or
+// partially-written artifact is rejected before being used.
+def sherpaOnnxGroup = "com.k2fsa.sherpa.onnx"
+def sherpaOnnxArtifact = "sherpa-onnx"
+def sherpaOnnxVersion = "1.13.4"
+def sherpaOnnxSha256 = "03f9c4df965f21c71269365a7951a7f23b5696fddd093fa318c80d65550ab780"
+
+def sherpaOnnxMavenRoot = file("libs/maven")
+def sherpaOnnxRepoDir = new File(
+  sherpaOnnxMavenRoot,
+  "${sherpaOnnxGroup.replace('.', '/')}/${sherpaOnnxArtifact}/${sherpaOnnxVersion}"
+)
+def sherpaOnnxAar = new File(sherpaOnnxRepoDir, "${sherpaOnnxArtifact}-${sherpaOnnxVersion}.aar")
+def sherpaOnnxPom = new File(sherpaOnnxRepoDir, "${sherpaOnnxArtifact}-${sherpaOnnxVersion}.pom")
+
+def sha256OfFile = { File f ->
+  def digest = MessageDigest.getInstance("SHA-256")
+  f.withInputStream { input ->
+    def buf = new byte[64 * 1024]
+    int n
+    while ((n = input.read(buf)) != -1) {
+      digest.update(buf, 0, n)
+    }
+  }
+  digest.digest().collect { String.format("%02x", it & 0xff) }.join("")
+}
+
+// If a stale AAR exists with the wrong hash (e.g. from a previous failed
+// download or a version bump), drop it so we re-fetch.
+if (sherpaOnnxAar.exists() && sha256OfFile(sherpaOnnxAar) != sherpaOnnxSha256) {
+  logger.lifecycle("Sherpa-ONNX AAR checksum mismatch on disk; redownloading.")
+  if (!sherpaOnnxAar.delete()) {
+    throw new GradleException(
+      "Sherpa-ONNX AAR at ${sherpaOnnxAar.absolutePath} has a mismatched SHA-256 " +
+      "but could not be deleted. Refusing to continue with a potentially tampered artifact."
+    )
+  }
+}
+
+if (!sherpaOnnxAar.exists()) {
+  sherpaOnnxRepoDir.mkdirs()
+  def sherpaOnnxUrl = "https://github.com/k2-fsa/sherpa-onnx/releases/download/v${sherpaOnnxVersion}/${sherpaOnnxArtifact}-${sherpaOnnxVersion}.aar"
+  logger.lifecycle("Downloading Sherpa-ONNX AAR v${sherpaOnnxVersion} from GitHub release…")
+  // Download to a .part sibling and rename only after the SHA-256 matches, so
+  // an interrupted or tampered download can't be silently accepted as valid.
+  def partial = file("${sherpaOnnxAar.absolutePath}.part")
+  try {
+    new URL(sherpaOnnxUrl).withInputStream { input ->
+      partial.withOutputStream { output -> output << input }
+    }
+    def actual = sha256OfFile(partial)
+    if (actual != sherpaOnnxSha256) {
+      throw new GradleException(
+        "Sherpa-ONNX AAR v${sherpaOnnxVersion} SHA-256 mismatch.\n" +
+        "  expected: ${sherpaOnnxSha256}\n" +
+        "  actual:   ${actual}\n" +
+        "Refusing to use the downloaded artifact."
+      )
+    }
+    if (!partial.renameTo(sherpaOnnxAar)) {
+      throw new GradleException("Failed to move ${partial.name} to ${sherpaOnnxAar.name}")
+    }
+  } finally {
+    if (partial.exists()) {
+      partial.delete()
+    }
+  }
+}
+
+// Minimal POM so the Maven resolver is happy. No transitive deps — the AAR
+// ships its own native libs and we already pin onnxruntime separately below.
+if (!sherpaOnnxPom.exists()) {
+  sherpaOnnxPom.text = """<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>${sherpaOnnxGroup}</groupId>
+  <artifactId>${sherpaOnnxArtifact}</artifactId>
+  <version>${sherpaOnnxVersion}</version>
+  <packaging>aar</packaging>
+</project>
+"""
+}
+
+repositories {
+  maven { url = uri(sherpaOnnxMavenRoot) }
+  maven { url 'https://jitpack.io' }
+}
+
+
+group = mavenGroupId
+version = mavenPublishVersion
+
+def credentialValue = { List<String> propertyNames, List<String> envNames ->
+  for (propertyName in propertyNames) {
+    def value = findProperty(propertyName)
+    if (value != null && value.toString().trim()) {
+      return value.toString()
+    }
+  }
+  for (envName in envNames) {
+    def value = System.getenv(envName)
+    if (value != null && value.trim()) {
+      return value
+    }
+  }
+  return null
+}
+
+def centralTokenParts = { boolean failOnInvalid = false ->
+  def token = credentialValue(['sonatypeTokenBase64', 'mavenCentralTokenBase64'], ['SONATYPE_TOKEN_BASE64', 'MAVEN_CENTRAL_TOKEN_BASE64'])
+  if (!token) {
+    return null
+  }
+  def decoded
+  try {
+    decoded = new String(token.decodeBase64(), 'UTF-8')
+  } catch (Exception e) {
+    if (failOnInvalid) {
+      throw new GradleException('Sonatype token must be valid base64 for username:password', e)
+    }
+    return null
+  }
+  def separator = decoded.indexOf(':')
+  if (separator <= 0) {
+    if (failOnInvalid) {
+      throw new GradleException('Sonatype token must decode to username:password')
+    }
+    return null
+  }
+  return [decoded.substring(0, separator), decoded.substring(separator + 1)]
+}
+
+def centralUsername = { boolean failOnInvalidToken = false ->
+  credentialValue(['sonatypeUsername', 'mavenCentralUsername'], ['SONATYPE_USERNAME', 'MAVEN_CENTRAL_USERNAME']) ?: centralTokenParts(failOnInvalidToken)?.get(0)
+}
+
+def centralPassword = { boolean failOnInvalidToken = false ->
+  credentialValue(['sonatypePassword', 'mavenCentralPassword'], ['SONATYPE_PASSWORD', 'MAVEN_CENTRAL_PASSWORD']) ?: centralTokenParts(failOnInvalidToken)?.get(1)
+}
+
+def signingKey = {
+  credentialValue(['signingKey'], ['SIGNING_KEY'])
+}
+
+def signingPassword = {
+  credentialValue(['signingPassword'], ['SIGNING_PASSWORD'])
+}
+
+def shouldUseGpgCmd = {
+  (credentialValue(['signing.useGpgCmd'], ['SIGNING_USE_GPG_CMD']) ?: 'false').toBoolean()
+}
+
+def isCentralPublishTask = {
+  gradle.taskGraph.allTasks.any { it.name.toLowerCase().contains('sonatypecentral') }
+}
+
+gradle.taskGraph.whenReady {
+  if (isCentralPublishTask()) {
+    centralUsername(true)
+    centralPassword(true)
+  }
+}
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+  useDefaultAndroidSdkVersions()
+} else {
+  buildscript {
+    // Simple helper that allows the root project to override versions declared by this library.
+    ext.safeExtGet = { prop, fallback ->
+      rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+  }
+  project.android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 36)
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 28)
+      targetSdkVersion safeExtGet("targetSdkVersion", 36)
+    }
+  }
+}
+
+android {
+  namespace "com.glassly.bluetoothsdk"
+  defaultConfig {
+    versionCode 1
+    versionName project.version
+    buildConfigField "String", "SDK_VERSION", "\"${project.version}\""
+  }
+  publishing {
+    singleVariant("release") {
+      withSourcesJar()
+      withJavadocJar()
+    }
+  }
+  lintOptions {
+    abortOnError false
+  }
+  testOptions {
+    unitTests {
+      includeAndroidResources = true
+    }
+  }
+  packagingOptions {
+    pickFirst '**/libjsc.so'
+    pickFirst '**/libc++_shared.so'
+    pickFirst '**/libonnxruntime.so'
+    pickFirst '**/libonnxruntime4j_jni.so'
+  }
+}
+
+dependencies {
+  // Expo adapter class is compiled into the Glassly module, but the bare SDK
+  // artifact should not expose Expo as a runtime dependency.
+  compileOnly project(':expo-modules-core')
+
+  // Kotlin standard library (explicitly added for IDE support)
+  // Version is managed by Expo modules, but explicit dependency helps IDE indexing
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+
+  implementation "androidx.lifecycle:lifecycle-service:2.6.1"
+  implementation "org.greenrobot:eventbus:3.3.1"
+  implementation 'com.google.code.gson:gson:2.10.1'
+
+  // Google Play Services for location settings dialog
+  implementation 'com.google.android.gms:play-services-location:21.0.1'
+  implementation 'com.google.android.gms:play-services-base:18.2.0'
+
+  // Apache Commons Compress for tar.bz2 extraction
+  implementation 'org.apache.commons:commons-compress:1.24.0'
+
+  // OkHttp for HTTP requests
+  implementation 'com.squareup.okhttp3:okhttp:4.12.0'
+  implementation 'androidx.exifinterface:exifinterface:1.3.7'
+
+  // AVIF decode for BLE photo fallback. Public Maven artifacts omit this
+  // JitPack-only decoder from runtime metadata; Android 12+ can still use the
+  // platform decoder, while Glassly app builds keep HeifCoder for broader
+  // fallback support.
+  // Pinned to the JitPack 1.7.3 build (same as asg_client): the Maven Central
+  // 2.2.x releases transitively pull kotlin-stdlib 2.3.0, which breaks this
+  // project's Kotlin 2.1 compile of :expo.
+  dependencies.add(publicMavenSdk ? 'compileOnly' : 'implementation', 'com.github.awxkee:avif-coder:1.7.3')
+
+  testImplementation 'junit:junit:4.13.2'
+  testImplementation 'org.robolectric:robolectric:4.11.1'
+  testImplementation 'org.assertj:assertj-core:3.24.2'
+  testImplementation 'androidx.test:core:1.5.0'
+
+  // Local photo upload receiver
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1"
+
+  // AR99 GATT Opus to PCM decoder.
+  implementation 'io.github.jaredmdobson:concentus:1.0.1'
+
+  // LC3 audio codec library
+  implementation project(':lc3Lib')
+
+  // These integrations are used by the full Glassly app, but are not exposed
+  // through the public SDK API. Public Maven artifacts compile against them
+  // without publishing them as runtime transitives, so consumers only need
+  // Maven Central/Google repositories for normal SDK use.
+  def optionalGlasslyIntegrationDependency = publicMavenSdk ? 'compileOnly' : 'implementation'
+
+  // Sherpa-ONNX for local transcription. Jitpack's v1.13.2 build failed
+  // upstream, so we stage the prebuilt AAR into libs/maven/ (see top of file)
+  // and consume it as a Maven coord — AGP rejects raw files() .aar deps in
+  // library modules.
+  dependencies.add(optionalGlasslyIntegrationDependency, "${sherpaOnnxGroup}:${sherpaOnnxArtifact}:${sherpaOnnxVersion}@aar")
+
+  if (!publicMavenSdk) {
+    // Silero VAD — vendored source under silero/, wired as :silero
+    // sub-project (see settings.gradle). This replaces the previous Jitpack AAR
+    // (com.github.gkonovalov:android-vad:2.0.9) whose prebuilt JNI was bound to
+    // an ORT version incompatible with the one bundled by sherpa-onnx, causing a
+    // dlopen UnsatisfiedLinkError for OrtGetApiBase at VAD startup. By owning the
+    // source we control both the Java API surface and the ORT version it links
+    // against; today both consumers (Silero VAD and sherpa-onnx) load their own
+    // libonnxruntime.so — see packagingOptions pickFirst above.
+    implementation project(':silero')
+
+    // Vuzix Z100
+    implementation 'com.vuzix:ultralite-sdk-android:1.8'
+    implementation 'com.squareup.picasso:picasso:2.8'
+  } else {
+    compileOnly project(':silero')
+    compileOnly 'com.vuzix:ultralite-sdk-android:1.8'
+    compileOnly 'com.squareup.picasso:picasso:2.8'
+  }
+
+  implementation 'com.google.protobuf:protobuf-java:4.32.0'
+  implementation 'com.google.protobuf:protobuf-java-util:4.32.0'
+}
+
+// Pin onnxruntime-android to 1.27.0 — the version sherpa-onnx 1.13.4 was built
+// against (its libonnxruntime.so exports OrtGetApiBase@@VERS_1.27.0). Matching
+// this lets the :silero VAD module share a single libonnxruntime.so with
+// sherpa-onnx, resolving the ELF symbol-versioning conflict that crashed VAD
+// startup on previous mismatched versions.
+//
+// This pin MUST be bumped in lockstep with sherpaOnnxVersion above: the bundled
+// ORT moved 1.24.3 -> 1.27.0 across the 1.13.2 -> 1.13.4 upgrade. To re-derive
+// it after a future bump:
+//   unzip -p <aar> jni/arm64-v8a/libonnxruntime.so > /tmp/ort.so
+//   strings /tmp/ort.so | grep -Eo 'VERS_1\.[0-9]+\.[0-9]+' | sort -u
+configurations.all {
+  resolutionStrategy {
+    eachDependency { DependencyResolveDetails details ->
+      if (details.requested.group == 'com.microsoft.onnxruntime') {
+        details.useVersion '1.27.0'
+        details.because('Match sherpa-onnx 1.13.4 ORT 1.27.0')
+      }
+      if (details.requested.name == 'onnxruntime-android') {
+        details.useVersion '1.27.0'
+        details.because('Match sherpa-onnx 1.13.4 ORT 1.27.0')
+      }
+    }
+  }
+}
+
+afterEvaluate {
+  publishing {
+    publications {
+      release(MavenPublication) {
+        groupId = mavenGroupId
+        artifactId = 'bluetooth-sdk'
+        version = project.version
+
+        from components.release
+
+        pom {
+          name = 'Glassly Bluetooth SDK'
+          description = 'SDK for communicating with smart glasses'
+          url = 'https://github.com/tetramo-labs/glassly'
+          licenses {
+            license {
+              name = 'MIT License'
+              url = 'https://opensource.org/licenses/MIT'
+            }
+          }
+          developers {
+            developer {
+              id = 'glassly'
+              name = 'Glassly'
+              email = 'dev@glassly.com'
+            }
+          }
+          scm {
+            connection = 'scm:git:https://github.com/tetramo-labs/glassly.git'
+            developerConnection = 'scm:git:ssh://git@github.com:tetramo-labs/glassly.git'
+            url = 'https://github.com/tetramo-labs/glassly'
+          }
+        }
+      }
+    }
+    repositories {
+      maven {
+        name = 'sonatypeCentral'
+        def repositoryUrl = System.getenv('GLASSLY_MAVEN_STAGING_REPOSITORY_URL') ?: 'https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/'
+        url = uri(repositoryUrl)
+        if (repositoryUrl.startsWith('http')) {
+          credentials {
+            username = centralUsername()
+            password = centralPassword()
+          }
+        }
+      }
+    }
+  }
+
+  signing {
+    def inMemorySigningKey = signingKey()
+    if (inMemorySigningKey) {
+      useInMemoryPgpKeys(inMemorySigningKey, signingPassword())
+    } else if (shouldUseGpgCmd()) {
+      useGpgCmd()
+    }
+    required {
+      isCentralPublishTask()
+    }
+    sign publishing.publications.release
+  }
+}
+
+tasks.withType(Sign).configureEach {
+  onlyIf { isCentralPublishTask() }
+}
+
+tasks.register('uploadSonatypeCentralDeployment') {
+  group = 'publishing'
+  description = "Uploads the ${mavenGroupId} OSSRH compatibility repository to the Central Portal."
+  def releasePublishTaskPath = project.path == ':'
+    ? ':publishReleasePublicationToSonatypeCentralRepository'
+    : "${project.path}:publishReleasePublicationToSonatypeCentralRepository"
+  dependsOn ':lc3Lib:publishReleasePublicationToSonatypeCentralRepository',
+    releasePublishTaskPath
+
+  doLast {
+    def username = centralUsername(true)
+    def password = centralPassword(true)
+    if (!username || !password) {
+      throw new GradleException('Set sonatypeTokenBase64 or sonatypeUsername/sonatypePassword before uploading to Central.')
+    }
+
+    def publishingType = (findProperty('sonatypePublishingType') ?: System.getenv('SONATYPE_PUBLISHING_TYPE') ?: 'user_managed').toString()
+    def endpoint = new URL("https://ossrh-staging-api.central.sonatype.com/manual/upload/defaultRepository/${mavenGroupId}?publishing_type=${publishingType}")
+    def connection = endpoint.openConnection()
+    connection.requestMethod = 'POST'
+    connection.setRequestProperty('Authorization', "Bearer ${"${username}:${password}".bytes.encodeBase64()}")
+    connection.setRequestProperty('Content-Length', '0')
+
+    def statusCode = connection.responseCode
+    def responseBody = statusCode >= 400 ? connection.errorStream?.text : connection.inputStream?.text
+    if (statusCode < 200 || statusCode >= 300) {
+      throw new GradleException("Central deployment upload failed with HTTP ${statusCode}: ${responseBody ?: ''}")
+    }
+
+    println "Sonatype Central deployment upload requested for ${mavenGroupId} (${publishingType})."
+  }
+}

package/android/gradle.properties.example

@@ -0,0 +1,9 @@
+# Copy these values into ~/.gradle/gradle.properties or inject them as CI
+# secrets before running Android Maven publishing tasks. Do not commit real
+# Sonatype tokens, GPG key names, or GPG passphrases.
+sonatypeTokenBase64=...
+sonatypePublishingType=user_managed
+signing.useGpgCmd=true
+signing.gnupg.executable=/opt/homebrew/bin/gpg
+signing.gnupg.keyName=...
+signing.gnupg.passphrase=...

package/android/lc3Lib/CMakeLists.txt

@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 3.22.1)
+
+project("some-name-needed-here")
+
+add_subdirectory(src/main/cpp)
+add_subdirectory(src/main/cpp/jni)

package/android/lc3Lib/build.gradle

@@ -0,0 +1,212 @@
+import groovy.json.JsonSlurper
+
+plugins {
+    id 'com.android.library'
+    id 'maven-publish'
+    id 'signing'
+}
+
+def packageJson = new JsonSlurper().parse(file("../../package.json"))
+def mavenGroupId = 'com.glassly'
+def mavenPublishVersion = (findProperty('glasslyMavenVersion') ?: System.getenv('MAVEN_VERSION') ?: packageJson.version).toString()
+
+group = mavenGroupId
+version = mavenPublishVersion
+
+def credentialValue = { List<String> propertyNames, List<String> envNames ->
+    for (propertyName in propertyNames) {
+        def value = findProperty(propertyName)
+        if (value != null && value.toString().trim()) {
+            return value.toString()
+        }
+    }
+    for (envName in envNames) {
+        def value = System.getenv(envName)
+        if (value != null && value.trim()) {
+            return value
+        }
+    }
+    return null
+}
+
+def centralTokenParts = { boolean failOnInvalid = false ->
+    def token = credentialValue(['sonatypeTokenBase64', 'mavenCentralTokenBase64'], ['SONATYPE_TOKEN_BASE64', 'MAVEN_CENTRAL_TOKEN_BASE64'])
+    if (!token) {
+        return null
+    }
+    def decoded
+    try {
+        decoded = new String(token.decodeBase64(), 'UTF-8')
+    } catch (Exception e) {
+        if (failOnInvalid) {
+            throw new GradleException('Sonatype token must be valid base64 for username:password', e)
+        }
+        return null
+    }
+    def separator = decoded.indexOf(':')
+    if (separator <= 0) {
+        if (failOnInvalid) {
+            throw new GradleException('Sonatype token must decode to username:password')
+        }
+        return null
+    }
+    return [decoded.substring(0, separator), decoded.substring(separator + 1)]
+}
+
+def centralUsername = { boolean failOnInvalidToken = false ->
+    credentialValue(['sonatypeUsername', 'mavenCentralUsername'], ['SONATYPE_USERNAME', 'MAVEN_CENTRAL_USERNAME']) ?: centralTokenParts(failOnInvalidToken)?.get(0)
+}
+
+def centralPassword = { boolean failOnInvalidToken = false ->
+    credentialValue(['sonatypePassword', 'mavenCentralPassword'], ['SONATYPE_PASSWORD', 'MAVEN_CENTRAL_PASSWORD']) ?: centralTokenParts(failOnInvalidToken)?.get(1)
+}
+
+def signingKey = {
+    credentialValue(['signingKey'], ['SIGNING_KEY'])
+}
+
+def signingPassword = {
+    credentialValue(['signingPassword'], ['SIGNING_PASSWORD'])
+}
+
+def shouldUseGpgCmd = {
+    (credentialValue(['signing.useGpgCmd'], ['SIGNING_USE_GPG_CMD']) ?: 'false').toBoolean()
+}
+
+def isCentralPublishTask = {
+    gradle.taskGraph.allTasks.any { it.name.toLowerCase().contains('sonatypecentral') }
+}
+
+gradle.taskGraph.whenReady {
+    if (isCentralPublishTask()) {
+        centralUsername(true)
+        centralPassword(true)
+    }
+}
+
+android {
+    namespace "com.glassly.lc3Lib"
+    compileSdk 33
+
+    publishing {
+        singleVariant("release") {
+            withSourcesJar()
+            withJavadocJar()
+        }
+    }
+
+    packagingOptions {
+        exclude 'META-INF/proguard/androidx-annotations.pro'
+        resources {
+            excludes += '/META-INF/{AL2.0,LGPL2.1,DEPENDENCIES}'
+            excludes += '/META-INF/INDEX.LIST'
+        }
+    }
+
+    defaultConfig {
+        minSdk 28
+        targetSdk 32
+        versionCode 3
+        versionName "0.1"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+
+        ndk {
+            // Honor reactNativeArchitectures so CI/staging ABI filters apply.
+            // Without this, CMake still builds every ABI on an arm64-only job.
+            def abiList = (findProperty("reactNativeArchitectures") ?: "armeabi-v7a,arm64-v8a,x86,x86_64")
+                .toString()
+                .split(",")
+                .collect { it.trim() }
+                .findAll { !it.isEmpty() }
+            abiFilters(*abiList)
+        }
+
+        externalNativeBuild {
+            cmake {
+                arguments '-DCMAKE_OBJECT_PATH_MAX=600', '-DANDROID_STL=c++_static'
+            }
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path file('src/main/cpp/liblc3/CMakeLists.txt')
+            version '3.22.1'
+        }
+    }
+
+}
+
+dependencies {
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
+}
+
+afterEvaluate {
+    publishing {
+        publications {
+            release(MavenPublication) {
+                groupId = mavenGroupId
+                artifactId = 'lc3Lib'
+                version = project.version
+
+                from components.release
+
+                pom {
+                    name = 'Glassly LC3 Android Library'
+                    description = 'LC3 audio codec support for Glassly Bluetooth SDK'
+                    url = 'https://github.com/tetramo-labs/glassly'
+                    licenses {
+                        license {
+                            name = 'MIT License'
+                            url = 'https://opensource.org/licenses/MIT'
+                        }
+                    }
+                    developers {
+                        developer {
+                            id = 'glassly'
+                            name = 'Glassly'
+                            email = 'dev@glassly.com'
+                        }
+                    }
+                    scm {
+                        connection = 'scm:git:https://github.com/tetramo-labs/glassly.git'
+                        developerConnection = 'scm:git:ssh://git@github.com:tetramo-labs/glassly.git'
+                        url = 'https://github.com/tetramo-labs/glassly'
+                    }
+                }
+            }
+        }
+        repositories {
+            maven {
+                name = 'sonatypeCentral'
+                def repositoryUrl = System.getenv('GLASSLY_MAVEN_STAGING_REPOSITORY_URL') ?: 'https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/'
+                url = uri(repositoryUrl)
+                if (repositoryUrl.startsWith('http')) {
+                    credentials {
+                        username = centralUsername()
+                        password = centralPassword()
+                    }
+                }
+            }
+        }
+    }
+
+    signing {
+        def inMemorySigningKey = signingKey()
+        if (inMemorySigningKey) {
+            useInMemoryPgpKeys(inMemorySigningKey, signingPassword())
+        } else if (shouldUseGpgCmd()) {
+            useGpgCmd()
+        }
+        required {
+            isCentralPublishTask()
+        }
+        sign publishing.publications.release
+    }
+}
+
+tasks.withType(Sign).configureEach {
+    onlyIf { isCentralPublishTask() }
+}