@mentra/bluetooth-sdk 0.1.0

package/android/src/main/java/com/mentra/bluetoothsdk/utils/AES.java

@@ -0,0 +1,106 @@
+package com.mentra.bluetoothsdk.utils;
+
+import android.util.Base64;
+
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+
+import javax.crypto.Cipher;
+import javax.crypto.spec.SecretKeySpec;
+
+import android.util.Log;
+
+public class AES {
+    private static final String TAG = "WearableIntelligenceSystem_AES";
+
+    private static SecretKeySpec secretKey;
+    private static byte[] key;
+
+    public static void setKey(String myKey)
+    {
+        MessageDigest sha = null;
+        try {
+            key = myKey.getBytes("UTF-8");
+            sha = MessageDigest.getInstance("SHA-1");
+            key = sha.digest(key);
+            key = Arrays.copyOf(key, 16);
+            secretKey = new SecretKeySpec(key, "AES");
+        }
+        catch (NoSuchAlgorithmException e) {
+            e.printStackTrace();
+        }
+        catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static String encrypt(String strToEncrypt, String secret)
+    {
+        try
+        {
+            setKey(secret);
+            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
+            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
+            return Base64.encodeToString(cipher.doFinal(strToEncrypt.getBytes("UTF-8")), Base64.DEFAULT);
+        }
+        catch (Exception e)
+        {
+            Log.d(TAG, "Error while encrypting: " + e.toString());
+        }
+        return null;
+    }
+
+    //bytes version
+    public static byte [] encrypt(byte [ ] bytesToEncrypt, String secret)
+    {
+        try
+        {
+            setKey(secret);
+            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
+            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
+            return cipher.doFinal(bytesToEncrypt);
+        }
+        catch (Exception e)
+        {
+            Log.d(TAG, "Error while encrypting: " + e.toString());
+        }
+        return null;
+    }
+
+    //String version
+    public static String decrypt(String strToDecrypt, String secret)
+    {
+        try
+        {
+            Log.d(TAG, "Secret key is: " + secret);
+            setKey(secret);
+            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7PADDING");
+            cipher.init(Cipher.DECRYPT_MODE, secretKey);
+            return new String(cipher.doFinal(Base64.decode(strToDecrypt, Base64.DEFAULT)));
+        }
+        catch (Exception e)
+        {
+            Log.d(TAG, "Error while decrypting: " + e.toString());
+        }
+        return null;
+    }
+
+    //bytes version
+    public static byte [] decrypt(byte [] bytesToDecrypt, String secret)
+    {
+        try
+        {
+            setKey(secret);
+            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7PADDING");
+            cipher.init(Cipher.DECRYPT_MODE, secretKey);
+            return cipher.doFinal(bytesToDecrypt);
+        }
+        catch (Exception e)
+        {
+            Log.d(TAG, "Error while decrypting: " + e.toString());
+        }
+        return null;
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/utils/AudioSessionMonitor.kt

@@ -0,0 +1,189 @@
+package com.mentra.bluetoothsdk.utils
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.media.AudioManager
+import com.mentra.bluetoothsdk.Bridge
+
+/**
+ * Android AudioSessionMonitor - maintains API parity with iOS implementation
+ *
+ * On Android, CTKD automatically handles BT Classic bonding including audio.
+ * This class provides a consistent API surface across platforms while being
+ * simpler than the iOS version since Android handles most of this automatically.
+ */
+class AudioSessionMonitor private constructor(private val context: Context) {
+
+    companion object {
+        @Volatile
+        private var instance: AudioSessionMonitor? = null
+
+        fun getInstance(context: Context): AudioSessionMonitor {
+            return instance ?: synchronized(this) {
+                instance ?: AudioSessionMonitor(context.applicationContext).also {
+                    instance = it
+                }
+            }
+        }
+    }
+
+    private val audioManager: AudioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    private var isMonitoring = false
+    private var devicePattern: String? = null
+    private var callback: ((Boolean, String?) -> Unit)? = null
+
+    private val audioDeviceReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            when (intent?.action) {
+                AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED -> {
+                    val state = intent.getIntExtra(AudioManager.EXTRA_SCO_AUDIO_STATE, -1)
+                    handleScoStateChange(state)
+                }
+                BluetoothDevice.ACTION_ACL_CONNECTED -> {
+                    val device: BluetoothDevice? = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
+                    device?.let { handleDeviceConnected(it) }
+                }
+                BluetoothDevice.ACTION_ACL_DISCONNECTED -> {
+                    val device: BluetoothDevice? = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
+                    device?.let { handleDeviceDisconnected(it) }
+                }
+            }
+        }
+    }
+
+    /**
+     * Configure audio session for Bluetooth
+     * On Android, this is largely handled by the system, so this is mostly a no-op
+     * Returns true for API consistency with iOS
+     */
+    fun configureAudioSession(): Boolean {
+        Bridge.log("AudioMonitor: Audio session configured (Android auto-handles)")
+        return true
+    }
+
+    /**
+     * Check if a Bluetooth audio device matching the pattern is connected
+     * On Android, we check if SCO (Synchronous Connection-Oriented) audio is active
+     */
+    fun isAudioDeviceConnected(devicePattern: String): Boolean {
+        val isBluetoothA2dpOn = audioManager.isBluetoothA2dpOn
+        val isBluetoothScoOn = audioManager.isBluetoothScoOn
+
+        if (isBluetoothA2dpOn || isBluetoothScoOn) {
+            // Check if any connected device matches pattern
+            val adapter = BluetoothAdapter.getDefaultAdapter()
+            adapter?.bondedDevices?.forEach { device ->
+                if (device.name?.contains(devicePattern, ignoreCase = true) == true) {
+                    Bridge.log("AudioMonitor: Found active audio device: ${device.name}")
+                    return true
+                }
+            }
+        }
+
+        Bridge.log("AudioMonitor: No active audio device matching '$devicePattern'")
+        return false
+    }
+
+    /**
+     * Set Bluetooth device as preferred audio device
+     * On Android, this is handled automatically by CTKD bonding
+     * This method is a no-op for API parity with iOS
+     * Returns true if device is bonded (meaning audio will be available)
+     */
+    fun setAsPreferredAudioOutputDevice(devicePattern: String): Boolean {
+        val adapter = BluetoothAdapter.getDefaultAdapter() ?: return false
+
+        adapter.bondedDevices?.forEach { device ->
+            if (device.name?.contains(devicePattern, ignoreCase = true) == true) {
+                Bridge.log("AudioMonitor: Device '$devicePattern' is bonded, audio routing handled by system")
+                return true
+            }
+        }
+
+        Bridge.log("AudioMonitor: Device '$devicePattern' not bonded")
+        return false
+    }
+
+    /**
+     * Start monitoring for audio device connections/disconnections
+     */
+    fun startMonitoring(devicePattern: String, callback: (Boolean, String?) -> Unit) {
+        if (isMonitoring) {
+            Bridge.log("AudioMonitor: Already monitoring")
+            return
+        }
+
+        this.devicePattern = devicePattern
+        this.callback = callback
+
+        val filter = IntentFilter().apply {
+            addAction(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED)
+            addAction(BluetoothDevice.ACTION_ACL_CONNECTED)
+            addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED)
+        }
+
+        context.registerReceiver(audioDeviceReceiver, filter)
+        isMonitoring = true
+        Bridge.log("AudioMonitor: Started monitoring for '$devicePattern'")
+    }
+
+    /**
+     * Stop monitoring for audio device changes
+     */
+    fun stopMonitoring() {
+        if (!isMonitoring) {
+            Bridge.log("AudioMonitor: Not currently monitoring")
+            return
+        }
+
+        try {
+            context.unregisterReceiver(audioDeviceReceiver)
+        } catch (e: IllegalArgumentException) {
+            Bridge.log("AudioMonitor: Receiver was not registered")
+        }
+
+        isMonitoring = false
+        devicePattern = null
+        callback = null
+        Bridge.log("AudioMonitor: Stopped monitoring")
+    }
+
+    private fun handleScoStateChange(state: Int) {
+        val pattern = devicePattern ?: return
+
+        when (state) {
+            AudioManager.SCO_AUDIO_STATE_CONNECTED -> {
+                Bridge.log("AudioMonitor: SCO audio connected")
+                if (isAudioDeviceConnected(pattern)) {
+                    callback?.invoke(true, pattern)
+                }
+            }
+            AudioManager.SCO_AUDIO_STATE_DISCONNECTED -> {
+                Bridge.log("AudioMonitor: SCO audio disconnected")
+                callback?.invoke(false, null)
+            }
+        }
+    }
+
+    private fun handleDeviceConnected(device: BluetoothDevice) {
+        val pattern = devicePattern ?: return
+
+        if (device.name?.contains(pattern, ignoreCase = true) == true) {
+            Bridge.log("AudioMonitor: Device '${device.name}' connected")
+            callback?.invoke(true, device.name)
+        }
+    }
+
+    private fun handleDeviceDisconnected(device: BluetoothDevice) {
+        val pattern = devicePattern ?: return
+
+        if (device.name?.contains(pattern, ignoreCase = true) == true) {
+            Bridge.log("AudioMonitor: Device '${device.name}' disconnected")
+            callback?.invoke(false, null)
+        }
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/utils/BitmapJavaUtils.java

@@ -0,0 +1,169 @@
+package com.mentra.bluetoothsdk.utils;
+
+import java.io.File;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.util.Log;
+import android.graphics.Bitmap;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+public class BitmapJavaUtils {
+    private static final String TAG = "WearableAi_BitmapJavaUtils";
+
+    public static Bitmap loadImageFromStorage(String path){
+        File imgFile = new  File(path);
+        if(imgFile.exists()){
+            Bitmap myBitmap = BitmapFactory.decodeFile(imgFile.getAbsolutePath());
+            return myBitmap;
+        } else {
+            Log.d(TAG, "Image doesn't exist");
+            return null;
+        }
+    }
+
+    /**
+     * Converts a standard Android ARGB Bitmap into a 1-bit-per-pixel (monochrome) BMP file in memory.
+     *
+     * <p>This method:
+     * <ul>
+     *   <li>Thresholds each pixel to black or white (simple average-based threshold).
+     *   <li>Packs the bits: leftmost pixel in the most significant bit.
+     *   <li>Writes a BITMAPFILEHEADER + BITMAPINFOHEADER + 2-entry palette + raw 1-bpp data.
+     * </ul>
+     *
+     * @param bitmap the Android Bitmap to convert. Its alpha channel is ignored.
+     * @param invert if {@code false}, bits of 0 map to white, bits of 1 map to black;
+     *               if {@code true}, the palette is reversed so 0 maps to black, 1 to white.
+     * @return A byte[] containing a valid 1-bpp BMP file.
+     * @throws IOException if an I/O error occurs writing to the buffer (unlikely in memory).
+     */
+    public static byte[] convertBitmapTo1BitBmpBytes(Bitmap bitmap, boolean invert) throws IOException {
+        int width = bitmap.getWidth();
+        int height = bitmap.getHeight();
+
+        // Each row is padded to a multiple of 4 bytes (32 bits).
+        int rowSizeBytes = ((width + 31) / 32) * 4;
+        int imageSize = rowSizeBytes * height;
+
+        // BMP header sizes for 1-bpp:
+        //  - File header: 14 bytes
+        //  - DIB header (BITMAPINFOHEADER): 40 bytes
+        //  - Color table: 2 entries × 4 bytes each = 8 bytes
+        // => Pixel data offset = 14 + 40 + 8 = 62
+        int dataOffset = 62;
+        int fileSize = dataOffset + imageSize;
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream(fileSize);
+
+        // ================== BMP FILE HEADER (14 bytes) ==================
+        // Signature: "BM"
+        baos.write('B');
+        baos.write('M');
+        // File size (4 bytes, LE)
+        writeIntLE(baos, fileSize);
+        // Reserved (4 bytes)
+        writeShortLE(baos, 0);
+        writeShortLE(baos, 0);
+        // Offset to pixel data
+        writeIntLE(baos, dataOffset);
+
+        // ================== DIB HEADER: BITMAPINFOHEADER (40 bytes) ==================
+        writeIntLE(baos, 40);        // DIB header size
+        writeIntLE(baos, width);     // Width
+        writeIntLE(baos, height);    // Height (positive => bottom-to-top)
+        writeShortLE(baos, 1);       // Planes = 1
+        writeShortLE(baos, 1);       // Bits per pixel = 1
+        writeIntLE(baos, 0);         // Compression = BI_RGB (uncompressed)
+        writeIntLE(baos, imageSize); // Image size
+        writeIntLE(baos, 2835);      // X pixels per meter (72 DPI)
+        writeIntLE(baos, 2835);      // Y pixels per meter (72 DPI)
+        writeIntLE(baos, 2);         // # of colors in palette
+        writeIntLE(baos, 0);         // # of important colors
+
+        // ================== COLOR TABLE (8 bytes: 2 entries × 4 bytes each) ==================
+        // Each color entry: (Blue, Green, Red, Reserved)
+        // If invert=false, then 0 => White, 1 => Black. Otherwise, 0 => Black, 1 => White.
+        if (!invert) {
+            // color index 0 => white
+            baos.write(0xFF); baos.write(0xFF); baos.write(0xFF); baos.write(0x00);
+            // color index 1 => black
+            baos.write(0x00); baos.write(0x00); baos.write(0x00); baos.write(0x00);
+        } else {
+            // color index 0 => black
+            baos.write(0x00); baos.write(0x00); baos.write(0x00); baos.write(0x00);
+            // color index 1 => white
+            baos.write(0xFF); baos.write(0xFF); baos.write(0xFF); baos.write(0x00);
+        }
+
+        // ================== PIXEL DATA (1-bpp, bottom-to-top) ==================
+        // We'll iterate from top row to bottom row in the Android sense,
+        // but actually output from bottom row to top row in BMP format.
+        int[] rowPixels = new int[width];
+
+        for (int y = 0; y < height; y++) {
+            int py = height - 1 - y; // "py" is the actual row index in the source
+            bitmap.getPixels(rowPixels, 0, width, 0, py, width, 1);
+
+            byte[] packedRow = new byte[rowSizeBytes];
+            int bitIndex = 0;   // which bit within the current byte [0..7]
+            int byteIndex = 0;  // which byte in packedRow
+
+            for (int x = 0; x < width; x++) {
+                int color = rowPixels[x];
+                int r = (color >> 16) & 0xFF;
+                int g = (color >> 8) & 0xFF;
+                int b = (color) & 0xFF;
+
+                // Simple threshold (tweak if you want better dithering)
+                int gray = (r + g + b) / 3;
+                // int pixelVal = (gray < 128) ? 1 : 0; // 0=white or 1=black depending on palette
+                int pixelVal = 0;
+                if (!invert) {
+                    pixelVal = (gray < 128) ? 1 : 0; // Dark → 1 (black), Light → 0 (white)
+                } else {
+                    pixelVal = (gray < 128) ? 0 : 1; // Dark → 0 (black), Light → 1 (white)
+                }
+
+                // The leftmost pixel goes in the MSB of the byte => bit position = 7 - bitIndex
+                packedRow[byteIndex] |= (pixelVal << (7 - bitIndex));
+
+                bitIndex++;
+                if (bitIndex == 8) {
+                    bitIndex = 0;
+                    byteIndex++;
+                }
+            }
+
+            baos.write(packedRow, 0, rowSizeBytes);
+        }
+
+        return baos.toByteArray();
+    }
+
+    /**
+     * Writes an integer as 4 little-endian bytes.
+     */
+    private static void writeIntLE(OutputStream out, int value) throws IOException {
+        out.write(value & 0xFF);
+        out.write((value >> 8) & 0xFF);
+        out.write((value >> 16) & 0xFF);
+        out.write((value >> 24) & 0xFF);
+    }
+
+    /**
+     * Writes a short as 2 little-endian bytes.
+     */
+    private static void writeShortLE(OutputStream out, int value) throws IOException {
+        out.write(value & 0xFF);
+        out.write((value >> 8) & 0xFF);
+    }
+
+    public static Bitmap bytesToBitmap(byte[] imageData) {
+        if (imageData == null || imageData.length == 0) {
+            return null;
+        }
+        return BitmapFactory.decodeByteArray(imageData, 0, imageData.length);
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/utils/BlePhotoUploadService.java

@@ -0,0 +1,179 @@
+package com.mentra.bluetoothsdk.utils;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+import okhttp3.MediaType;
+import okhttp3.MultipartBody;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+
+/**
+ * Service to handle BLE photo uploads including AVIF decoding and webhook posting
+ */
+public class BlePhotoUploadService {
+    private static final String TAG = "BlePhotoUploadService";
+
+    public interface UploadCallback {
+        void onSuccess(String requestId);
+        void onError(String requestId, String error);
+    }
+
+    /**
+     * Process image data and upload to webhook
+     * @param imageData Raw image data (AVIF or JPEG)
+     * @param requestId Original request ID for tracking
+     * @param webhookUrl Destination webhook URL
+     * @param authToken Optional authentication token for upload
+     * @param callback Callback for success/error
+     */
+    public static void processAndUploadPhoto(byte[] imageData, String requestId,
+                                            String webhookUrl, @Nullable String authToken,
+                                            UploadCallback callback) {
+        new Thread(() -> {
+            try {
+                Log.d(TAG, "Processing BLE photo for upload. Image size: " + imageData.length + " bytes");
+
+                // 1. Decode image (AVIF or JPEG) to Bitmap
+                Bitmap bitmap = decodeImage(imageData);
+                if (bitmap == null) {
+                    throw new Exception("Failed to decode image data");
+                }
+
+                Log.d(TAG, "Decoded image to bitmap: " + bitmap.getWidth() + "x" + bitmap.getHeight());
+
+                // 2. Convert to JPEG for upload (in case it was AVIF)
+                ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                bitmap.compress(Bitmap.CompressFormat.JPEG, 90, baos);
+                byte[] jpegData = baos.toByteArray();
+                bitmap.recycle();
+
+                Log.d(TAG, "Converted to JPEG for upload. Size: " + jpegData.length + " bytes");
+
+                // 3. Upload to webhook
+                uploadToWebhook(jpegData, requestId, webhookUrl, authToken);
+
+                Log.d(TAG, "Photo uploaded successfully for requestId: " + requestId);
+                callback.onSuccess(requestId);
+
+            } catch (Exception e) {
+                Log.e(TAG, "Error processing BLE photo for requestId: " + requestId, e);
+                callback.onError(requestId, e.getMessage());
+            }
+        }).start();
+    }
+
+    /**
+     * Decode image data (AVIF or JPEG) to Bitmap
+     * @param imageData Raw image bytes
+     * @return Decoded bitmap or null if failed
+     */
+    private static Bitmap decodeImage(byte[] imageData) {
+        try {
+            // Check if this is AVIF by looking for "ftyp" box
+            boolean isAvif = imageData.length > 12 &&
+                           imageData[4] == 'f' && imageData[5] == 't' &&
+                           imageData[6] == 'y' && imageData[7] == 'p' &&
+                           (imageData[8] == 'a' && imageData[9] == 'v' && imageData[10] == 'i' && imageData[11] == 'f');
+
+            if (isAvif) {
+                Log.d(TAG, "Detected AVIF image format");
+                // AVIF decoding - requires Android API 31+ for native support
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    // Android 12+ has native AVIF support
+                    BitmapFactory.Options options = new BitmapFactory.Options();
+                    options.inPreferredConfig = Bitmap.Config.ARGB_8888;
+                    return BitmapFactory.decodeByteArray(imageData, 0, imageData.length, options);
+                } else {
+                    // For older Android versions, we could add a library or convert on glasses side
+                    Log.e(TAG, "AVIF decoding requires Android 12+ (API 31+). Current API: " + Build.VERSION.SDK_INT);
+                    throw new UnsupportedOperationException("AVIF not supported on Android " + Build.VERSION.SDK_INT);
+                }
+            } else {
+                Log.d(TAG, "Detected JPEG image format");
+                // Standard JPEG decoding
+                return BitmapFactory.decodeByteArray(imageData, 0, imageData.length);
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to decode image", e);
+            return null;
+        }
+    }
+
+    /**
+     * Upload JPEG data to webhook
+     * @param jpegData JPEG image bytes
+     * @param requestId Request ID for tracking
+     * @param webhookUrl Destination URL
+     * @param authToken Optional bearer token for auth
+     * @throws IOException If upload fails
+     */
+    private static void uploadToWebhook(byte[] jpegData, String requestId,
+                                       String webhookUrl, @Nullable String authToken) throws IOException {
+        OkHttpClient client = new OkHttpClient.Builder()
+            .connectTimeout(30, TimeUnit.SECONDS)
+            .writeTimeout(30, TimeUnit.SECONDS)
+            .readTimeout(30, TimeUnit.SECONDS)
+            .build();
+
+        // Build multipart request
+        RequestBody requestBody = new MultipartBody.Builder()
+            .setType(MultipartBody.FORM)
+            .addFormDataPart("requestId", requestId)
+            .addFormDataPart("source", "ble_transfer")
+            .addFormDataPart("photo", requestId + ".jpg",
+                RequestBody.create(MediaType.parse("image/jpeg"), jpegData))
+            .build();
+
+        // Build request with auth header
+        Request.Builder requestBuilder = new Request.Builder()
+            .url(webhookUrl)
+            .post(requestBody);
+
+        if (authToken != null && !authToken.isEmpty()) {
+            requestBuilder.addHeader("Authorization", "Bearer " + authToken);
+        }
+
+        Request request = requestBuilder.build();
+
+        Log.d(TAG, "Uploading photo to webhook: " + webhookUrl);
+
+        try (Response response = client.newCall(request).execute()) {
+            if (!response.isSuccessful()) {
+                String errorBody = response.body() != null ? response.body().string() : "No response body";
+                throw new IOException("Upload failed with code " + response.code() + ": " + errorBody);
+            }
+
+            Log.d(TAG, "Upload successful. Response code: " + response.code());
+        }
+    }
+
+    /**
+     * Alternative method for platforms without AVIF support
+     * Expects already-decoded JPEG data instead of AVIF
+     */
+    public static void uploadJpegPhoto(byte[] jpegData, String requestId,
+                                      String webhookUrl, @Nullable String authToken,
+                                      UploadCallback callback) {
+        new Thread(() -> {
+            try {
+                Log.d(TAG, "Uploading pre-decoded JPEG. Size: " + jpegData.length + " bytes");
+                uploadToWebhook(jpegData, requestId, webhookUrl, authToken);
+                callback.onSuccess(requestId);
+            } catch (Exception e) {
+                Log.e(TAG, "Error uploading JPEG photo", e);
+                callback.onError(requestId, e.getMessage());
+            }
+        }).start();
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/utils/Constants.kt

@@ -0,0 +1,44 @@
+package com.mentra.bluetoothsdk.utils
+
+object DeviceTypes {
+    const val SIMULATED = "Simulated Glasses"
+    const val G1 = "Even Realities G1"
+    const val NEX = "Mentra Display"
+    const val MACH1 = "Mentra Mach1"
+    const val LIVE = "Mentra Live"
+    const val Z100 = "Vuzix Z100"
+    const val FRAME = "Brilliant Frame"
+    const val G2 = "Even Realities G2"
+    val ALL = arrayOf(SIMULATED, G1, G2, MACH1, LIVE, Z100, FRAME, NEX)
+}
+
+object ControllerTypes {
+    const val R1 = "Even Realities R1"
+    val ALL = arrayOf(R1)
+}
+
+object ConnTypes {
+    const val CONNECTING = "CONNECTING"
+    const val CONNECTED = "CONNECTED"
+    const val DISCONNECTED = "DISCONNECTED"
+    const val SCANNING = "SCANNING"
+    const val BONDING = "BONDING"
+}
+
+object MicTypes {
+    const val PHONE_INTERNAL = "phone"
+    const val GLASSES_CUSTOM = "glasses"
+    const val BT_CLASSIC = "btclassic"
+    const val BT = "bt"
+    val ALL = arrayOf(PHONE_INTERNAL, GLASSES_CUSTOM, BT_CLASSIC, BT)
+}
+
+// convert to kotlin:
+object MicMap {
+    val map: Map<String, List<String>> = mapOf(
+        "auto" to listOf(MicTypes.GLASSES_CUSTOM, MicTypes.PHONE_INTERNAL, MicTypes.BT, MicTypes.BT_CLASSIC),
+        "glasses" to listOf(MicTypes.GLASSES_CUSTOM),
+        "phone" to listOf(MicTypes.PHONE_INTERNAL, MicTypes.GLASSES_CUSTOM),
+        "bluetooth" to listOf(MicTypes.BT, MicTypes.BT_CLASSIC, MicTypes.PHONE_INTERNAL, MicTypes.GLASSES_CUSTOM),
+    )
+}