@mentra/bluetooth-sdk 0.1.21-beta.0 → 0.1.21-beta.1

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/ar99/ota/OtaProtocol.java

@@ -0,0 +1,92 @@
+package com.mentra.bluetoothsdk.sgcs.ar99.ota;
+
+import java.io.ByteArrayOutputStream;
+
+public final class OtaProtocol {
+  private OtaProtocol() {}
+
+  public static byte[] buildFrame(byte cmd, byte paramType, byte[] payload) {
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    out.write(OtaCommandConstants.OTA.SVC_ID & 0xFF);
+    out.write(cmd & 0xFF);
+    out.write(paramType & 0xFF);
+    int len = payload != null ? payload.length : 0;
+    out.write(len & 0xFF);
+    out.write((len >> 8) & 0xFF);
+    if (payload != null && payload.length > 0) {
+      try {
+        out.write(payload);
+      } catch (Exception ignored) {
+      }
+    }
+    return out.toByteArray();
+  }
+
+  public static byte[] buildRequestUpgrade(int packageSize, int blockSize, long crc32) {
+    // Wire layout matches the vendor bring-up frame: type marker, then TLV
+    // 0x0A/len4 = package size (LE). CRC is validated per-block in SEND_IMAGE_DATA;
+    // blockSize is negotiated separately in CONNECT_NEGOTIATION.
+    ByteArrayOutputStream payload = new ByteArrayOutputStream();
+    payload.write(0x09);
+    payload.write(0x01);
+    payload.write(0x00);
+    payload.write(0x01);
+    payload.write(0x0A);
+    payload.write(0x04);
+    payload.write(packageSize & 0xFF);
+    payload.write((packageSize >> 8) & 0xFF);
+    payload.write((packageSize >> 16) & 0xFF);
+    payload.write((packageSize >> 24) & 0xFF);
+    payload.write(0x00);
+    return buildFrame(OtaCommandConstants.OTA.REQUEST_UPGRADE, (byte) 0x80, payload.toByteArray());
+  }
+
+  public static byte[] buildConnectNegotiation(int blockSize) {
+    return buildFrame(OtaCommandConstants.OTA.CONNECT_NEGOTIATION, (byte) 0x80, null);
+  }
+
+  public static byte[] buildNegotiationResult() {
+    ByteArrayOutputStream payload = new ByteArrayOutputStream();
+    payload.write(0x01);
+    payload.write(0x01);
+    payload.write(0x00);
+    payload.write(0x01);
+    return buildFrame(OtaCommandConstants.OTA.NEGOTIATION_RESULT, (byte) 0x80, payload.toByteArray());
+  }
+
+  public static byte[] buildSendImageData(int psn, byte[] data) {
+    ByteArrayOutputStream payload = new ByteArrayOutputStream();
+    payload.write(psn & 0xFF);
+    long crc32 = OtaCrc32Util.calculate(data);
+    payload.write((byte) (crc32 & 0xFF));
+    payload.write((byte) ((crc32 >> 8) & 0xFF));
+    payload.write((byte) ((crc32 >> 16) & 0xFF));
+    payload.write((byte) ((crc32 >> 24) & 0xFF));
+    if (data != null && data.length > 0) {
+      try {
+        payload.write(data);
+      } catch (Exception ignored) {
+      }
+    }
+    return buildFrame(OtaCommandConstants.OTA.SEND_IMAGE_DATA, (byte) 0x80, payload.toByteArray());
+  }
+
+  public static FrameHeader parseFrameHeader(byte[] frame) {
+    if (frame == null || frame.length < 5) return null;
+    FrameHeader header = new FrameHeader();
+    header.svcId = frame[0];
+    header.cmd = frame[1];
+    header.paramType = frame[2];
+    header.paramLen = OtaByteUtils.readShortLE(frame, 3) & 0xFFFF;
+    header.payloadOffset = 5;
+    return header;
+  }
+
+  public static class FrameHeader {
+    public byte svcId;
+    public byte cmd;
+    public byte paramType;
+    public int paramLen;
+    public int payloadOffset;
+  }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/streaming/StreamModels.kt

@@ -168,6 +168,38 @@ data class StreamResolvedConfig @JvmOverloads constructor(
     }
 }
 
+/** Live encoder and device telemetry reported by the glasses while streaming. */
+data class StreamLiveStats @JvmOverloads constructor(
+    val bitrate: Long? = null,
+    val fps: Double? = null,
+    val droppedFrames: Long? = null,
+    val duration: Long? = null,
+    val temperatureC: Double? = null,
+) {
+    fun toMap(): Map<String, Any> =
+        buildMap {
+            bitrate?.let { put("bitrate", it) }
+            fps?.let { put("fps", it) }
+            droppedFrames?.let { put("droppedFrames", it) }
+            duration?.let { put("duration", it) }
+            temperatureC?.let { put("temperatureC", it) }
+        }
+
+    companion object {
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>?): StreamLiveStats? {
+            values ?: return null
+            return StreamLiveStats(
+                bitrate = longValue(values, "bitrate"),
+                fps = doubleValue(values, "fps"),
+                droppedFrames = longValue(values, "droppedFrames"),
+                duration = longValue(values, "duration"),
+                temperatureC = doubleValue(values, "temperatureC"),
+            )
+        }
+    }
+}
+
 data class StreamRequest @JvmOverloads constructor(
     val streamUrl: String,
     val streamId: String = "",
@@ -435,6 +467,7 @@ sealed interface StreamStatus {
 
 data class StreamStatusEvent(
     val status: StreamStatus,
+    val stats: StreamLiveStats? = null,
 ) {
     // True when the glasses will retry the failed publisher themselves
     // (emitting side lands in PR #3488); absent on older firmware and on
@@ -443,7 +476,10 @@ data class StreamStatusEvent(
     var willRetry: Boolean? = null
         private set
 
-    constructor(values: Map<String, Any>) : this(StreamStatus.fromMap(values)) {
+    constructor(values: Map<String, Any>) : this(
+        status = StreamStatus.fromMap(values),
+        stats = StreamLiveStats.fromMap(stringMapValue(values["stats"])),
+    ) {
         willRetry = boolValue(values, "willRetry")
     }
 
@@ -453,6 +489,7 @@ data class StreamStatusEvent(
     val values: Map<String, Any>
         get() = buildMap {
             putAll(status.toEventMap())
+            stats?.let { put("stats", it.toMap()) }
             willRetry?.let { put("willRetry", it) }
         }
 }

package/android/src/main/java/com/mentra/bluetoothsdk/types/DeviceModels.kt

@@ -23,6 +23,7 @@ enum class DeviceModel(val deviceType: String) {
     Z100(DeviceTypes.Z100),
     FRAME(DeviceTypes.FRAME),
     NIMO(DeviceTypes.NIMO),
+    AR99(DeviceTypes.AR99),
     SIMULATED(DeviceTypes.SIMULATED),
     R1(ControllerTypes.R1);
 
@@ -38,6 +39,7 @@ data class Device(
     val name: String,
     /** Android Bluetooth address when available. */
     val address: String? = null,
+    val projectName: String? = null,
     val rssi: Int? = null,
     /** Stable app-facing scan-result key. Do not parse; use typed fields instead. */
     val id: String = address?.takeIf { it.isNotBlank() } ?: "${model.deviceType}:$name",
@@ -50,6 +52,9 @@ data class Device(
             address?.takeIf { it.isNotBlank() }?.let {
                 put("address", it)
             }
+            projectName?.takeIf { it.isNotBlank() }?.let {
+                put("projectName", it)
+            }
             rssi?.let { put("rssi", it) }
         }
 
@@ -58,12 +63,14 @@ data class Device(
             val model = stringValue(values, "model") ?: return null
             val name = stringValue(values, "name") ?: return null
             val address = stringValue(values, "address")?.takeIf { it.isNotBlank() }
+            val projectName = stringValue(values, "projectName")?.takeIf { it.isNotBlank() }
             val rssi = numberValue(values, "rssi")
             val id = stringValue(values, "id")?.takeIf { it.isNotBlank() } ?: address ?: "${model}:$name"
             return Device(
                 model = DeviceModel.fromDeviceType(model),
                 name = name,
                 address = address,
+                projectName = projectName,
                 rssi = rssi,
                 id = id,
             )

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

@@ -66,6 +66,14 @@ public final class BleJsonCompact {
         putKey("transferMethod", "tm");
         putKey("manual", "m");
         putKey("reconnecting", "rc");
+        putKey("stats", "st");
+        putKey("width", "w");
+        putKey("height", "h");
+        putKey("bitrate", "br");
+        putKey("fps", "f");
+        putKey("droppedFrames", "df");
+        putKey("duration", "du");
+        putKey("temperatureC", "tc");
 
         putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "accepted", 0);
         putEnum(PHOTO_STATUS_TO_INT, PHOTO_STATUS_FROM_INT, "queued", 1);

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

@@ -10,7 +10,8 @@ object DeviceTypes {
     const val FRAME = "Brilliant Frame"
     const val G2 = "Even Realities G2"
     const val NIMO = "NIMO"
-    val ALL = arrayOf(SIMULATED, G1, G2, MACH1, LIVE, Z100, FRAME, NEX, NIMO)
+    const val AR99 = "AR99"
+    val ALL = arrayOf(SIMULATED, G1, G2, MACH1, LIVE, Z100, FRAME, NEX, NIMO, AR99)
 }
 
 object ControllerTypes {

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

@@ -26,6 +26,14 @@ class PhoneAudioMonitor private constructor(private val context: Context) {
         @Volatile
         private var instance: PhoneAudioMonitor? = null
 
+        internal fun shouldKeepOwnAppAudioSignal(
+            signalledPlaying: Boolean,
+            systemAudioPlaying: Boolean,
+            nowMs: Long,
+            holdoffUntilMs: Long,
+        ): Boolean =
+            signalledPlaying && (systemAudioPlaying || nowMs < holdoffUntilMs)
+
         @JvmStatic
         fun getInstance(context: Context): PhoneAudioMonitor {
             return instance ?: synchronized(this) {
@@ -48,6 +56,10 @@ class PhoneAudioMonitor private constructor(private val context: Context) {
     private var listener: Listener? = null
     private var isMonitoring = false
     private var lastKnownState = false
+    // Set explicitly by AudioPlaybackService. Unlike isPlaying(), this is
+    // limited to Mentra's own playback and is safe for mic-watchdog gating.
+    @Volatile
+    private var ownAppAudioPlaying = false
 
     // Rate limiting: max 1 state change notification per 500ms
     // If state changes rapidly (true/false/true), we wait and send the final state
@@ -78,6 +90,37 @@ class PhoneAudioMonitor private constructor(private val context: Context) {
         return audioManager.isMusicActive
     }
 
+    /**
+     * Return the explicit React Native playback hint, reconciling it with
+     * Android's actual media state.
+     *
+     * Expo can miss a completion callback while its Activity is backgrounded,
+     * leaving the explicit hint stuck at PLAYING. The hint only protects the
+     * short A2DP codec transition; after that hold-off, Android's
+     * isMusicActive is authoritative. Clearing a stale hint lets the glasses
+     * mic watchdog recover instead of suppressing recovery forever.
+     */
+    @Synchronized
+    fun isOwnAppAudioPlaying(): Boolean {
+        val systemAudioPlaying = isPlaying()
+        if (
+            shouldKeepOwnAppAudioSignal(
+                ownAppAudioPlaying,
+                systemAudioPlaying,
+                System.currentTimeMillis(),
+                audioStartHoldoffUntil,
+            )
+        ) {
+            return true
+        }
+
+        if (ownAppAudioPlaying) {
+            ownAppAudioPlaying = false
+            Bridge.log("$TAG: Cleared stale own-app audio flag (system audio is inactive)")
+        }
+        return false
+    }
+
     /**
      * Notify the monitor that our own app started/stopped playing audio
      * Called from RN AudioPlaybackService via Bridge
@@ -87,7 +130,9 @@ class PhoneAudioMonitor private constructor(private val context: Context) {
      * there's a brief gap where the system reports 0 active configs (codec is switching).
      * The hold-off prevents us from reporting STOPPED during this transition.
      */
+    @Synchronized
     fun setOwnAppAudioPlaying(playing: Boolean) {
+        ownAppAudioPlaying = playing
         Bridge.log("$TAG: Own app audio -> ${if (playing) "PLAYING" else "STOPPED"}")
 
         if (playing) {

package/android/src/main/java/com/mentra/bluetoothsdk/utils/audio/Ar99OpusPcmDecoder.java

@@ -0,0 +1,398 @@
+package com.mentra.bluetoothsdk.utils.audio;
+
+import android.util.Log;
+
+import java.util.Arrays;
+import java.util.concurrent.ArrayBlockingQueue;
+
+import io.github.jaredmdobson.OpusDecoder;
+import io.github.jaredmdobson.OpusException;
+
+/**
+ * AR99 Opus decoder worker.
+ *
+ * <p>The caller feeds BLE notify bytes through {@link #submitBleNotify(byte[])}. This class owns
+ * queueing, frame reassembly, Opus decoder state, and decoded PCM callbacks.
+ */
+public final class Ar99OpusPcmDecoder extends Thread {
+  public interface Callback {
+    void onPcmDecoded(byte[] pcmData);
+
+    default void onNotifyProcessed(int rawLen, int pcmFrames, int pcmBytesOut) {}
+  }
+
+  private enum TaskType {
+    DECODE,
+    RESET,
+    STOP
+  }
+
+  private static final class Task {
+    final TaskType type;
+    final byte[] payload;
+
+    Task(TaskType type, byte[] payload) {
+      this.type = type;
+      this.payload = payload;
+    }
+  }
+
+  private static final int SAMPLE_RATE = 16000;
+  private static final int CHANNELS = 1;
+  private static final int MAX_FRAME_SAMPLES = 5760;
+  private static final int FRAME_BYTES = 48;
+  private static final int HEADER_BYTES = 8;
+  private static final int MAX_BUFFER_SIZE = 10000;
+  private static final int TASK_QUEUE_CAPACITY = 256;
+  private static final int MAX_DIAG_FRAMES = 8;
+  private static final byte[] EXPECTED_PREFIX = new byte[] {0x00, 0x00, 0x00, 0x28};
+  private static final String TAG = "Ar99OpusPcmDecoder";
+
+  private final Callback callback;
+  private final OpusDecoder decoder;
+  private final ArrayBlockingQueue<Task> taskQueue = new ArrayBlockingQueue<>(TASK_QUEUE_CAPACITY);
+
+  private volatile boolean running = true;
+
+  private byte[] buffer = new byte[0];
+  private long totalNotifyCount = 0L;
+  private long totalFrameCount = 0L;
+  private long totalDecodeFailCount = 0L;
+  private long totalHeaderMismatchCount = 0L;
+  private long totalShortChunkCount = 0L;
+  private long totalResyncDropBytes = 0L;
+  private boolean headerLooksStable = true;
+
+  public Ar99OpusPcmDecoder(Callback callback) throws OpusException {
+    super("ar99-opus-decode");
+    this.callback = callback;
+    this.decoder = new OpusDecoder(SAMPLE_RATE, CHANNELS);
+    start();
+  }
+
+  public void submitBleNotify(byte[] opusPayload) {
+    if (!running || opusPayload == null || opusPayload.length == 0) {
+      return;
+    }
+    byte[] payloadCopy = Arrays.copyOf(opusPayload, opusPayload.length);
+    if (!taskQueue.offer(new Task(TaskType.DECODE, payloadCopy))) {
+      Log.w(TAG, "AR99 Opus task queue full, drop notify len=" + payloadCopy.length);
+    }
+  }
+
+  public void resetSession() {
+    if (!running) {
+      return;
+    }
+    taskQueue.clear();
+    taskQueue.offer(new Task(TaskType.RESET, null));
+  }
+
+  public void resetBuffer() {
+    resetSession();
+  }
+
+  public void shutdownDecoder() {
+    if (!running) {
+      return;
+    }
+    running = false;
+    taskQueue.clear();
+    taskQueue.offer(new Task(TaskType.STOP, null));
+  }
+
+  public synchronized byte[] decodePacketToPcm16Mono(byte[] opusPayload) {
+    return decodePayload(opusPayload);
+  }
+
+  @Override
+  public void run() {
+    try {
+      while (true) {
+        Task task = taskQueue.take();
+        if (task.type == TaskType.STOP) {
+          break;
+        }
+        if (task.type == TaskType.RESET) {
+          resetDecoderState();
+          continue;
+        }
+        if (task.payload != null && task.payload.length > 0) {
+          handleChunk(task.payload);
+        }
+      }
+    } catch (InterruptedException e) {
+      if (running) {
+        Log.w(TAG, "AR99 Opus worker interrupted: " + e.getMessage());
+      }
+    } finally {
+      taskQueue.clear();
+      resetDecoderState();
+    }
+  }
+
+  private synchronized void resetDecoderState() {
+    decoder.resetState();
+    buffer = new byte[0];
+    totalNotifyCount = 0L;
+    totalFrameCount = 0L;
+    totalDecodeFailCount = 0L;
+    totalHeaderMismatchCount = 0L;
+    totalShortChunkCount = 0L;
+    totalResyncDropBytes = 0L;
+    headerLooksStable = true;
+  }
+
+  private synchronized void handleChunk(byte[] chunk) {
+    totalNotifyCount++;
+    if (chunk.length < FRAME_BYTES) {
+      totalShortChunkCount++;
+    }
+
+    if (buffer.length + chunk.length > MAX_BUFFER_SIZE) {
+      Log.w(
+          TAG,
+          "AR99 Opus buffer overflow, clear"
+              + ", oldBuf="
+              + buffer.length
+              + ", chunk="
+              + chunk.length
+              + ", notify#="
+              + totalNotifyCount);
+      buffer = new byte[0];
+    }
+
+    int oldBufferLen = buffer.length;
+    buffer = concat(buffer, chunk);
+
+    int pcmFrames = 0;
+    int pcmBytesOut = 0;
+    int decodeFail = 0;
+    int skipPayload = 0;
+    int headerMismatch = 0;
+
+    while (buffer.length >= EXPECTED_PREFIX.length) {
+      int frameStart = findFrameStart(buffer, 0);
+      if (frameStart < 0) {
+        int keep = Math.min(buffer.length, EXPECTED_PREFIX.length - 1);
+        int drop = buffer.length - keep;
+        if (drop > 0) {
+          totalResyncDropBytes += drop;
+          headerLooksStable = false;
+          Log.w(
+              TAG,
+              "AR99 Opus resync drop(no header)"
+                  + " notify#="
+                  + totalNotifyCount
+                  + " dropBytes="
+                  + drop
+                  + " keepTail="
+                  + keep
+                  + " tailHex="
+                  + hex(Arrays.copyOfRange(buffer, drop, buffer.length), keep));
+          buffer = Arrays.copyOfRange(buffer, drop, buffer.length);
+        }
+        break;
+      }
+
+      if (frameStart > 0) {
+        totalResyncDropBytes += frameStart;
+        headerLooksStable = false;
+        headerMismatch++;
+        totalHeaderMismatchCount++;
+        Log.w(
+            TAG,
+            "AR99 Opus resync shift"
+                + " notify#="
+                + totalNotifyCount
+                + " dropBytes="
+                + frameStart
+                + " bufLen="
+                + buffer.length
+                + " droppedHex="
+                + hex(Arrays.copyOfRange(buffer, 0, frameStart), Math.min(frameStart, 24)));
+        buffer = Arrays.copyOfRange(buffer, frameStart, buffer.length);
+      }
+
+      if (buffer.length < FRAME_BYTES) {
+        break;
+      }
+
+      byte[] frame = Arrays.copyOfRange(buffer, 0, FRAME_BYTES);
+      buffer = Arrays.copyOfRange(buffer, FRAME_BYTES, buffer.length);
+      totalFrameCount++;
+
+      boolean prefixOk = true;
+      for (int i = 0; i < EXPECTED_PREFIX.length; i++) {
+        if (frame[i] != EXPECTED_PREFIX[i]) {
+          prefixOk = false;
+          break;
+        }
+      }
+      if (!prefixOk) {
+        headerMismatch++;
+        totalHeaderMismatchCount++;
+        headerLooksStable = false;
+        if (totalFrameCount <= MAX_DIAG_FRAMES || !headerLooksStable) {
+          Log.w(
+              TAG,
+              "AR99 Opus frame header mismatch"
+                  + " frame#="
+                  + totalFrameCount
+                  + " notify#="
+                  + totalNotifyCount
+                  + " remain="
+                  + buffer.length
+                  + " frameHex="
+                  + hex(frame, FRAME_BYTES));
+        }
+      }
+
+      byte[] opusPayload = Arrays.copyOfRange(frame, HEADER_BYTES, FRAME_BYTES);
+      if (opusPayload.length == 0) {
+        skipPayload++;
+        continue;
+      }
+
+      byte[] pcm = decodePayload(opusPayload);
+      if (pcm != null && pcm.length > 0) {
+        pcmFrames++;
+        pcmBytesOut += pcm.length;
+        if (callback != null) {
+          callback.onPcmDecoded(pcm);
+        }
+      } else {
+        decodeFail++;
+        totalDecodeFailCount++;
+        if (totalFrameCount <= MAX_DIAG_FRAMES || !headerLooksStable) {
+          Log.w(
+              TAG,
+              "AR99 Opus frame decode failed"
+                  + " frame#="
+                  + totalFrameCount
+                  + " notify#="
+                  + totalNotifyCount
+                  + " prefixOk="
+                  + prefixOk
+                  + " frameHex="
+                  + hex(frame, FRAME_BYTES)
+                  + " payloadHex="
+                  + hex(opusPayload, opusPayload.length));
+        }
+      }
+    }
+
+    if (chunk.length != FRAME_BYTES
+        || oldBufferLen != 0
+        || decodeFail > 0
+        || headerMismatch > 0
+        || skipPayload > 0
+        || pcmFrames == 0
+        || !headerLooksStable) {
+      Log.d(
+          TAG,
+          "AR99 Opus decode summary"
+              + " notify#="
+              + totalNotifyCount
+              + " inLen="
+              + chunk.length
+              + " pcmFrames="
+              + pcmFrames
+              + " decodeFail="
+              + decodeFail
+              + " headerMismatch="
+              + headerMismatch
+              + " skipPayload="
+              + skipPayload
+              + " bufRemain="
+              + buffer.length
+              + " totals={frames="
+              + totalFrameCount
+              + ",fail="
+              + totalDecodeFailCount
+              + ",headerMismatch="
+              + totalHeaderMismatchCount
+              + ",shortChunk="
+              + totalShortChunkCount
+              + ",resyncDropBytes="
+              + totalResyncDropBytes
+              + "}");
+    }
+
+    if (callback != null) {
+      callback.onNotifyProcessed(chunk.length, pcmFrames, pcmBytesOut);
+    }
+  }
+
+  private byte[] decodePayload(byte[] opusPayload) {
+    if (opusPayload == null || opusPayload.length == 0) {
+      return null;
+    }
+    byte[] pcm = new byte[MAX_FRAME_SAMPLES * CHANNELS * 2];
+    try {
+      int samples = decoder.decode(opusPayload, 0, opusPayload.length, pcm, 0, MAX_FRAME_SAMPLES, false);
+      if (samples <= 0) {
+        return null;
+      }
+      int bytes = samples * CHANNELS * 2;
+      return Arrays.copyOf(pcm, bytes);
+    } catch (OpusException | AssertionError | RuntimeException e) {
+      Log.w(
+          TAG,
+          "AR99 Opus decode failed len="
+              + opusPayload.length
+              + ", payloadHex="
+              + hex(opusPayload, opusPayload.length)
+              + ": "
+              + e.getMessage());
+      return null;
+    }
+  }
+
+  private static int findFrameStart(byte[] data, int fromIndex) {
+    if (data == null || data.length < EXPECTED_PREFIX.length) {
+      return -1;
+    }
+    int max = data.length - EXPECTED_PREFIX.length;
+    for (int i = Math.max(0, fromIndex); i <= max; i++) {
+      boolean match = true;
+      for (int j = 0; j < EXPECTED_PREFIX.length; j++) {
+        if (data[i + j] != EXPECTED_PREFIX[j]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  private static String hex(byte[] data, int maxBytes) {
+    if (data == null || data.length == 0 || maxBytes <= 0) {
+      return "";
+    }
+    int len = Math.min(data.length, maxBytes);
+    StringBuilder sb = new StringBuilder(len * 3);
+    for (int i = 0; i < len; i++) {
+      if (i > 0) {
+        sb.append(' ');
+      }
+      sb.append(String.format("%02X", data[i] & 0xFF));
+    }
+    if (data.length > len) {
+      sb.append("...");
+    }
+    return sb.toString();
+  }
+
+  private static byte[] concat(byte[] a, byte[] b) {
+    if (a.length == 0) {
+      return Arrays.copyOf(b, b.length);
+    }
+    byte[] out = Arrays.copyOf(a, a.length + b.length);
+    System.arraycopy(b, 0, out, a.length, b.length);
+    return out;
+  }
+}