Fix Opus decoding and RX jitter buffer on Android 16 (v1.0.5)

- Monitor button between callsign and TG selector
- On: reconnects with TG_MONITOR for all switch-list groups,
  status shows 'Мониторинг: TG...', PTT disabled
- Talker display shows callsign and its TG
- Off: back to normal talk mode

app/src/main/java/ru/ua1zbe/svxremote/MainActivity.kt

@@ -9,6 +9,8 @@ import android.content.Intent
 import android.content.ServiceConnection
 import android.content.pm.PackageManager
 import android.net.Uri
+import android.content.res.ColorStateList
+import android.graphics.Color
 import android.graphics.PixelFormat
 import android.os.Build
 import android.os.Bundle
@@ -57,10 +59,13 @@ class MainActivity : Activity(), SvxService.Listener {
     private lateinit var micDb: TextView
     private lateinit var pttButton: PttButton
     private lateinit var btnSettings: ImageButton
+    private lateinit var btnMonitor: ImageButton
 
     private val mainHandler = Handler(Looper.getMainLooper())
 
     private var connected = false
+    private var monitoring = false
+    private var priorityActive = false
     private var settings: ConnectionSettings = ConnectionSettings("", 5300, "", "", 11)
 
     private var svc: SvxService? = null
@@ -101,8 +106,11 @@ class MainActivity : Activity(), SvxService.Listener {
         micDb = findViewById(R.id.mic_db)
         pttButton = findViewById(R.id.ptt_button)
         btnSettings = findViewById(R.id.btn_settings)
+        btnMonitor = findViewById(R.id.btn_monitor)
         pttButton.enabled2 = false
 
+        btnMonitor.setOnClickListener { toggleMonitoring() }
+        updateMonitorButton()
         val testText = intent?.getStringExtra("node_toast_test")
         if (testText != null) {
             mainHandler.postDelayed({ showNodeOverlay(testText) }, 1500)
@@ -152,6 +160,7 @@ class MainActivity : Activity(), SvxService.Listener {
             }
 
             override fun onPttUp() {
+                Log.d("SVXRemote", "PTT up")
                 svc?.stopTx()
                 lblPttHint.text = getString(R.string.hold_to_talk)
                 lblTxState.text =
@@ -239,7 +248,11 @@ class MainActivity : Activity(), SvxService.Listener {
                 ReflectorClient.STATE_READY -> {
                     connected = true
                     updatePttEnabled()
-                    statusChip.text = getString(R.string.status_connected)
+                    statusChip.text = if (monitoring) {
+                        getString(R.string.status_monitoring, monitorTgLabel())
+                    } else {
+                        getString(R.string.status_connected)
+                    }
                     statusChip.setTextColor(getColor(R.color.accent))
                     lblTxState.text = getString(R.string.status_big_connected)
                     lblTxState.setTextColor(getColor(R.color.accent))
@@ -280,13 +293,32 @@ class MainActivity : Activity(), SvxService.Listener {
 
     override fun onTalkerStart(tg: Long, callsign: String) {
         mainHandler.post {
-            lblTalkerTitle.text = getString(R.string.talker_now, callsign)
+            val priority = monitoring && settings.groups.firstOrNull() == tg
+            if (priority) {
+                priorityActive = true
+            }
+            if (priority || !priorityActive) {
+                svc?.selectGroup(tg)
+                lblTalkerTitle.text = when {
+                    priority -> getString(R.string.talker_mon_priority, callsign, tg)
+                    monitoring -> getString(R.string.talker_mon, callsign, tg)
+                    else -> getString(R.string.talker_now, callsign)
+                }
+                lblTalkerTitle.setTextColor(
+                    if (priority) getColor(R.color.danger) else getColor(R.color.text_secondary)
+                )
                 lblTalker.text = callsign
             }
         }
+    }
 
     override fun onTalkerStop(tg: Long, callsign: String) {
         // последний говоривший остаётся на экране
+        mainHandler.post {
+            if (monitoring && settings.groups.firstOrNull() == tg) {
+                priorityActive = false
+            }
+        }
     }
 
     override fun onNodeJoined(callsign: String, tg: Long?) {
@@ -366,7 +398,7 @@ class MainActivity : Activity(), SvxService.Listener {
     }
 
     private fun updatePttEnabled() {
-        pttButton.enabled2 = connected
+        pttButton.enabled2 = connected && !monitoring
     }
 
     private fun requestPermissionsIfNeeded() {
@@ -391,12 +423,37 @@ class MainActivity : Activity(), SvxService.Listener {
                     port = settings.port,
                     callsign = settings.callsign,
                     authKey = settings.authKey,
-                    talkGroup = settings.talkGroup
+                    talkGroup = settings.talkGroup,
+                    monitorTgs = if (monitoring) settings.groups else null
                 )
             )
         }, 300)
     }
 
+    /** Включить/выключить режим мониторинга групп с переподключением. */
+    private fun toggleMonitoring() {
+        monitoring = !monitoring
+        priorityActive = false
+        updateMonitorButton()
+        updatePttEnabled()
+        if (connected) {
+            svc?.disconnect()
+            mainHandler.postDelayed({ connect() }, 500)
+        } else {
+            connect()
+        }
+    }
+
+    private fun updateMonitorButton() {
+        val active = monitoring
+        btnMonitor.imageTintList = ColorStateList.valueOf(
+            if (active) Color.parseColor("#58A6FF") else Color.parseColor("#8B949E")
+        )
+        btnMonitor.setBackgroundResource(if (active) R.drawable.bg_monitor_on else 0)
+        btnMonitor.contentDescription =
+            getString(if (active) R.string.btn_monitor_on else R.string.btn_monitor)
+    }
+
     /** Переключиться на другую группу: пересохранить и переподключиться. */
     private fun switchGroup(tg: Long) {
         settings = settings.copy(talkGroup = tg)
@@ -406,6 +463,9 @@ class MainActivity : Activity(), SvxService.Listener {
         mainHandler.postDelayed({ connect() }, 500)
     }
 
+    private fun monitorTgLabel(): String =
+        settings.groups.joinToString(", ") { "TG$it" }
+
     private fun showNodesDialog() {
         val nodes = svc?.nodeList().orEmpty()
         if (nodes.isEmpty()) {

app/src/main/java/ru/ua1zbe/svxremote/SvxService.kt

@@ -8,6 +8,7 @@ import android.app.Service
 import android.content.Intent
 import android.os.Binder
 import android.os.IBinder
+import android.util.Log
 import ru.ua1zbe.svxremote.audio.OpusEngine
 import ru.ua1zbe.svxremote.proto.MsgParser
 import ru.ua1zbe.svxremote.proto.ReflectorClient
@@ -87,13 +88,22 @@ class SvxService : Service(), ReflectorClient.Callbacks {
 
     fun isRunning(): Boolean = client.isRunning()
 
+    fun selectGroup(tg: Long) {
+        client.selectGroup(tg)
+    }
+
     fun startTx() {
         engine.startCapture { packet -> client.sendAudio(packet) }
     }
 
     fun stopTx() {
+        Log.d("SVXRemote", "stopTx")
+        // В фоне: сеть запрещена в главном потоке (NetworkOnMainThreadException),
+        // а join потока захвата блокировал бы UI
+        Thread {
             engine.stopCapture()
             client.sendAudioFlush()
+        }.start()
     }
 
     // ---------- Callbacks (фоновые потоки) ----------

app/src/main/java/ru/ua1zbe/svxremote/audio/OpusEngine.kt

@@ -47,33 +47,39 @@ class OpusEngine(
     private var recThread: Thread? = null
 
     private val encodeBufferInfo = MediaCodec.BufferInfo()
-    private val decodeBufferInfo = MediaCodec.BufferInfo()
 
     // ---------- Воспроизведение (RX) ----------
 
-    private var headSent = false
     private val rxQueue = java.util.concurrent.ConcurrentLinkedQueue<ByteArray>()
-    private var drainThread: Thread? = null
+    private val freeInputs = java.util.concurrent.ConcurrentLinkedQueue<Int>()
     private var ptsCounter = 0L
+    private var receivedAny = false
+    private var concealLogs = 0
+    private var dbgOut = 0
+    private var playStarted = false
+    private var gateStart = 0L
+    private val jitterTarget = 6 // ≈ 120 мс накапливаем до первого слива
+    private val configBuffers = ArrayList<ByteArray>()
+    private var configIdx = 0
 
     fun startDecoder() {
         if (decoder != null) return
         val format = MediaFormat()
         format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_AUDIO_OPUS)
-        format.setInteger(MediaFormat.KEY_SAMPLE_RATE, SAMPLE_RATE)
+        // ВАЖНО: c2.android.opus.decoder (Android 16) выводит только 48 кГц
+        // (kRate=48000); KEY_SAMPLE_RATE=8000 вызывает конфликт конфига
+        // («We have a failed config») и фатальную ошибку кодера.
+        format.setInteger(MediaFormat.KEY_SAMPLE_RATE, OUT_SAMPLE_RATE)
         format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, CHANNELS)
-        format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 8192)
-        // Android 16: c2.android.opus.decoder ждёт 3 конфиг-буфера:
-        // csd-0 OpusHead, csd-1 CodecDelay (int64 LE нс), csd-2 SeekPreRoll (int64 LE нс).
-        // Без csd-1/2 декодер берёт мусорные значения из пакетов и молча
-        // выкидывает весь вывод (mSamplesToDiscard).
-        format.setByteBuffer("csd-0", ByteBuffer.wrap(opusHead()))
-        // Прескип 312 сэмплов при 8 кГц = 39 мс = 39_000_000 нс (перекодируется в 48 кГц внутри)
-        format.setByteBuffer("csd-1", ByteBuffer.wrap(longBytes(39_000_000L)))
-        format.setByteBuffer("csd-2", ByteBuffer.wrap(longBytes(0L)))
+        // Android 16: c2.android.opus.decoder читает конфиг (OpusHead + codec
+        // delay + seek preroll) ТОЛЬКО из первых входных буферов
+        // (см. queueDecoderConfig); csd-ключи MediaFormat он игнорирует, и без
+        // конфига первый же аудио-кадр ломает декодер (C2_CORRUPTED).
         decoder = try {
             MediaCodec.createDecoderByType(MediaFormat.MIMETYPE_AUDIO_OPUS).also {
+                it.setCallback(decoderCallback)
                 it.configure(format, null, null, 0)
+                queueDecoderConfig() // готовим конфиг ДО start: колбэки уйдут после
                 it.start()
             }
         } catch (e: Exception) {
@@ -81,6 +87,7 @@ class OpusEngine(
             null
         }
         if (decoder == null) return
+        Log.d(TAG, "decoder started, config=${configBuffers.size}B")
         val minBuf = AudioTrack.getMinBufferSize(
             OUT_SAMPLE_RATE,
             AudioFormat.CHANNEL_OUT_MONO,
@@ -92,77 +99,165 @@ class OpusEngine(
                 OUT_SAMPLE_RATE,
                 AudioFormat.CHANNEL_OUT_MONO,
                 AudioFormat.ENCODING_PCM_16BIT,
-                maxOf(minBuf, FRAME_SIZE * 2 * 8),
+                maxOf(minBuf, 20000), // ~208 мс — буфер AudioTrack и есть джиттер-буфер
                 AudioTrack.MODE_STREAM
-            ).also { it.play() }
+            ) // play() включаем на первом выходном кадре — буфер успевает накопиться
         } catch (e: Exception) {
             Log.e(TAG, "AudioTrack create failed: ${e.message}")
             null
         }
-        headSent = true // csd уходит через формат, не через буферы
-        drainThread = Thread({ drainLoop() }, "opus-out").also { it.start() }
+        concealLogs = 0
+        dbgOut = 0
+        ptsCounter = 20_000L // первый кадр: pts!=0, иначе декодер повторно сбросит codecDelay
         Log.d(TAG, "decoder started")
     }
 
+    /** Асинхронные колбэки кодера: подача входных кадров + слив вывода. */
+    private val decoderCallback = object : MediaCodec.Callback() {
+        override fun onError(codec: MediaCodec, e: MediaCodec.CodecException) {
+            Log.e(TAG, "decoder error: ${e.message} code=${e.errorCode} transient=${e.isTransient}")
+        }
+
+        override fun onInputBufferAvailable(codec: MediaCodec, index: Int) {
+            // Конфиг (csd) первыми входными буферами — в async-режиме нельзя
+            // использовать dequeueInputBuffer, только колбэки
+            if (configIdx < configBuffers.size) {
+                val data = configBuffers[configIdx++]
+                try {
+                    val buf = codec.getInputBuffer(index) ?: return
+                    buf.clear()
+                    buf.put(data)
+                    codec.queueInputBuffer(index, 0, data.size, 0, MediaCodec.BUFFER_FLAG_CODEC_CONFIG)
+                    Log.d(TAG, "cfg ${data.size}B")
+                } catch (e: Exception) {
+                    Log.e(TAG, "cfg error: ${e.message}")
+                }
+                return
+            }
+            val pkt = rxQueue.poll()
+            when {
+                // Джиттер-гейт: пока не накопили jitterTarget кадров (или не
+                // вышло 80 мс с первого пакета) — не кормим декодер, чтобы
+                // буфер AudioTrack успел заполниться до старта воспроизведения
+                pkt != null && gateOpen() -> feedDecoder(codec, index, pkt)
+                pkt != null -> {
+                    rxQueue.add(pkt)
+                    freeInputs.add(index)
+                }
+                receivedAny -> {
+                    if (concealLogs < 3) {
+                        Log.d(TAG, "conceal (no packet)")
+                        concealLogs++
+                    }
+                    feedDecoder(codec, index, silenceFrame()) // скрытие потерь
+                }
+                else -> freeInputs.add(index) // ждём первый пакет
+            }
+        }
+
+        override fun onOutputBufferAvailable(codec: MediaCodec, index: Int, info: MediaCodec.BufferInfo) {
+            try {
+                if (info.size > 0) {
+                    val outBuf = ByteBuffer.allocate(info.size)
+                    outBuf.order(ByteOrder.LITTLE_ENDIAN)
+                    codec.getOutputBuffer(index)?.also { src ->
+                        src.position(info.offset)
+                        src.limit(info.offset + info.size)
+                        outBuf.put(src)
+                    }
+                    val pcm = outBuf.array()
+                    if (!playStarted) {
+                        playStarted = true
+                        Log.d(TAG, "play start")
+                        try {
+                            player?.play()
+                        } catch (e: Exception) {
+                            Log.e(TAG, "play error: ${e.message}")
+                        }
+                    }
+                    player?.write(pcm, 0, pcm.size)
+                    onLevel(SRC_SPEAKER, pcmLevel(pcm))
+                    if (dbgOut < 5) {
+                        Log.d(TAG, "out ${pcm.size}B")
+                        dbgOut++
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "out error: ${e.message}")
+            } finally {
+                try {
+                    codec.releaseOutputBuffer(index, false)
+                } catch (_: Exception) {
+                }
+            }
+        }
+
+        override fun onOutputFormatChanged(codec: MediaCodec, format: MediaFormat) {
+            Log.d(TAG, "dec out format: sr=${format.getInteger(MediaFormat.KEY_SAMPLE_RATE)} " +
+                "ch=${format.getInteger(MediaFormat.KEY_CHANNEL_COUNT)}")
+        }
+    }
+
+    private fun feedDecoder(codec: MediaCodec, index: Int, pkt: ByteArray) {
+        try {
+            val buf = codec.getInputBuffer(index) ?: return
+            buf.clear()
+            buf.put(pkt)
+            codec.queueInputBuffer(index, 0, pkt.size, ptsCounter, 0)
+            ptsCounter += 20_000L // 20 мс кадра
+            if (concealLogs < 3 && rxQueue.isEmpty() && pkt === silenceFrame()) {
+                Log.d(TAG, "conceal (no packet)")
+                concealLogs++
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "feed error: ${e.message}")
+        }
+    }
+
+    /**
+     * Android 16: c2.android.opus.decoder читает конфиг из первых входных
+     * буферов. Единый CSD-блоб (формат AOSP WriteOpusHeaders): OpusHead (19
+     * байт) + codecDelay (int64 LE нс) + seekPreroll (int64 LE нс) — БЕЗ
+     * u32-префиксов длины. После него декодер уже сконфигурирован; лишние
+     * конфиг-буферы игнорируются как повторный CSD, поэтому шлём и их.
+     */
+    private fun queueDecoderConfig() {
+        configBuffers.clear()
+        try {
+            val head = opusHead()
+            val delay = longBytes(39_000_000L) // прескип 312 сэмплов при 8 кГц = 39 мс
+            val preroll = longBytes(0L)
+            val w = java.io.ByteArrayOutputStream()
+            w.write(head)
+            w.write(delay)
+            w.write(preroll)
+            configBuffers.add(w.toByteArray())
+            configBuffers.add(delay)
+            configBuffers.add(preroll)
+            configIdx = 0
+        } catch (_: Exception) {
+        }
+    }
+
     /** int64 в little-endian. */
     private fun longBytes(v: Long): ByteArray =
         ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).putLong(v).array()
 
-    /** Отдельный поток: голова + входная очередь + слив вывода. */
-    private fun drainLoop() {
-        val dec = decoder ?: return
-        var dbg = 0
-        while (decoder != null && decoder === dec) {
-            try {
-                // Монотонный pts обязателен: при pts==0 c2.opus.decoder
-                // считает каждый кадр «перемоткой в ноль» и выбрасывает
-                // mCodecDelay сэмплов (C2SoftOpusDec.cpp, "When seeking to zero").
-                var pts = ptsCounter
-                while (true) {
-                    val pkt = rxQueue.poll() ?: break
-                    val inIdx = dec.dequeueInputBuffer(5000)
-                    if (inIdx < 0) { rxQueue.add(pkt); break }
-                    val buf = dec.getInputBuffer(inIdx) ?: break
-                    buf.clear()
-                    buf.put(pkt)
-                    dec.queueInputBuffer(inIdx, 0, pkt.size, pts, 0)
-                    pts += 20_000L // 20 мс кадра
-                    ptsCounter = pts
-                    if (dbg < 5) { Log.d(TAG, "queued ${pkt.size}B"); dbg++ }
-                }
-                var outIdx = dec.dequeueOutputBuffer(decodeBufferInfo, 1000)
-                while (outIdx >= 0) {
-                    if (outIdx == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
-                        val f = dec.outputFormat
-                        Log.d(TAG, "dec out format: sr=${f.getInteger(MediaFormat.KEY_SAMPLE_RATE)} " +
-                            "ch=${f.getInteger(MediaFormat.KEY_CHANNEL_COUNT)}")
-                    } else {
-                        if (decodeBufferInfo.size > 0) {
-                            val outBuf = ByteBuffer.allocate(decodeBufferInfo.size)
-                            outBuf.order(ByteOrder.LITTLE_ENDIAN)
-                            dec.getOutputBuffer(outIdx)?.also { src ->
-                                src.position(decodeBufferInfo.offset)
-                                src.limit(decodeBufferInfo.offset + decodeBufferInfo.size)
-                                outBuf.put(src)
-                            }
-                            val pcm = outBuf.array()
-                            player?.write(pcm, 0, pcm.size)
-                            onLevel(SRC_SPEAKER, pcmLevel(pcm))
-                            if (dbg < 5) { Log.d(TAG, "out ${pcm.size}B"); dbg++ }
-                        }
-                        dec.releaseOutputBuffer(outIdx, false)
-                    }
-                    outIdx = dec.dequeueOutputBuffer(decodeBufferInfo, 0)
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "drain error: ${e.message}")
-            }
-        }
-    }
-
-    /** Подача одного Opus-пакета на декодер. */
+    /** Подача одного Opus-пакета на декодер (с UDP-потока). */
     fun onAudioPacket(packet: ByteArray) {
         rxQueue.add(packet)
+        receivedAny = true
+        if (gateStart == 0L) gateStart = System.currentTimeMillis()
+        if (!gateOpen()) return
+        val idx = freeInputs.poll() ?: return // если слот свободен — кормим сразу
+        decoder?.let { feedDecoder(it, idx, rxQueue.poll() ?: packet) }
+    }
+
+    /** Джиттер-гейт открыт: накопили кадры или вышло 80 мс с первого пакета. */
+    private fun gateOpen(): Boolean {
+        if (playStarted) return true
+        if (rxQueue.size >= jitterTarget) return true
+        return gateStart != 0L && System.currentTimeMillis() - gateStart >= 80
     }
 
     fun onAudioFlush() {
@@ -170,11 +265,23 @@ class OpusEngine(
             decoder?.flush()
             player?.flush()
             rxQueue.clear()
+            receivedAny = false
+            playStarted = false
+            gateStart = 0L
             onLevel(SRC_SPEAKER, 0f)
         } catch (_: Exception) {
         }
     }
 
+    /**
+     * Один кадр тишины (20 мс) для скрытия потерь вместо паузы в звуке.
+     * Сгенерирован opuslib: 8 кГц, моно, 20 кбит/с, нули PCM.
+     */
+    private fun silenceFrame(): ByteArray = byteArrayOf(
+        0x08.toByte(), 0x0B.toByte(), 0xE4.toByte(), 0xB9.toByte(),
+        0xA0.toByte(), 0xBC.toByte(), 0x84.toByte()
+    )
+
     /** Заголовок OpusHead (csd-0) для декодера: Opus, 1 канал, 8 кГц, прескип 312. */
     private fun opusHead(): ByteArray {
         val head = "OpusHead".toByteArray(Charsets.US_ASCII)
@@ -197,8 +304,12 @@ class OpusEngine(
     /** Остановить декодер и плеер (при отключении). */
     fun stopDecoder() {
         val dec = decoder
-        decoder = null // поток разбора выйдет из цикла до release
+        decoder = null
         rxQueue.clear()
+        freeInputs.clear()
+        receivedAny = false
+        playStarted = false
+        gateStart = 0L
         if (dec != null) {
             try {
                 dec.stop()
@@ -308,14 +419,43 @@ class OpusEngine(
             } catch (_: Exception) {
             }
         }
+        // Дренаж: отдаём пакеты, оставшиеся в кодере после остановки записи
+        try {
+            var outIdx = enc.dequeueOutputBuffer(encodeBufferInfo, 0)
+            while (outIdx >= 0) {
+                if (encodeBufferInfo.size > 0) {
+                    val outBuf = ByteBuffer.allocate(encodeBufferInfo.size)
+                    enc.getOutputBuffer(outIdx)?.also { src ->
+                        src.position(encodeBufferInfo.offset)
+                        src.limit(encodeBufferInfo.offset + encodeBufferInfo.size)
+                        outBuf.put(src)
+                    }
+                    onPacket(outBuf.array())
+                }
+                enc.releaseOutputBuffer(outIdx, false)
+                outIdx = enc.dequeueOutputBuffer(encodeBufferInfo, 0)
+            }
+        } catch (_: Exception) {
+        }
     }
 
     fun stopCapture() {
+        if (!encoding && recThread == null) return
         encoding = false
         try {
             recorder?.stop()
         } catch (_: Exception) {
         }
+        // Ждём завершения потока захвата: он должен отправить последние пакеты,
+        // чтобы flush (окончание передачи) ушёл после всего аудио
+        val t = recThread
+        recThread = null
+        if (t != null && t.isAlive) {
+            try {
+                t.join(1000)
+            } catch (_: InterruptedException) {
+            }
+        }
         try {
             recorder?.release()
         } catch (_: Exception) {
@@ -330,8 +470,6 @@ class OpusEngine(
         } catch (_: Exception) {
         }
         encoder = null
-        recThread?.interrupt()
-        recThread = null
         onLevel(SRC_MIC, 0f)
     }
 

app/src/main/java/ru/ua1zbe/svxremote/proto/ReflectorClient.kt

@@ -58,7 +58,9 @@ class ReflectorClient(
         val port: Int,
         val callsign: String,
         val authKey: String,
-        val talkGroup: Long
+        val talkGroup: Long,
+        /** Список групп для мониторинга; null = обычный режим (своя группа). */
+        val monitorTgs: List<Long>? = null
     )
 
     @Volatile
@@ -151,12 +153,30 @@ class ReflectorClient(
         udpSend(sock, s, data)
     }
 
+    /** Переключить принимаемую группу на живом соединении. */
+    fun selectGroup(tg: Long) {
+        val sock = tcpSocket
+        if (sock == null || !running.get()) {
+            Log.d(TAG, "selectGroup tg=$tg skipped (sock=${sock != null} running=${running.get()})")
+            return
+        }
+        try {
+            Log.d(TAG, "selectGroup tg=$tg")
+            sendTcp(sock, MsgBuilder.selectTg(tg))
+        } catch (_: Exception) {
+        }
+    }
+
     /** Конец передачи. */
     fun sendAudioFlush() {
         val sock = udpSocket
         val s = settings
         val id = clientId
-        if (sock == null || s == null || id == 0) return
+        if (sock == null || s == null || id == 0) {
+            Log.w(TAG, "sendAudioFlush skipped (sock=${sock != null} s=${s != null} id=$id)")
+            return
+        }
+        Log.d(TAG, "sendAudioFlush")
         udpSend(sock, s, MsgBuilder.udpFlush(id, nextSeq()))
     }
 
@@ -361,8 +381,14 @@ class ReflectorClient(
                     // (иначе сервер не шлёт аудио группы и не показывает
                     // подписку в статусе: monitoredTGs остаётся пустым).
                     sendTcp(socket, MsgBuilder.nodeInfo(CLIENT_SW_INFO, CLIENT_SW_VERSION))
+                    val monitor = s.monitorTgs
+                    if (monitor.isNullOrEmpty()) {
                         sendTcp(socket, MsgBuilder.selectTg(s.talkGroup))
                         sendTcp(socket, MsgBuilder.tgMonitor(listOf(s.talkGroup)))
+                    } else {
+                        sendTcp(socket, MsgBuilder.selectTg(monitor.first()))
+                        sendTcp(socket, MsgBuilder.tgMonitor(monitor))
+                    }
                     openUdp(s)
                 }
 
@@ -388,6 +414,7 @@ class ReflectorClient(
 
                 ReflectorProtocol.MSG_ERROR -> {
                     val err = MsgParser.errorMessage(msg.fields)
+                    Log.w(TAG, "MSG_ERROR: $err")
                     if (state < STATE_READY) {
                         stopFatal(err.ifEmpty { "Access denied" })
                         return false
@@ -447,6 +474,7 @@ class ReflectorClient(
             stopUdp()
             val ds = DatagramSocket()
             udpSocket = ds
+            Log.d(TAG, "UDP bound port=${ds.localPort}")
             // Первый пакет регистрирует наш UDP-адрес у сервера
             val addr = resolvedAddr ?: InetAddress.getByName(s.host)
             sendRawUdp(ds, addr, s.port, MsgBuilder.udpHeartbeat(clientId, nextSeq()))
@@ -490,7 +518,7 @@ class ReflectorClient(
         val seq = r.u16()
         val payload = data.copyOfRange(6, data.size)
         when (type) {
-            ReflectorProtocol.MSG_UDP_HEARTBEAT -> Unit
+            ReflectorProtocol.MSG_UDP_HEARTBEAT -> Log.d(TAG, "UDP RX heartbeat")
             ReflectorProtocol.MSG_UDP_AUDIO -> {
                 val audio = MsgParser.udpAudio(payload)
                 if (audio != null && audio.isNotEmpty()) {
@@ -504,7 +532,7 @@ class ReflectorClient(
                 Log.d(TAG, "UDP RX flush")
                 callbacks.onAudioFlush()
             }
-            ReflectorProtocol.MSG_UDP_ALL_SAMPLES_FLUSHED -> Unit
+            ReflectorProtocol.MSG_UDP_ALL_SAMPLES_FLUSHED -> Log.d(TAG, "UDP RX all-flushed seq=$seq")
             else -> Log.d(TAG, "UDP RX type=$type len=${data.size}")
         }
     }
@@ -528,10 +556,16 @@ class ReflectorClient(
     }
 
     private fun sendRawUdp(sock: DatagramSocket, addr: InetAddress, port: Int, data: ByteArray) {
-        if (sock.isClosed) return
+        if (sock.isClosed) {
+            Log.w(TAG, "UDP TX skipped: socket closed")
+            return
+        }
         try {
             sock.send(DatagramPacket(data, data.size, addr, port))
+            val typ = if (data.size >= 2) ((data[0].toInt() shl 8) or (data[1].toInt() and 0xFF)) else -1
+            Log.d(TAG, "UDP TX type=$typ len=${data.size}")
         } catch (e: Exception) {
+            Log.e(TAG, "UDP send error: ${e.message}", e)
             callbacks.onError("UDP send: ${e.message}")
         }
     }

app/src/main/res/drawable/bg_monitor_on.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="oval">
+    <solid android:color="#3358A6FF" />
+</shape>

app/src/main/res/drawable/ic_headset.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#8B949E"
+        android:pathData="M12,1c-4.97,0 -9,4.03 -9,9v7c0,1.66 1.34,3 3,3h3v-8L5,12v-2c0,-3.87 3.13,-7 7,-7s7,3.13 7,7v2h-4v8h3c1.66,0 3,-1.34 3,-3v-7c0,-4.97 -4.03,-9 -9,-9z" />
+</vector>

app/src/main/res/layout/activity_main.xml

@@ -84,6 +84,15 @@
                     android:ellipsize="end"
                     android:text="@string/settings_not_configured" />
 
+                <ImageButton
+                    android:id="@+id/btn_monitor"
+                    android:layout_width="44dp"
+                    android:layout_height="44dp"
+                    android:src="@drawable/ic_headset"
+                    android:background="?android:attr/selectableItemBackgroundBorderless"
+                    android:contentDescription="@string/btn_monitor"
+                    android:scaleType="centerInside" />
+
                 <TextView
                     android:id="@+id/lbl_tg"
                     android:layout_width="wrap_content"

app/src/main/res/values/strings.xml

@@ -27,6 +27,11 @@
     <string name="status_disconnected">Отключено</string>
     <string name="app_title">SVXHomyak</string>
     <string name="btn_power">Выключить: отключиться и закрыть</string>
+    <string name="btn_monitor">Мониторинг групп (нажмите, чтобы включить)</string>
+    <string name="btn_monitor_on">Мониторинг групп включен (нажмите, чтобы выключить)</string>
+    <string name="status_monitoring">Мониторинг: %1$s</string>
+    <string name="talker_mon">Говорит: %1$s · TG%2$d</string>
+    <string name="talker_mon_priority">ПРИОРИТЕТ: %1$s · TG%2$d</string>
     <string name="status_big_disconnected">DISCONNECTED</string>
     <string name="status_big_connected">CONNECTED</string>
     <string name="status_big_talking">ПЕРЕДАЧА</string>