@mentra/bluetooth-sdk 0.1.8 → 0.1.10

package/android/lc3Lib/build.gradle

@@ -7,12 +7,81 @@ plugins {
 }
 
 def packageJson = new JsonSlurper().parse(file("../../package.json"))
+def mavenGroupId = 'com.mentraglass'
+def mavenPublishVersion = (findProperty('mentraMavenVersion') ?: System.getenv('MENTRA_MAVEN_VERSION') ?: packageJson.version).toString()
 
-group = 'com.mentra'
-version = packageJson.version
+group = mavenGroupId
+version = mavenPublishVersion
 
-def isPublishTask = {
-    gradle.taskGraph.allTasks.any { it.name.toLowerCase().contains("publish") }
+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 {
@@ -67,7 +136,7 @@ afterEvaluate {
     publishing {
         publications {
             release(MavenPublication) {
-                groupId = 'com.mentra'
+                groupId = mavenGroupId
                 artifactId = 'lc3Lib'
                 version = project.version
 
@@ -98,12 +167,32 @@ afterEvaluate {
                 }
             }
         }
+        repositories {
+            maven {
+                name = 'sonatypeCentral'
+                url = uri('https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/')
+                credentials {
+                    username = centralUsername()
+                    password = centralPassword()
+                }
+            }
+        }
     }
 
     signing {
+        def inMemorySigningKey = signingKey()
+        if (inMemorySigningKey) {
+            useInMemoryPgpKeys(inMemorySigningKey, signingPassword())
+        } else if (shouldUseGpgCmd()) {
+            useGpgCmd()
+        }
         required {
-            isPublishTask() && (findProperty("signing.keyId") || findProperty("signingKey"))
+            isCentralPublishTask()
         }
         sign publishing.publications.release
     }
 }
+
+tasks.withType(Sign).configureEach {
+    onlyIf { isCentralPublishTask() }
+}

package/android/settings.gradle

@@ -1 +1,4 @@
 include ':lc3Lib'
+
+include ':silero'
+project(':silero').projectDir = new File(rootDir, 'silero')

package/android/silero/LICENSE.md

@@ -0,0 +1,17 @@
+Copyright 2023 Georgiy Konovalov
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 
+associated documentation files (the "Software"), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial 
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT 
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/android/silero/build.gradle

@@ -0,0 +1,42 @@
+// Vendored from https://github.com/gkonovalov/android-vad (silero module, v2.0.10)
+// Consumed in-place by the bluetooth-sdk so we can pin ORT to a version that
+// matches our other ORT consumer (sherpa-onnx) without depending on a Jitpack
+// AAR whose prebuilt JNI was built against a different ORT.
+plugins {
+    id 'com.android.library'
+    id 'kotlin-android'
+}
+
+android {
+    namespace "com.konovalov.vad.silero"
+    compileSdk 36
+
+    defaultConfig {
+        minSdkVersion 24
+        targetSdkVersion 36
+
+        ndk {
+            abiFilters "armeabi-v7a", "x86", "x86_64", "arm64-v8a"
+        }
+    }
+
+    aaptOptions {
+        noCompress "onnx"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+}
+
+dependencies {
+    // 1.24.3 matches the ORT version sherpa-onnx 1.13.2 was built against, so
+    // both consumers can share a single libonnxruntime.so (same versioned
+    // OrtGetApiBase@@VERS_1.24.3 symbol). Keep these versions in lockstep.
+    implementation 'com.microsoft.onnxruntime:onnxruntime-android:1.24.3'
+}

package/android/silero/proguard-rules.pro

@@ -0,0 +1,24 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
+-keep class ai.onnxruntime.** {*;}
+-keep class com.konovalov.vad.** {*;}
+-dontwarn com.google.**

package/android/silero/src/androidTest/java/com/konovalov/vad/silero/VadSileroTest.kt

@@ -0,0 +1,79 @@
+package com.konovalov.silero
+
+import android.content.Context
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.konovalov.vad.silero.Vad
+import com.konovalov.vad.silero.VadSilero
+import com.konovalov.vad.silero.config.FrameSize
+import com.konovalov.vad.silero.config.Mode
+import com.konovalov.vad.silero.config.SampleRate
+import junit.framework.TestCase.assertEquals
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+
+/**
+ * Created by Georgiy Konovalov on 12/22/2023.
+ *
+ * Instrumented test for VadSilero class.
+ */
+@RunWith(AndroidJUnit4::class)
+class VadSileroTest {
+
+    private lateinit var vad: VadSilero
+    private lateinit var testContext: Context
+
+    @Before
+    fun setUp() {
+        this.testContext = InstrumentationRegistry.getInstrumentation().context
+
+        this.vad = Vad.builder()
+            .setContext(testContext)
+            .setSampleRate(SampleRate.SAMPLE_RATE_16K)
+            .setFrameSize(FrameSize.FRAME_SIZE_512)
+            .setMode(Mode.VERY_AGGRESSIVE)
+            .build()
+    }
+
+    @After
+    fun shutdown() {
+        vad.close()
+    }
+
+    @Test
+    fun testIsSpeech() {
+        // List for VAD results
+        val actualResult = mutableListOf<Boolean>()
+
+        // List with expected VAD results
+        val expectedResult = listOf(
+            false, false, false, false, false,
+            false, true, true, true, true,
+            true, true, true, true, true,
+            true, true, true, false, false
+        )
+
+        // Buffer size should be 2x for ByteArray
+        val chunkSize = vad.frameSize.value * 2
+
+        // Reading audio data from test file
+        testContext.assets.open("hello.wav").buffered().use { input ->
+            // Skip WAV Header
+            input.skip(44)
+
+            while (input.available() > 0) {
+                // Read audio Frame
+                val frameChunk = ByteArray(chunkSize).apply { input.read(this) }
+
+                // Save interference result
+                actualResult.add(vad.isSpeech(frameChunk))
+            }
+        }
+
+        // Compare expectedResult with actualResult
+        assertEquals(expectedResult, actualResult)
+    }
+}

package/android/silero/src/main/assets/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present Silero Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/android/silero/src/main/java/com/konovalov/vad/silero/Vad.kt

@@ -0,0 +1,160 @@
+package com.konovalov.vad.silero
+
+import android.content.Context
+import com.konovalov.vad.silero.config.FrameSize
+import com.konovalov.vad.silero.config.Mode
+import com.konovalov.vad.silero.config.SampleRate
+
+/**
+ * Created by Georgiy Konovalov on 6/26/2023.
+ *
+ * The Silero VAD algorithm, based on DNN, analyzes the audio signal to determine whether it
+ * contains speech or non-speech segments. It offers higher accuracy in differentiating speech from
+ * background noise compared to the WebRTC VAD algorithm.
+ *
+ * The Silero VAD supports the following parameters:
+ *
+ * Sample Rates:
+ *
+ *      8000Hz,
+ *      16000Hz
+ *
+ * Frame Sizes (per sample rate):
+ *
+ *    For 8000Hz: 80, 160, 240
+ *    For 16000Hz: 160, 320, 480
+ *
+ * Mode:
+ *
+ *    NORMAL,
+ *    LOW_BITRATE,
+ *    AGGRESSIVE,
+ *    VERY_AGGRESSIVE
+ *
+ * Please note that the VAD class supports these specific combinations of sample
+ * rates and frame sizes, and the classifiers determine the aggressiveness of the voice
+ * activity detection algorithm.
+ *
+ * @param context           is required for reading the model file from file system.
+ * @param sampleRate        is required for processing audio input.
+ * @param frameSize         is required for processing audio input.
+ * @param mode              is required for the VAD model.
+ * @param speechDurationMs  is minimum duration in milliseconds for speech segments (optional).
+ * @param silenceDurationMs is minimum duration in milliseconds for silence segments (optional).
+ */
+class Vad private constructor() {
+    private lateinit var context: Context
+    private lateinit var sampleRate: SampleRate
+    private lateinit var frameSize: FrameSize
+    private lateinit var mode: Mode
+    private var speechDurationMs = 0
+    private var silenceDurationMs = 0
+
+    /**
+     * Set Context for Vad Model.
+     *
+     * @param context is required for accessing the model file.
+     */
+    fun setContext(context: Context): Vad = apply {
+        this.context = context.applicationContext ?: context
+    }
+
+    /**
+     * Set, retrieve and validate sample rate for Vad Model.
+     *
+     * Valid Sample Rates:
+     *
+     *      8000Hz,
+     *      16000Hz
+     *
+     * @param sampleRate is required for processing audio input.
+     */
+    fun setSampleRate(sampleRate: SampleRate): Vad = apply {
+        this.sampleRate = sampleRate
+    }
+
+    /**
+     * Set, retrieve and validate frame size for Vad Model.
+     *
+     * Valid Frame Sizes (per sample rate):
+     *
+     *             For 8000Hz: 256, 512, 768
+     *             For 16000Hz: 512, 1024, 1536
+     *
+     * @param frameSize is required for processing audio input.
+     */
+    fun setFrameSize(frameSize: FrameSize): Vad = apply {
+        this.frameSize = frameSize
+    }
+
+    /**
+     * Set and retrieve detection mode for Vad model.
+     *
+     * Mode:
+     *
+     *    NORMAL,
+     *    LOW_BITRATE,
+     *    AGGRESSIVE,
+     *    VERY_AGGRESSIVE
+     *
+     * @param mode is required for the VAD model.
+     */
+    fun setMode(mode: Mode): Vad = apply {
+        this.mode = mode
+    }
+
+    /**
+     * Set the minimum duration in milliseconds for speech segments.
+     * The value of this parameter will define the necessary and sufficient duration of positive
+     * results to recognize result as speech. This parameter is optional.
+     *
+     * Permitted range (0ms >= speechDurationMs <= 300000ms).
+     *
+     * Parameters used for {@link VadSilero.isSpeech}.
+     *
+     * @param speechDurationMs minimum duration in milliseconds for speech segments.
+     */
+    fun setSpeechDurationMs(speechDurationMs: Int): Vad = apply {
+        this.speechDurationMs = speechDurationMs
+    }
+
+    /**
+     * Set the minimum duration in milliseconds for silence segments.
+     * The value of this parameter will define the necessary and sufficient duration of
+     * negative results to recognize it as silence. This parameter is optional.
+     *
+     * Permitted range (0ms >= silenceDurationMs <= 300000ms).
+     *
+     * Parameters used in {@link VadSilero.isSpeech}.
+     *
+     * @param silenceDurationMs minimum duration in milliseconds for silence segments.
+     */
+    fun setSilenceDurationMs(silenceDurationMs: Int): Vad = apply {
+        this.silenceDurationMs = silenceDurationMs
+    }
+
+    /**
+     * Builds and returns a VadModel instance based on the specified parameters.
+     *
+     * @return constructed VadSilero model.
+     * @throws IllegalArgumentException if invalid parameters have been set for the model.
+     * @throws OrtException if the model failed to parse, wasn't compatible or caused an error.
+     */
+    fun build(): VadSilero {
+        return VadSilero(
+            context,
+            sampleRate,
+            frameSize,
+            mode,
+            speechDurationMs,
+            silenceDurationMs
+        )
+    }
+
+    companion object {
+        @JvmStatic
+        fun builder(): Vad {
+            return Vad()
+        }
+    }
+}