Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.
Voice recorder: record on the phone, saved on the PC in your format
Beef287fb848a6b
diff --git a/README.md b/README.mdindex a818402..ecec1e6 100644--- a/README.md+++ b/README.md@@ -139,6 +139,14 @@ tests; there are no releases yet.following the phone's gyroscope or finger. Off by default on the PC, with aone-time prompt the first time a phone asks and a per-phone toggle inSettings.+- **Voice recorder**: record with the phone's microphone (with a live level+ meter, pause and resume, timestamped markers, and recording that keeps going+ when the screen turns off) and send it straight to the PC. On the PC it lands+ in the folder and format you choose (`Downloads\Nectarlink` and M4A by+ default, or MP3, WAV or FLAC converted on the PC), with a `.markers.txt`+ file beside it when you add markers and a notification to open the recording+ or its folder. If the PC is offline, the recording waits on the phone and+ goes out as soon as it reconnects.- **Media** both ways: what plays on the phone shows on the PC, in the app andin Windows' own media flyout (so the keyboard's media keys work too), andwhat plays on the PC shows in the phone's media controls, with artwork anddiff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xmlindex 2e29949..7038fd1 100644--- a/android/app/src/main/AndroidManifest.xml+++ b/android/app/src/main/AndroidManifest.xml@@ -16,8 +16,10 @@<uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE" /><!-- Sharing the screen with a PC (each time, after Android's prompt). --><uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />- <!-- The phone's sound while mirrored (playback capture, with the screen- share's consent). Never the microphone. -->+ <!-- Voice recorder to PC while the screen is off or the app is in the background. -->+ <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />+ <!-- Voice recordings for a PC (asked for on the Record screen) and the+ phone's sound while mirrored (playback capture, with the screen share's consent). --><uses-permission android:name="android.permission.RECORD_AUDIO" /><!-- Elevated: turning wireless debugging back on after a reboot or a newWi-Fi network. Not grantable to apps; Nectarlink grants it to itself@@ -224,6 +226,11 @@android:name=".mirror.AppWindows$CloseReceiver"android:exported="false" />+ <service+ android:name=".recorder.RecorderService"+ android:exported="false"+ android:foregroundServiceType="microphone" />+<serviceandroid:name=".service.ConnectionService"android:exported="false"diff --git a/android/app/src/main/kotlin/app/nectarlink/android/core/Core.kt b/android/app/src/main/kotlin/app/nectarlink/android/core/Core.ktindex f695ca0..e42df9a 100644--- a/android/app/src/main/kotlin/app/nectarlink/android/core/Core.kt+++ b/android/app/src/main/kotlin/app/nectarlink/android/core/Core.kt@@ -25,6 +25,9 @@ import app.nectarlink.android.mirror.AppWindowsimport app.nectarlink.android.mirror.InputServiceimport app.nectarlink.android.mirror.MirrorRequestsimport app.nectarlink.android.photos.RecentPhotos+import app.nectarlink.android.recorder.DeliveryState+import app.nectarlink.android.recorder.RecordingsStore+import app.nectarlink.android.recorder.SavedRecordingimport app.nectarlink.android.service.ConnectionServiceimport app.nectarlink.android.sms.PhoneSmsimport app.nectarlink.core.Event@@ -38,6 +41,7 @@ import app.nectarlink.core.NodeOptionsimport app.nectarlink.core.Notificationimport app.nectarlink.core.PairingFailureimport app.nectarlink.core.PowerLevel+import app.nectarlink.core.RecordingMarkerimport app.nectarlink.core.Transferimport app.nectarlink.core.TransferDirectionimport app.nectarlink.core.TransferStatus@@ -294,6 +298,9 @@ class Core(context: Context, private val scope: CoroutineScope) : EventListener}}+ /** Voice recordings stored on this phone and their delivery status to PCs. */+ val recordings = RecordingsStore(this.context)+override fun onEvent(event: Event) {_state.update { it.reduce(event) }when (event) {@@ -301,7 +308,13 @@ class Core(context: Context, private val scope: CoroutineScope) : EventListeneris Event.MediaChanged -> pcMedia.update(event.id, _state.value.nameOf(event.id).orEmpty(), event.players)// A PC that's gone isn't playing for this phone anymore; it// sends what plays when it's back.- is Event.LinkChanged -> if (event.link is Link.Offline) pcMedia.update(event.id, "", emptyList())+ is Event.LinkChanged -> {+ if (event.link is Link.Offline) {+ pcMedia.update(event.id, "", emptyList())+ } else if (event.link is Link.Online) {+ retryWaitingRecordings(event.id)+ }+ }is Event.DeviceAdded -> ConnectionService.start(context)is Event.DeviceRemoved -> {pcMedia.update(event.id, "", emptyList())@@ -312,10 +325,12 @@ class Core(context: Context, private val scope: CoroutineScope) : EventListener}}- // ---- Files ----+ // ---- Files & Recordings ----private fun onTransfer(transfer: Transfer) {val pc = _state.value.nameOf(transfer.deviceId).orEmpty()+ val pcOnline = _state.value.device(transfer.deviceId)?.online == true+ recordings.onTransferEvent(transfer, pcOnline)TransferNotifications.update(context, transfer, pc)val done = transfer.status as? TransferStatus.Done ?: returnif (transfer.direction != TransferDirection.INCOMING) return@@ -326,6 +341,92 @@ class Core(context: Context, private val scope: CoroutineScope) : EventListener}}+ /** Saves a finished voice recording and sends it to the chosen PC. */+ fun onRecordingFinished(+ pcId: String,+ file: java.io.File,+ durationMs: Long,+ markers: List<RecordingMarker>,+ ): SavedRecording {+ val online = _state.value.device(pcId)?.online == true+ val saved = recordings.add(+ file = file,+ durationMs = durationMs,+ markers = markers,+ targetPcId = pcId,+ waiting = !online,+ )+ sendSavedRecording(pcId, saved.id)+ return saved+ }++ /** Sends (or re-sends) a saved voice recording and its markers to `pcId`. */+ fun sendSavedRecording(pcId: String, recordingId: String) {+ val rec = recordings.get(recordingId) ?: return+ val file = recordings.fileFor(rec)+ if (!file.exists()) return+ val online = _state.value.device(pcId)?.online == true+ recordings.updateDelivery(+ id = recordingId,+ pcId = pcId,+ transferId = rec.transferId,+ delivery = if (online) DeliveryState.Sending else DeliveryState.Waiting,+ )+ scope.launch(Dispatchers.IO) {+ startJob?.join()+ val node = node ?: return@launch+ try {+ val tid = node.sendRecording(+ pcId,+ FileToSend.Path(+ path = file.absolutePath,+ name = file.name,+ folder = null,+ ),+ rec.markers,+ )+ val nowOnline = _state.value.device(pcId)?.online == true+ val existing = _state.value.transfers.firstOrNull { it.id == tid }+ val delivery = when (existing?.status) {+ is TransferStatus.Done -> DeliveryState.Sent+ is TransferStatus.Running -> DeliveryState.Sending+ is TransferStatus.Waiting -> DeliveryState.Waiting+ else -> if (nowOnline) DeliveryState.Sending else DeliveryState.Waiting+ }+ recordings.updateDelivery(+ id = recordingId,+ pcId = pcId,+ transferId = tid,+ delivery = delivery,+ )+ } catch (e: NectarlinkException) {+ val name = _state.value.nameOf(pcId).orEmpty()+ when (e) {+ is NectarlinkException.Denied -> {+ recordings.updateDelivery(recordingId, pcId, null, DeliveryState.Denied)+ _messages.tryEmit(context.getString(R.string.recorder_denied_text, name))+ }+ is NectarlinkException.Offline -> {+ recordings.updateDelivery(recordingId, pcId, null, DeliveryState.Waiting)+ }+ else -> {+ recordings.updateDelivery(recordingId, pcId, null, DeliveryState.Failed)+ _messages.tryEmit(describe(e))+ }+ }+ }+ }+ }++ private fun retryWaitingRecordings(pcId: String) {+ val activeIds = _state.value.transfers.filterNot { it.isFinished() }.map { it.id }.toSet()+ for (rec in recordings.waitingForPc(pcId)) {+ if (rec.transferId == null || rec.transferId !in activeIds) {+ sendSavedRecording(pcId, rec.id)+ }+ }+ }+/** Opens this phone's screen stream to a PC (after the user agreed). */suspend fun mirrorOpen(pcId: String): MirrorStream {startJob?.join()diff --git a/android/app/src/main/kotlin/app/nectarlink/android/recorder/RecorderService.kt b/android/app/src/main/kotlin/app/nectarlink/android/recorder/RecorderService.ktnew file mode 100644index 0000000..740ba8d--- /dev/null+++ b/android/app/src/main/kotlin/app/nectarlink/android/recorder/RecorderService.kt@@ -0,0 +1,437 @@+// SPDX-License-Identifier: GPL-3.0-or-later+package app.nectarlink.android.recorder++import android.Manifest+import android.annotation.SuppressLint+import android.app.Notification+import android.app.NotificationChannel+import android.app.NotificationManager+import android.app.PendingIntent+import android.app.Service+import android.content.Context+import android.content.Intent+import android.content.pm.PackageManager+import android.content.pm.ServiceInfo+import android.media.AudioFormat+import android.media.AudioRecord+import android.media.MediaCodec+import android.media.MediaCodecInfo+import android.media.MediaFormat+import android.media.MediaMuxer+import android.media.MediaRecorder+import android.os.Build+import android.os.IBinder+import android.util.Log+import androidx.core.app.NotificationCompat+import androidx.core.app.ServiceCompat+import androidx.core.content.ContextCompat+import app.nectarlink.android.NectarlinkApplication+import app.nectarlink.android.R+import app.nectarlink.android.ui.MainActivity+import app.nectarlink.core.RecordingMarker+import kotlinx.coroutines.CoroutineScope+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.Job+import kotlinx.coroutines.SupervisorJob+import kotlinx.coroutines.cancel+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.StateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.flow.update+import kotlinx.coroutines.launch+import java.io.File+import java.nio.ByteBuffer+import java.nio.ByteOrder+import kotlin.math.sqrt++data class RecorderSession(+ val active: Boolean = false,+ val paused: Boolean = false,+ val pcId: String? = null,+ val elapsedMs: Long = 0L,+ val level: Float = 0f,+ val markers: List<RecordingMarker> = emptyList(),+ val lastSavedId: String? = null,+)++/**+ * Records voice in 48 kHz mono AAC (`.m4a`) in a foreground service of type+ * `microphone` so recording continues with the screen off or while the user+ * switches apps, and sends the finished recording to the chosen PC on stop.+ */+class RecorderService : Service() {+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)+ private var encodeJob: Job? = null++ @Volatile+ private var running = false++ @Volatile+ private var paused = false++ override fun onBind(intent: Intent?): IBinder? = null++ override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {+ when (intent?.action) {+ ACTION_START -> {+ val pcId = intent.getStringExtra(EXTRA_PC)+ if (!running && pcId != null) {+ startRecordingSession(pcId)+ }+ }+ ACTION_PAUSE -> if (running && !paused) {+ paused = true+ _session.update { it.copy(paused = true, level = 0f) }+ updateNotification()+ }+ ACTION_RESUME -> if (running && paused) {+ paused = false+ _session.update { it.copy(paused = false) }+ updateNotification()+ }+ ACTION_STOP -> if (running) {+ running = false+ } else {+ stopSelf()+ }+ }+ return START_NOT_STICKY+ }++ private fun startRecordingSession(pcId: String) {+ if (!hasPermission(this)) {+ stopSelf()+ return+ }+ createChannel(this)+ running = true+ paused = false+ _session.value = RecorderSession(+ active = true,+ paused = false,+ pcId = pcId,+ elapsedMs = 0L,+ level = 0f,+ markers = emptyList(),+ lastSavedId = _session.value.lastSavedId,+ )+ val type = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {+ ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE+ } else {+ 0+ }+ ServiceCompat.startForeground(this, NOTIFICATION_ID, buildNotification(pcId, paused = false, elapsedMs = 0L), type)++ val app = application as NectarlinkApplication+ val outFile = app.core.recordings.newRecordingFile()+ encodeJob = scope.launch(Dispatchers.IO) {+ val durationMs = recordM4a(outFile, pcId)+ val finalMarkers = _session.value.markers+ val savedId = if (outFile.exists() && outFile.length() > 0L) {+ app.core.onRecordingFinished(pcId, outFile, durationMs, finalMarkers).id+ } else {+ null+ }+ _session.value = RecorderSession(+ active = false,+ paused = false,+ pcId = pcId,+ elapsedMs = 0L,+ level = 0f,+ markers = emptyList(),+ lastSavedId = savedId,+ )+ ServiceCompat.stopForeground(this@RecorderService, ServiceCompat.STOP_FOREGROUND_REMOVE)+ stopSelf()+ }+ }++ @SuppressLint("MissingPermission")+ private fun recordM4a(outFile: File, pcId: String): Long {+ val minBuf = AudioRecord.getMinBufferSize(+ SAMPLE_RATE,+ AudioFormat.CHANNEL_IN_MONO,+ AudioFormat.ENCODING_PCM_16BIT,+ ).coerceAtLeast(FRAME_SAMPLES * 2 * 4)++ val audioRecord = runCatching {+ AudioRecord(+ MediaRecorder.AudioSource.MIC,+ SAMPLE_RATE,+ AudioFormat.CHANNEL_IN_MONO,+ AudioFormat.ENCODING_PCM_16BIT,+ minBuf,+ )+ }.getOrNull()++ val codec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC)+ val format = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC, SAMPLE_RATE, CHANNELS).apply {+ setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC)+ setInteger(MediaFormat.KEY_BIT_RATE, BIT_RATE)+ setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 16_384)+ }+ codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)+ codec.start()++ outFile.parentFile?.mkdirs()+ val muxer = MediaMuxer(outFile.absolutePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)+ var trackIndex = -1+ var muxerStarted = false+ val bufferInfo = MediaCodec.BufferInfo()++ val pcmShorts = ShortArray(FRAME_SAMPLES)+ var totalSamples = 0L+ var lastNotifSec = -1L++ fun drainEncoder(endOfStream: Boolean) {+ if (endOfStream) {+ val inIdx = codec.dequeueInputBuffer(10_000L)+ if (inIdx >= 0) {+ val ptsUs = (totalSamples * 1_000_000L) / SAMPLE_RATE+ codec.queueInputBuffer(inIdx, 0, 0, ptsUs, MediaCodec.BUFFER_FLAG_END_OF_STREAM)+ }+ }+ while (true) {+ val outIdx = codec.dequeueOutputBuffer(bufferInfo, if (endOfStream) 10_000L else 0L)+ when {+ outIdx == MediaCodec.INFO_TRY_AGAIN_LATER -> break+ outIdx == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {+ if (!muxerStarted) {+ trackIndex = muxer.addTrack(codec.outputFormat)+ muxer.start()+ muxerStarted = true+ }+ }+ outIdx >= 0 -> {+ val encoded = codec.getOutputBuffer(outIdx)+ if (bufferInfo.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG != 0) {+ bufferInfo.size = 0+ }+ if (bufferInfo.size > 0 && muxerStarted && encoded != null) {+ encoded.position(bufferInfo.offset)+ encoded.limit(bufferInfo.offset + bufferInfo.size)+ muxer.writeSampleData(trackIndex, encoded, bufferInfo)+ }+ codec.releaseOutputBuffer(outIdx, false)+ if (bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0) break+ }+ }+ }+ }++ try {+ if (audioRecord?.state == AudioRecord.STATE_INITIALIZED) {+ runCatching { audioRecord.startRecording() }+ }+ while (running || totalSamples < SAMPLE_RATE / 4) {+ if (paused && running) {+ Thread.sleep(30L)+ continue+ }+ val read = if (audioRecord?.recordingState == AudioRecord.RECORDSTATE_RECORDING) {+ audioRecord.read(pcmShorts, 0, FRAME_SAMPLES)+ } else {+ Thread.sleep(20L)+ pcmShorts.fill(0)+ FRAME_SAMPLES+ }+ val count = if (read > 0) read else {+ Thread.sleep(20L)+ pcmShorts.fill(0)+ FRAME_SAMPLES+ }++ // Compute RMS level for the live meter and add 1-LSB dither so silent virtual mics still mux cleanly.+ var sumSq = 0.0+ for (i in 0 until count) {+ val s = pcmShorts[i].toInt()+ sumSq += (s * s).toDouble()+ if (s == 0 && (i and 1) == 0) {+ pcmShorts[i] = 1+ }+ }+ val rms = sqrt(sumSq / count.coerceAtLeast(1)) / 32768.0+ val meter = (rms * 4.5).toFloat().coerceIn(0f, 1f)++ val inIdx = codec.dequeueInputBuffer(10_000L)+ if (inIdx >= 0) {+ val inBuf: ByteBuffer? = codec.getInputBuffer(inIdx)+ if (inBuf != null) {+ inBuf.clear()+ inBuf.order(ByteOrder.nativeOrder())+ val shortBuf = inBuf.asShortBuffer()+ shortBuf.put(pcmShorts, 0, count)+ val ptsUs = (totalSamples * 1_000_000L) / SAMPLE_RATE+ codec.queueInputBuffer(inIdx, 0, count * 2, ptsUs, 0)+ }+ }+ totalSamples += count+ val elapsedMs = (totalSamples * 1_000L) / SAMPLE_RATE+ _session.update { it.copy(elapsedMs = elapsedMs, level = meter) }++ val sec = elapsedMs / 1_000L+ if (sec != lastNotifSec) {+ lastNotifSec = sec+ val nm = getSystemService(NotificationManager::class.java)+ nm?.notify(NOTIFICATION_ID, buildNotification(pcId, paused = paused, elapsedMs = elapsedMs))+ }++ drainEncoder(endOfStream = false)+ }+ drainEncoder(endOfStream = true)+ } catch (e: Exception) {+ Log.w(TAG, "recording interrupted", e)+ } finally {+ runCatching {+ if (audioRecord?.recordingState == AudioRecord.RECORDSTATE_RECORDING) {+ audioRecord.stop()+ }+ audioRecord?.release()+ }+ runCatching {+ codec.stop()+ codec.release()+ }+ runCatching {+ if (muxerStarted) muxer.stop()+ muxer.release()+ }+ }+ return (totalSamples * 1_000L) / SAMPLE_RATE+ }++ private fun updateNotification() {+ val s = _session.value+ val pcId = s.pcId ?: return+ val nm = getSystemService(NotificationManager::class.java)+ nm?.notify(NOTIFICATION_ID, buildNotification(pcId, s.paused, s.elapsedMs))+ }++ private fun buildNotification(pcId: String, paused: Boolean, elapsedMs: Long): Notification {+ val core = (application as NectarlinkApplication).core+ val pcName = core.state.value.nameOf(pcId).orEmpty().ifEmpty { getString(R.string.your_pc) }++ val openIntent = Intent(this, MainActivity::class.java).apply {+ putExtra("record_pc", pcId)+ flags = Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP+ }+ val openPending = PendingIntent.getActivity(+ this,+ 1,+ openIntent,+ PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,+ )++ val toggleAction = if (paused) ACTION_RESUME else ACTION_PAUSE+ val toggleLabel = getString(if (paused) R.string.recorder_resume else R.string.recorder_pause)+ val togglePending = PendingIntent.getService(+ this,+ 2,+ Intent(this, RecorderService::class.java).setAction(toggleAction),+ PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,+ )++ val stopPending = PendingIntent.getService(+ this,+ 3,+ Intent(this, RecorderService::class.java).setAction(ACTION_STOP),+ PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,+ )++ val title = if (paused) {+ getString(R.string.recorder_notification_paused, pcName)+ } else {+ getString(R.string.recorder_notification_recording, pcName)+ }++ return NotificationCompat.Builder(this, CHANNEL)+ .setSmallIcon(R.drawable.ic_notification)+ .setContentTitle(title)+ .setContentText(formatDuration(elapsedMs))+ .setContentIntent(openPending)+ .setOngoing(true)+ .setSilent(true)+ .setOnlyAlertOnce(true)+ .setCategory(NotificationCompat.CATEGORY_SERVICE)+ .addAction(0, toggleLabel, togglePending)+ .addAction(0, getString(R.string.action_stop), stopPending)+ .build()+ }++ override fun onDestroy() {+ running = false+ encodeJob?.cancel()+ scope.cancel()+ super.onDestroy()+ }++ companion object {+ private const val TAG = "RecorderService"+ private const val CHANNEL = "recorder"+ private const val NOTIFICATION_ID = 7+ private const val SAMPLE_RATE = 48_000+ private const val CHANNELS = 1+ private const val BIT_RATE = 128_000+ private const val FRAME_SAMPLES = 1024++ private const val ACTION_START = "app.nectarlink.android.recorder.START"+ private const val ACTION_PAUSE = "app.nectarlink.android.recorder.PAUSE"+ private const val ACTION_RESUME = "app.nectarlink.android.recorder.RESUME"+ private const val ACTION_STOP = "app.nectarlink.android.recorder.STOP"+ private const val EXTRA_PC = "pc"++ private val _session = MutableStateFlow(RecorderSession())+ val session: StateFlow<RecorderSession> = _session.asStateFlow()++ fun hasPermission(context: Context): Boolean =+ ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO) ==+ PackageManager.PERMISSION_GRANTED++ fun start(context: Context, pcId: String) {+ val intent = Intent(context, RecorderService::class.java)+ .setAction(ACTION_START)+ .putExtra(EXTRA_PC, pcId)+ ContextCompat.startForegroundService(context, intent)+ }++ fun pause(context: Context) {+ context.startService(Intent(context, RecorderService::class.java).setAction(ACTION_PAUSE))+ }++ fun resume(context: Context) {+ context.startService(Intent(context, RecorderService::class.java).setAction(ACTION_RESUME))+ }++ fun stop(context: Context) {+ context.startService(Intent(context, RecorderService::class.java).setAction(ACTION_STOP))+ }++ fun addMarker(label: String? = null) {+ _session.update { s ->+ if (!s.active) return@update s+ val cleaned = label?.trim()?.take(80)?.ifEmpty { null }+ val marker = RecordingMarker(atMs = s.elapsedMs.coerceAtLeast(0L).toULong(), label = cleaned)+ s.copy(markers = s.markers + marker)+ }+ }++ fun formatDuration(ms: Long): String {+ val totalSecs = (ms.coerceAtLeast(0L)) / 1_000L+ val mins = totalSecs / 60L+ val secs = totalSecs % 60L+ return String.format(java.util.Locale.US, "%02d:%02d", mins, secs)+ }++ private fun createChannel(context: Context) {+ val nm = context.getSystemService(NotificationManager::class.java) ?: return+ val channel = NotificationChannel(+ CHANNEL,+ context.getString(R.string.channel_recorder),+ NotificationManager.IMPORTANCE_LOW,+ ).apply {+ setShowBadge(false)+ }+ nm.createNotificationChannel(channel)+ }+ }+}diff --git a/android/app/src/main/kotlin/app/nectarlink/android/recorder/RecordingsStore.kt b/android/app/src/main/kotlin/app/nectarlink/android/recorder/RecordingsStore.ktnew file mode 100644index 0000000..4009fce--- /dev/null+++ b/android/app/src/main/kotlin/app/nectarlink/android/recorder/RecordingsStore.kt@@ -0,0 +1,247 @@+// SPDX-License-Identifier: GPL-3.0-or-later+package app.nectarlink.android.recorder++import android.content.Context+import app.nectarlink.core.RecordingMarker+import app.nectarlink.core.Transfer+import app.nectarlink.core.TransferStatus+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.StateFlow+import kotlinx.coroutines.flow.asStateFlow+import org.json.JSONArray+import org.json.JSONObject+import java.io.File+import java.text.SimpleDateFormat+import java.util.Date+import java.util.Locale++enum class DeliveryState {+ Idle,+ Waiting,+ Sending,+ Sent,+ Denied,+ Failed,+}++data class SavedRecording(+ val id: String,+ val fileName: String,+ val createdAtMs: Long,+ val durationMs: Long,+ val sizeBytes: Long,+ val markers: List<RecordingMarker>,+ val targetPcId: String?,+ val transferId: String? = null,+ val delivery: DeliveryState = DeliveryState.Idle,+) {+ fun file(dir: File): File = dir.resolve(fileName)+}++/**+ * Keeps voice recordings in `filesDir/recordings` with their markers and+ * delivery status to the chosen PC.+ */+class RecordingsStore(context: Context) {+ private val dir: File = context.applicationContext.filesDir.resolve("recordings").apply { mkdirs() }+ private val indexFile: File = dir.resolve("recordings.json")+ private val lock = Any()+ private val _recordings = MutableStateFlow<List<SavedRecording>>(emptyList())+ val recordings: StateFlow<List<SavedRecording>> = _recordings.asStateFlow()++ init {+ synchronized(lock) {+ _recordings.value = loadLocked()+ }+ }++ fun directory(): File = dir++ /** Picks a unique `Recording YYYY-MM-DD HH.mm.m4a` (or `(2)`, etc.) in `filesDir/recordings`. */+ fun newRecordingFile(nowMs: Long = System.currentTimeMillis()): File {+ synchronized(lock) {+ dir.mkdirs()+ val stem = "Recording " + SimpleDateFormat("yyyy-MM-dd HH.mm", Locale.US).format(Date(nowMs))+ val first = dir.resolve("$stem.m4a")+ if (!first.exists()) return first+ var n = 2+ while (true) {+ val candidate = dir.resolve("$stem ($n).m4a")+ if (!candidate.exists()) return candidate+ n+++ }+ }+ }++ fun get(id: String): SavedRecording? = _recordings.value.firstOrNull { it.id == id }++ fun fileFor(recording: SavedRecording): File = recording.file(dir)++ fun add(+ file: File,+ durationMs: Long,+ markers: List<RecordingMarker>,+ targetPcId: String?,+ waiting: Boolean,+ ): SavedRecording {+ synchronized(lock) {+ val rec = SavedRecording(+ id = "rec-${System.currentTimeMillis()}-${file.name.hashCode().toUInt()}",+ fileName = file.name,+ createdAtMs = System.currentTimeMillis(),+ durationMs = durationMs.coerceAtLeast(0L),+ sizeBytes = file.length().coerceAtLeast(0L),+ markers = markers,+ targetPcId = targetPcId,+ transferId = null,+ delivery = when {+ targetPcId == null -> DeliveryState.Idle+ waiting -> DeliveryState.Waiting+ else -> DeliveryState.Sending+ },+ )+ val updated = listOf(rec) + _recordings.value.filterNot { it.fileName == file.name }+ saveLocked(updated)+ _recordings.value = updated+ return rec+ }+ }++ fun delete(id: String) {+ synchronized(lock) {+ val target = _recordings.value.firstOrNull { it.id == id }+ if (target != null) {+ runCatching { target.file(dir).delete() }+ }+ val updated = _recordings.value.filterNot { it.id == id }+ saveLocked(updated)+ _recordings.value = updated+ }+ }++ fun updateDelivery(+ id: String,+ pcId: String?,+ transferId: String?,+ delivery: DeliveryState,+ ) {+ synchronized(lock) {+ val updated = _recordings.value.map { rec ->+ if (rec.id == id) {+ rec.copy(targetPcId = pcId, transferId = transferId, delivery = delivery)+ } else {+ rec+ }+ }+ saveLocked(updated)+ _recordings.value = updated+ }+ }++ fun onTransferEvent(transfer: Transfer, pcOnline: Boolean) {+ synchronized(lock) {+ val current = _recordings.value+ if (current.none { it.transferId == transfer.id }) return+ val updated = current.map { rec ->+ if (rec.transferId != transfer.id) return@map rec+ val nextDelivery = when (val status = transfer.status) {+ is TransferStatus.Waiting -> DeliveryState.Waiting+ is TransferStatus.Running -> DeliveryState.Sending+ is TransferStatus.Done -> DeliveryState.Sent+ is TransferStatus.Cancelled -> DeliveryState.Idle+ is TransferStatus.Failed -> when (status.reason) {+ "denied" -> DeliveryState.Denied+ "unreachable" -> if (!pcOnline) DeliveryState.Waiting else DeliveryState.Failed+ else -> if (!pcOnline) DeliveryState.Waiting else DeliveryState.Failed+ }+ }+ rec.copy(delivery = nextDelivery)+ }+ saveLocked(updated)+ _recordings.value = updated+ }+ }++ /** Recordings queued for `pcId` while it was offline. */+ fun waitingForPc(pcId: String): List<SavedRecording> =+ _recordings.value.filter { it.targetPcId == pcId && it.delivery == DeliveryState.Waiting }++ private fun loadLocked(): List<SavedRecording> {+ if (!indexFile.exists()) return emptyList()+ return runCatching {+ val arr = JSONArray(indexFile.readText())+ buildList {+ for (i in 0 until arr.length()) {+ val obj = arr.optJSONObject(i) ?: continue+ val fileName = obj.optString("fileName", "")+ if (fileName.isEmpty()) continue+ val file = dir.resolve(fileName)+ if (!file.exists()) continue+ val markersArr = obj.optJSONArray("markers") ?: JSONArray()+ val markers = buildList {+ for (j in 0 until markersArr.length()) {+ val m = markersArr.optJSONObject(j) ?: continue+ val atMs = m.optLong("atMs", -1L)+ if (atMs < 0L) continue+ val label = m.optString("label", "").trim().ifEmpty { null }+ add(RecordingMarker(atMs = atMs.toULong(), label = label))+ }+ }+ val delivery = runCatching {+ DeliveryState.valueOf(obj.optString("delivery", DeliveryState.Idle.name))+ }.getOrDefault(DeliveryState.Idle)+ add(+ SavedRecording(+ id = obj.optString("id", "rec-$i"),+ fileName = fileName,+ createdAtMs = obj.optLong("createdAtMs", file.lastModified()),+ durationMs = obj.optLong("durationMs", 0L),+ sizeBytes = file.length(),+ markers = markers,+ targetPcId = obj.optString("targetPcId", "").ifEmpty { null },+ transferId = obj.optString("transferId", "").ifEmpty { null },+ delivery = delivery,+ ),+ )+ }+ }+ }.getOrDefault(emptyList())+ }++ private fun saveLocked(items: List<SavedRecording>) {+ runCatching {+ dir.mkdirs()+ val arr = JSONArray()+ for (rec in items) {+ val markersArr = JSONArray()+ for (m in rec.markers) {+ markersArr.put(+ JSONObject().apply {+ put("atMs", m.atMs.toLong())+ if (m.label != null) put("label", m.label)+ },+ )+ }+ arr.put(+ JSONObject().apply {+ put("id", rec.id)+ put("fileName", rec.fileName)+ put("createdAtMs", rec.createdAtMs)+ put("durationMs", rec.durationMs)+ put("sizeBytes", rec.sizeBytes)+ put("markers", markersArr)+ if (rec.targetPcId != null) put("targetPcId", rec.targetPcId)+ if (rec.transferId != null) put("transferId", rec.transferId)+ put("delivery", rec.delivery.name)+ },+ )+ }+ val tmp = dir.resolve("recordings.json.tmp")+ tmp.writeText(arr.toString())+ if (!tmp.renameTo(indexFile)) {+ indexFile.writeText(arr.toString())+ tmp.delete()+ }+ }+ }+}diff --git a/android/app/src/main/kotlin/app/nectarlink/android/ui/MainActivity.kt b/android/app/src/main/kotlin/app/nectarlink/android/ui/MainActivity.ktindex 5ce4a15..663e9c2 100644--- a/android/app/src/main/kotlin/app/nectarlink/android/ui/MainActivity.kt+++ b/android/app/src/main/kotlin/app/nectarlink/android/ui/MainActivity.kt@@ -50,6 +50,7 @@ import app.nectarlink.android.ui.pairing.PairingActionsimport android.view.KeyEventimport app.nectarlink.android.core.LocalNetworkimport app.nectarlink.android.ui.pairing.PairingScreen+import app.nectarlink.android.ui.recorder.RecorderScreenimport app.nectarlink.android.ui.remote.RemoteModeimport app.nectarlink.android.ui.remote.RemoteScreenimport app.nectarlink.android.ui.settings.SettingsScreen@@ -60,6 +61,7 @@ class MainActivity : ComponentActivity() {private var activeRemotePcId: String? = nullprivate var requestedRemotePc by mutableStateOf<String?>(null)private var requestedRemoteMode by mutableStateOf(RemoteMode.Touchpad)+ private var requestedRecordPc by mutableStateOf<String?>(null)private val permissions =registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) {@@ -83,6 +85,7 @@ class MainActivity : ComponentActivity() {if (savedInstanceState == null) {handlePairingLink(intent)handleRemoteIntent(intent)+ handleRecordIntent(intent)}setContent {@@ -107,6 +110,8 @@ class MainActivity : ComponentActivity() {requestedRemotePc = requestedRemotePc,requestedRemoteMode = requestedRemoteMode,onRemoteConsumed = { requestedRemotePc = null },+ requestedRecordPc = requestedRecordPc,+ onRecordConsumed = { requestedRecordPc = null },onActiveRemoteChanged = { activeRemotePcId = it },)}@@ -126,6 +131,7 @@ class MainActivity : ComponentActivity() {super.onNewIntent(intent)handlePairingLink(intent)handleRemoteIntent(intent)+ handleRecordIntent(intent)}override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {@@ -169,6 +175,11 @@ class MainActivity : ComponentActivity() {requestedRemotePc = pc}+ private fun handleRecordIntent(intent: Intent?) {+ val pc = intent?.getStringExtra("record_pc") ?: return+ requestedRecordPc = pc+ }+/*** A PC's pairing QR code opened from another app (e.g. the camera).* Each link holds a one-time secret, so a link is used once: Android@@ -194,12 +205,15 @@ private fun App(requestedRemotePc: String?,requestedRemoteMode: RemoteMode,onRemoteConsumed: () -> Unit,+ requestedRecordPc: String?,+ onRecordConsumed: () -> Unit,onActiveRemoteChanged: (String?) -> Unit,) {var tab by rememberSaveable { mutableStateOf(Tab.Home) }var pairing by rememberSaveable { mutableStateOf(false) }var remotePcId by rememberSaveable { mutableStateOf<String?>(null) }var remoteInitialMode by rememberSaveable { mutableStateOf(RemoteMode.Touchpad) }+ var recordPcId by rememberSaveable { mutableStateOf<String?>(null) }val snackbar = remember { SnackbarHostState() }LaunchedEffect(Unit) { core.messages.collect { snackbar.showSnackbar(it) } }@@ -207,13 +221,25 @@ private fun App(val req = requestedRemotePc ?: return@LaunchedEffectval target = if (req == "first") state.devices.firstOrNull()?.id else state.device(req)?.idif (target != null) {+ recordPcId = nullremoteInitialMode = requestedRemoteModeremotePcId = targetonRemoteConsumed()}}+ LaunchedEffect(requestedRecordPc, state.devices) {+ val req = requestedRecordPc ?: return@LaunchedEffect+ val target = if (req == "first") state.devices.firstOrNull()?.id else state.device(req)?.id+ if (target != null) {+ remotePcId = null+ recordPcId = target+ onRecordConsumed()+ }+ }+val remoteDevice = remotePcId?.let { state.device(it) }+ val recordDevice = recordPcId?.let { state.device(it) }LaunchedEffect(remoteDevice?.id) {onActiveRemoteChanged(remoteDevice?.id)}@@ -239,6 +265,20 @@ private fun App(BackHandler(enabled = pairing && state.devices.isNotEmpty()) { core.resetPairing(); pairing = false }PairingScreen(state, actions, cancellable = state.devices.isNotEmpty()) { pairing = false }}+ recordDevice != null -> {+ BackHandler { recordPcId = null }+ Scaffold(+ snackbarHost = { SnackbarHost(snackbar) },+ ) { padding ->+ RecorderScreen(+ device = recordDevice,+ state = state,+ core = core,+ onBack = { recordPcId = null },+ modifier = Modifier.fillMaxSize().padding(padding),+ )+ }+ }remoteDevice != null -> {BackHandler { remotePcId = null }val sensitivity by preferences.touchpadSensitivity.collectAsStateWithLifecycle()@@ -287,6 +327,9 @@ private fun App(remoteInitialMode = RemoteMode.TouchpadremotePcId = id},+ onRecord = { id ->+ recordPcId = id+ },updater = (LocalContext.current.applicationContext as NectarlinkApplication).updater,onSendFiles = core::sendFiles,onSendFolder = core::sendFolder,diff --git a/android/app/src/main/kotlin/app/nectarlink/android/ui/home/HomeScreen.kt b/android/app/src/main/kotlin/app/nectarlink/android/ui/home/HomeScreen.ktindex e8aaf93..8868136 100644--- a/android/app/src/main/kotlin/app/nectarlink/android/ui/home/HomeScreen.kt+++ b/android/app/src/main/kotlin/app/nectarlink/android/ui/home/HomeScreen.kt@@ -82,6 +82,7 @@ fun HomeScreen(onRefresh: () -> Unit,onPower: (pcId: String, sleep: Boolean) -> Unit,onRemote: (pcId: String) -> Unit,+ onRecord: (pcId: String) -> Unit,updater: AppUpdater,onSendFiles: (pcId: String, uris: List<Uri>) -> Unit,onSendFolder: (pcId: String, tree: Uri) -> Unit,@@ -197,7 +198,9 @@ fun HomeScreen() { askPhotos.launch(RecentPhotos.permissions) }}}- items(state.devices, key = { it.id }) { device -> PcCard(device, onRing, onSendFiles, onSendFolder, onPower, onRemote) }+ items(state.devices, key = { it.id }) { device ->+ PcCard(device, onRing, onSendFiles, onSendFolder, onPower, onRemote, onRecord)+ }if (state.transfers.isNotEmpty()) {item { TransfersCard(state, onCancelTransfer) }}@@ -241,6 +244,7 @@ private fun PcCard(onSendFolder: (String, Uri) -> Unit,onPower: (String, Boolean) -> Unit,onRemote: (String) -> Unit,+ onRecord: (String) -> Unit,) {val pickFiles = rememberLauncherForActivityResult(ActivityResultContracts.OpenMultipleDocuments()) { uris ->if (uris.isNotEmpty()) onSendFiles(device.id, uris)@@ -315,6 +319,12 @@ private fun PcCard() {Text(stringResource(R.string.action_remote_pc))}+ FilledTonalButton(+ colors = tonal,+ onClick = { onRecord(device.id) },+ ) {+ Text(stringResource(R.string.action_record_pc))+ }FilledTonalButton(enabled = device.online,colors = tonal,diff --git a/android/app/src/main/kotlin/app/nectarlink/android/ui/recorder/RecorderScreen.kt b/android/app/src/main/kotlin/app/nectarlink/android/ui/recorder/RecorderScreen.ktnew file mode 100644index 0000000..433a012--- /dev/null+++ b/android/app/src/main/kotlin/app/nectarlink/android/ui/recorder/RecorderScreen.kt@@ -0,0 +1,520 @@+// SPDX-License-Identifier: GPL-3.0-or-later+package app.nectarlink.android.ui.recorder++import android.Manifest+import android.media.MediaPlayer+import android.text.format.Formatter+import androidx.activity.compose.rememberLauncherForActivityResult+import androidx.activity.result.contract.ActivityResultContracts+import androidx.compose.animation.core.animateFloatAsState+import androidx.compose.foundation.Canvas+import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Box+import androidx.compose.foundation.layout.Column+import androidx.compose.foundation.layout.ExperimentalLayoutApi+import androidx.compose.foundation.layout.FlowRow+import androidx.compose.foundation.layout.PaddingValues+import androidx.compose.foundation.layout.Row+import androidx.compose.foundation.layout.Spacer+import androidx.compose.foundation.layout.fillMaxSize+import androidx.compose.foundation.layout.fillMaxWidth+import androidx.compose.foundation.layout.height+import androidx.compose.foundation.layout.padding+import androidx.compose.foundation.layout.size+import androidx.compose.foundation.layout.width+import androidx.compose.foundation.lazy.LazyColumn+import androidx.compose.foundation.lazy.items+import androidx.compose.foundation.shape.CircleShape+import androidx.compose.foundation.text.KeyboardActions+import androidx.compose.foundation.text.KeyboardOptions+import androidx.compose.material3.AssistChip+import androidx.compose.material3.Button+import androidx.compose.material3.ButtonDefaults+import androidx.compose.material3.FilledTonalButton+import androidx.compose.material3.MaterialTheme+import androidx.compose.material3.OutlinedButton+import androidx.compose.material3.OutlinedTextField+import androidx.compose.material3.Surface+import androidx.compose.material3.Text+import androidx.compose.material3.TextButton+import androidx.compose.runtime.Composable+import androidx.compose.runtime.DisposableEffect+import androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf+import androidx.compose.runtime.remember+import androidx.compose.runtime.saveable.rememberSaveable+import androidx.compose.runtime.setValue+import androidx.compose.ui.Alignment+import androidx.compose.ui.Modifier+import androidx.compose.ui.geometry.CornerRadius+import androidx.compose.ui.geometry.Offset+import androidx.compose.ui.geometry.Size+import androidx.compose.ui.platform.LocalContext+import androidx.compose.ui.res.pluralStringResource+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.semantics.contentDescription+import androidx.compose.ui.semantics.semantics+import androidx.compose.ui.text.font.FontFamily+import androidx.compose.ui.text.input.ImeAction+import androidx.compose.ui.text.style.TextOverflow+import androidx.compose.ui.unit.dp+import androidx.lifecycle.compose.collectAsStateWithLifecycle+import app.nectarlink.android.R+import app.nectarlink.android.core.Core+import app.nectarlink.android.core.CoreState+import app.nectarlink.android.core.Device+import app.nectarlink.android.recorder.DeliveryState+import app.nectarlink.android.recorder.RecorderService+import app.nectarlink.android.recorder.SavedRecording+import kotlin.math.sin++@OptIn(ExperimentalLayoutApi::class)+@Composable+fun RecorderScreen(+ device: Device,+ state: CoreState,+ core: Core,+ onBack: () -> Unit,+ modifier: Modifier = Modifier,+) {+ val context = LocalContext.current+ val session by RecorderService.session.collectAsStateWithLifecycle()+ val recordings by core.recordings.recordings.collectAsStateWithLifecycle()++ var hasMicPermission by remember { mutableStateOf(RecorderService.hasPermission(context)) }+ var startAfterGrant by remember { mutableStateOf(false) }+ val askMic = rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->+ hasMicPermission = granted+ if (granted && startAfterGrant) {+ startAfterGrant = false+ RecorderService.start(context, device.id)+ } else {+ startAfterGrant = false+ }+ }++ var markerText by rememberSaveable { mutableStateOf("") }+ var playingId by remember { mutableStateOf<String?>(null) }+ val playerRef = remember { mutableStateOf<MediaPlayer?>(null) }++ fun stopPlayback() {+ playerRef.value?.let { mp ->+ runCatching { mp.stop() }+ runCatching { mp.release() }+ }+ playerRef.value = null+ playingId = null+ }++ fun togglePlayback(rec: SavedRecording) {+ if (playingId == rec.id) {+ stopPlayback()+ return+ }+ stopPlayback()+ val file = core.recordings.fileFor(rec)+ if (!file.exists()) return+ runCatching {+ val mp = MediaPlayer().apply {+ setDataSource(file.absolutePath)+ setOnCompletionListener {+ runCatching { release() }+ if (playerRef.value === this) {+ playerRef.value = null+ playingId = null+ }+ }+ prepare()+ start()+ }+ playerRef.value = mp+ playingId = rec.id+ }+ }++ DisposableEffect(Unit) {+ onDispose { stopPlayback() }+ }++ val animatedLevel by animateFloatAsState(+ targetValue = if (session.active && !session.paused) session.level else 0f,+ label = "micLevel",+ )++ LazyColumn(+ modifier = modifier.fillMaxSize(),+ contentPadding = PaddingValues(horizontal = 16.dp, vertical = 12.dp),+ verticalArrangement = Arrangement.spacedBy(16.dp),+ ) {+ // Header: Back, PC name, online dot+ item {+ Row(+ modifier = Modifier.fillMaxWidth(),+ verticalAlignment = Alignment.CenterVertically,+ ) {+ TextButton(+ onClick = onBack,+ contentPadding = PaddingValues(horizontal = 12.dp, vertical = 8.dp),+ ) {+ Text("← " + stringResource(R.string.action_back), style = MaterialTheme.typography.labelLarge)+ }+ Spacer(Modifier.width(4.dp))+ Text(+ device.name,+ style = MaterialTheme.typography.titleLarge,+ modifier = Modifier.weight(1f),+ )+ Surface(+ shape = CircleShape,+ color = if (device.online) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline,+ modifier = Modifier.size(10.dp),+ ) {}+ }+ }++ // Contextual permission card when microphone access has not been granted yet+ if (!hasMicPermission) {+ item {+ Surface(+ shape = MaterialTheme.shapes.extraLarge,+ color = MaterialTheme.colorScheme.secondaryContainer,+ ) {+ Column(Modifier.fillMaxWidth().padding(20.dp)) {+ Text(+ stringResource(R.string.recorder_permission_title),+ style = MaterialTheme.typography.titleMedium,+ color = MaterialTheme.colorScheme.onSecondaryContainer,+ )+ Spacer(Modifier.height(4.dp))+ Text(+ stringResource(R.string.recorder_permission_text, device.name),+ style = MaterialTheme.typography.bodyMedium,+ color = MaterialTheme.colorScheme.onSecondaryContainer,+ )+ Spacer(Modifier.height(12.dp))+ Button(+ onClick = {+ startAfterGrant = false+ askMic.launch(Manifest.permission.RECORD_AUDIO)+ },+ ) {+ Text(stringResource(R.string.recorder_allow_mic))+ }+ }+ }+ }+ }++ // Offline notice when PC isn't currently connected+ if (!device.online) {+ item {+ Surface(+ shape = MaterialTheme.shapes.large,+ color = MaterialTheme.colorScheme.surfaceContainerHigh,+ ) {+ Column(Modifier.fillMaxWidth().padding(16.dp)) {+ Text(+ stringResource(R.string.transfer_waiting, device.name),+ style = MaterialTheme.typography.titleSmall,+ )+ Spacer(Modifier.height(2.dp))+ Text(+ stringResource(R.string.recorder_offline_hint, device.name),+ style = MaterialTheme.typography.bodySmall,+ color = MaterialTheme.colorScheme.onSurfaceVariant,+ )+ }+ }+ }+ }++ // Main Recorder Card: elapsed time, live level meter, big record/pause/stop buttons, markers+ item {+ Surface(+ shape = MaterialTheme.shapes.extraLarge,+ color = MaterialTheme.colorScheme.primaryContainer,+ contentColor = MaterialTheme.colorScheme.onPrimaryContainer,+ ) {+ Column(+ modifier = Modifier.fillMaxWidth().padding(24.dp),+ horizontalAlignment = Alignment.CenterHorizontally,+ ) {+ Text(+ text = when {+ session.active && session.paused -> stringResource(R.string.recorder_status_paused)+ session.active -> stringResource(R.string.recorder_status_recording, device.name)+ else -> stringResource(R.string.recorder_status_ready, device.name)+ },+ style = MaterialTheme.typography.labelLarge,+ )+ Spacer(Modifier.height(12.dp))+ Text(+ text = RecorderService.formatDuration(session.elapsedMs),+ style = MaterialTheme.typography.displayLarge.copy(fontFamily = FontFamily.Monospace),+ )+ Spacer(Modifier.height(16.dp))++ // Live level meter+ LevelMeter(+ level = animatedLevel,+ active = session.active && !session.paused,+ modifier = Modifier+ .fillMaxWidth()+ .height(40.dp),+ )++ Spacer(Modifier.height(24.dp))++ if (!session.active) {+ val startDesc = stringResource(R.string.recorder_start)+ Button(+ onClick = {+ stopPlayback()+ if (RecorderService.hasPermission(context)) {+ hasMicPermission = true+ RecorderService.start(context, device.id)+ } else {+ startAfterGrant = true+ askMic.launch(Manifest.permission.RECORD_AUDIO)+ }+ },+ modifier = Modifier+ .height(64.dp)+ .fillMaxWidth(0.75f)+ .semantics { contentDescription = startDesc },+ shape = CircleShape,+ ) {+ Text(+ stringResource(R.string.recorder_start),+ style = MaterialTheme.typography.titleMedium,+ )+ }+ } else {+ Row(+ horizontalArrangement = Arrangement.spacedBy(12.dp),+ verticalAlignment = Alignment.CenterVertically,+ ) {+ val pauseResumeLabel = stringResource(+ if (session.paused) R.string.recorder_resume else R.string.recorder_pause,+ )+ FilledTonalButton(+ onClick = {+ if (session.paused) {+ RecorderService.resume(context)+ } else {+ RecorderService.pause(context)+ }+ },+ modifier = Modifier+ .height(56.dp)+ .weight(1f)+ .semantics { contentDescription = pauseResumeLabel },+ ) {+ Text(pauseResumeLabel, style = MaterialTheme.typography.titleMedium)+ }++ val stopLabel = stringResource(R.string.action_stop)+ Button(+ onClick = { RecorderService.stop(context) },+ colors = ButtonDefaults.buttonColors(+ containerColor = MaterialTheme.colorScheme.error,+ contentColor = MaterialTheme.colorScheme.onError,+ ),+ modifier = Modifier+ .height(56.dp)+ .weight(1f)+ .semantics { contentDescription = stopLabel },+ ) {+ Text(stopLabel, style = MaterialTheme.typography.titleMedium)+ }+ }++ Spacer(Modifier.height(16.dp))++ // Marker controls while recording+ Row(+ modifier = Modifier.fillMaxWidth(),+ horizontalArrangement = Arrangement.spacedBy(8.dp),+ verticalAlignment = Alignment.CenterVertically,+ ) {+ OutlinedTextField(+ value = markerText,+ onValueChange = { markerText = it },+ placeholder = { Text(stringResource(R.string.recorder_marker_hint)) },+ singleLine = true,+ keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),+ keyboardActions = KeyboardActions(+ onDone = {+ RecorderService.addMarker(markerText)+ markerText = ""+ },+ ),+ modifier = Modifier.weight(1f),+ )+ val addMarkerDesc = stringResource(R.string.recorder_add_marker)+ FilledTonalButton(+ onClick = {+ RecorderService.addMarker(markerText)+ markerText = ""+ },+ modifier = Modifier+ .height(52.dp)+ .semantics { contentDescription = addMarkerDesc },+ ) {+ Text(addMarkerDesc)+ }+ }++ if (session.markers.isNotEmpty()) {+ Spacer(Modifier.height(12.dp))+ FlowRow(+ modifier = Modifier.fillMaxWidth(),+ horizontalArrangement = Arrangement.spacedBy(8.dp),+ verticalArrangement = Arrangement.spacedBy(6.dp),+ ) {+ session.markers.forEachIndexed { idx, m ->+ val ts = RecorderService.formatDuration(m.atMs.toLong())+ val label = m.label ?: stringResource(R.string.recorder_marker_default, idx + 1)+ AssistChip(+ onClick = {},+ label = { Text("$ts · $label") },+ )+ }+ }+ }+ }+ }+ }+ }++ // Saved recordings list: play, send again, delete+ if (recordings.isNotEmpty()) {+ item {+ Text(+ stringResource(R.string.recorder_saved_title),+ style = MaterialTheme.typography.titleMedium,+ modifier = Modifier.padding(top = 4.dp),+ )+ }+ items(recordings, key = { it.id }) { rec ->+ RecordingRow(+ recording = rec,+ pcName = state.nameOf(rec.targetPcId ?: device.id) ?: device.name,+ playing = playingId == rec.id,+ onPlayToggle = { togglePlayback(rec) },+ onSend = { core.sendSavedRecording(device.id, rec.id) },+ onDelete = {+ if (playingId == rec.id) stopPlayback()+ core.recordings.delete(rec.id)+ },+ )+ }+ }+ }+}++@Composable+private fun LevelMeter(+ level: Float,+ active: Boolean,+ modifier: Modifier = Modifier,+) {+ val activeColor = MaterialTheme.colorScheme.primary+ val inactiveColor = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.2f)+ Canvas(modifier = modifier) {+ val barCount = 24+ val gap = 4.dp.toPx()+ val totalGaps = gap * (barCount - 1)+ val barWidth = ((size.width - totalGaps) / barCount).coerceAtLeast(2f)+ for (i in 0 until barCount) {+ val centerDist = kotlin.math.abs(i - (barCount - 1) / 2f) / (barCount / 2f)+ val envelope = (1f - centerDist * 0.55f)+ val wave = if (active) (0.18f + 0.82f * level * envelope + 0.06f * sin(i * 0.9f)).coerceIn(0.12f, 1f) else 0.12f+ val h = (size.height * wave).coerceAtLeast(4.dp.toPx())+ val x = i * (barWidth + gap)+ val y = (size.height - h) / 2f+ drawRoundRect(+ color = if (active && (i.toFloat() / barCount) <= (level * 1.25f + 0.15f)) activeColor else inactiveColor,+ topLeft = Offset(x, y),+ size = Size(barWidth, h),+ cornerRadius = CornerRadius(barWidth / 2f, barWidth / 2f),+ )+ }+ }+}++@Composable+private fun RecordingRow(+ recording: SavedRecording,+ pcName: String,+ playing: Boolean,+ onPlayToggle: () -> Unit,+ onSend: () -> Unit,+ onDelete: () -> Unit,+) {+ val context = LocalContext.current+ val title = recording.fileName.removeSuffix(".m4a")+ val durationText = RecorderService.formatDuration(recording.durationMs)+ val sizeText = Formatter.formatShortFileSize(context, recording.sizeBytes)+ val markersText = if (recording.markers.isEmpty()) {+ null+ } else {+ pluralStringResource(R.plurals.recorder_markers_count, recording.markers.size, recording.markers.size)+ }+ val statusText = when (recording.delivery) {+ DeliveryState.Waiting -> stringResource(R.string.transfer_waiting, pcName)+ DeliveryState.Sending -> stringResource(R.string.transfer_sending, pcName)+ DeliveryState.Sent -> stringResource(R.string.transfer_sent_to, pcName)+ DeliveryState.Denied -> stringResource(R.string.recorder_denied_text, pcName)+ DeliveryState.Failed -> stringResource(R.string.transfer_failed)+ DeliveryState.Idle -> null+ }++ Surface(+ shape = MaterialTheme.shapes.large,+ color = MaterialTheme.colorScheme.surfaceContainer,+ ) {+ Column(Modifier.fillMaxWidth().padding(16.dp)) {+ Text(+ title,+ style = MaterialTheme.typography.titleSmall,+ maxLines = 1,+ overflow = TextOverflow.Ellipsis,+ )+ Spacer(Modifier.height(4.dp))+ val meta = listOfNotNull(durationText, sizeText, markersText, statusText).joinToString(" · ")+ Text(+ meta,+ style = MaterialTheme.typography.bodySmall,+ color = MaterialTheme.colorScheme.onSurfaceVariant,+ )+ Spacer(Modifier.height(12.dp))+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {+ FilledTonalButton(+ onClick = onPlayToggle,+ contentPadding = PaddingValues(horizontal = 14.dp, vertical = 6.dp),+ ) {+ Text(stringResource(if (playing) R.string.action_stop else R.string.media_play))+ }+ OutlinedButton(+ onClick = onSend,+ contentPadding = PaddingValues(horizontal = 14.dp, vertical = 6.dp),+ ) {+ Text(+ stringResource(+ if (recording.delivery == DeliveryState.Sent) R.string.recorder_send_again+ else R.string.recorder_send_now,+ ),+ )+ }+ Spacer(Modifier.weight(1f))+ TextButton(+ onClick = onDelete,+ contentPadding = PaddingValues(horizontal = 12.dp, vertical = 6.dp),+ ) {+ Text(stringResource(R.string.recorder_delete))+ }+ }+ }+ }+}diff --git a/android/app/src/main/res/values/strings.xml b/android/app/src/main/res/values/strings.xmlindex 4e51e77..c337e4e 100644--- a/android/app/src/main/res/values/strings.xml+++ b/android/app/src/main/res/values/strings.xml@@ -244,4 +244,32 @@<string name="remote_laser_hold">Hold for laser pointer</string><string name="remote_laser_active">Laser on %1$s — tilt phone or drag here</string><string name="remote_volume_hint">Volume buttons also change slides while this screen is open.</string>++ <!-- Voice recorder -> PC -->+ <string name="action_record_pc">Record</string>+ <string name="channel_recorder">Voice recorder</string>+ <string name="recorder_notification_recording">Recording for %1$s</string>+ <string name="recorder_notification_paused">Recording paused (%1$s)</string>+ <string name="recorder_permission_title">Allow microphone access</string>+ <string name="recorder_permission_text">Nectarlink uses the microphone only while you record a voice note to send to %1$s.</string>+ <string name="recorder_allow_mic">Allow microphone</string>+ <string name="recorder_offline_hint">Recordings are saved on this phone and sent automatically when %1$s connects.</string>+ <string name="recorder_status_ready">Ready to record for %1$s</string>+ <string name="recorder_status_recording">Recording for %1$s</string>+ <string name="recorder_status_paused">Paused</string>+ <string name="recorder_start">Start recording</string>+ <string name="recorder_pause">Pause</string>+ <string name="recorder_resume">Resume</string>+ <string name="recorder_marker_hint">Marker label (optional)</string>+ <string name="recorder_add_marker">Add marker</string>+ <string name="recorder_marker_default">Marker %1$d</string>+ <string name="recorder_saved_title">Recordings</string>+ <string name="recorder_send_now">Send</string>+ <string name="recorder_send_again">Send again</string>+ <string name="recorder_delete">Delete</string>+ <string name="recorder_denied_text">Voice recordings are turned off for this phone on %1$s.</string>+ <plurals name="recorder_markers_count">+ <item quantity="one">%1$d marker</item>+ <item quantity="other">%1$d markers</item>+ </plurals></resources>diff --git a/core/nectarlink-cli/src/main.rs b/core/nectarlink-cli/src/main.rsindex 6a09450..ccd6d4c 100644--- a/core/nectarlink-cli/src/main.rs+++ b/core/nectarlink-cli/src/main.rs@@ -22,6 +22,9 @@ struct Cli {/// Where this client keeps its identity and paired devices.#[arg(long, global = true, env = "NECTARLINK_DATA_DIR")]data_dir: Option<PathBuf>,+ /// Where received files and recordings are saved.+ #[arg(long, global = true)]+ downloads_dir: Option<PathBuf>,/// Name announced to other devices (defaults to the computer name).#[arg(long, global = true)]name: Option<String>,@@ -117,6 +120,21 @@ enum Command {#[arg(required = true)]files: Vec<PathBuf>,},+ /// Send a voice recording with optional markers to a paired PC (use with+ /// --as-phone) and wait until it has arrived.+ Record {+ device: String,+ /// Duration in seconds when generating a test recording.+ #[arg(long, default_value_t = 3)]+ duration: u32,+ /// Existing audio file (.m4a) to send instead of generating one.+ #[arg(long)]+ file: Option<PathBuf>,+ /// Timestamped marker in milliseconds, optionally with a label:+ /// `<ms>` or `<ms>:<label>` (repeatable, e.g. `--marker 1200:Intro`).+ #[arg(long = "marker", value_name = "MS[:LABEL]")]+ markers: Vec<String>,+ },/// Put text, or an image with --image, on a paired device's clipboard.Clip {device: String,@@ -1675,13 +1693,24 @@ async fn start_node(cli: &Cli) -> Result<Node> {let device = DeviceInfo { name, kind, os, os_ver, model: None, accent: None };let power = node_power(cli);let mut config = NodeConfig::new(data_dir, device, env!("CARGO_PKG_VERSION"));+ config.downloads_dir = cli.downloads_dir.clone();config.port = cli.port;config.lan_discovery = !cli.no_lan;config.away_mode = cli.away;config.power = power;+ if !cli.as_phone {+ config.capabilities.push(nectarlink_core::RECORDER.into());+ }+ let extra_caps = config.capabilities.clone();let node = Node::start(config, Arc::new(TerminalPlatform)).await.context("failed to start")?;if !cli.offers.is_empty() {- node.update_power(power, cli.offers.clone()).await;+ let mut offers = extra_caps;+ for o in &cli.offers {+ if !offers.contains(o) {+ offers.push(o.clone());+ }+ }+ node.update_power(power, offers).await;}if let Some(level) = cli.battery {let plugged = cli.charging.then(|| "ac".to_owned());@@ -1746,6 +1775,16 @@ async fn run(cli: &Cli, node: &Node) -> Result<()> {wait_until_online(node, id).await?;send_files(node, id, files).await?;}+ Command::Record { device, duration, file, markers } => {+ if !cli.as_phone {+ bail!("voice recordings are sent by phones: add --as-phone");+ }+ let parsed_markers: Vec<nectarlink_core::RecordingMarker> =+ markers.iter().map(|s| parse_recording_marker(s)).collect::<Result<Vec<_>>>()?;+ let id = resolve(node, device)?;+ wait_until_online(node, id).await?;+ send_recording(node, id, *duration, file.as_deref(), parsed_markers).await?;+ }Command::Clip { device, text, image } => {let id = resolve(node, device)?;wait_until_online(node, id).await?;@@ -2720,6 +2759,59 @@ async fn send_files(node: &Node, device: DeviceId, paths: &[PathBuf]) -> Result<let mut events = node.events();let files = nectarlink_core::outgoing_paths(paths).context("can't read what to send")?;let id = node.send_files(device, files).await.context("can't send")?;+ wait_for_outgoing_transfer(&mut events, &id).await+}++fn parse_recording_marker(s: &str) -> Result<nectarlink_core::RecordingMarker> {+ let (ms_str, label) = match s.split_once(':') {+ Some((ms, l)) => (ms, Some(l.trim()).filter(|l| !l.is_empty()).map(str::to_owned)),+ None => (s, None),+ };+ let at_ms: u64 =+ ms_str.trim().parse().with_context(|| format!("invalid marker timestamp in ms: {ms_str:?}"))?;+ Ok(nectarlink_core::RecordingMarker { at_ms, label })+}++async fn send_recording(+ node: &Node,+ device: DeviceId,+ duration_secs: u32,+ file: Option<&std::path::Path>,+ markers: Vec<nectarlink_core::RecordingMarker>,+) -> Result<()> {+ let mut events = node.events();+ let (name, path, cleanup) = match file {+ Some(p) => (nectarlink_core::safe_file_name(&p.to_string_lossy()), p.to_path_buf(), false),+ None => {+ let tmp = std::env::temp_dir().join(format!("nectarlink-recording-{}.m4a", std::process::id()));+ std::fs::write(&tmp, sample_m4a(duration_secs)).context("can't write temporary M4A recording")?;+ ("Recording.m4a".to_owned(), tmp, true)+ }+ };+ let outgoing = nectarlink_core::OutgoingFile {+ name,+ folder: None,+ source: nectarlink_core::FileSource::Path(path.clone()),+ };+ let marker_count = markers.len();+ let id = node.send_recording(device, outgoing, markers).await.context("can't send recording")?;+ let res = wait_for_outgoing_transfer(&mut events, &id).await;+ if cleanup {+ let _ = std::fs::remove_file(&path);+ }+ res?;+ if marker_count > 0 {+ println!("Sent voice recording with {marker_count} marker(s).");+ } else {+ println!("Sent voice recording.");+ }+ Ok(())+}++async fn wait_for_outgoing_transfer(+ events: &mut tokio::sync::broadcast::Receiver<NodeEvent>,+ id: &str,+) -> Result<()> {loop {match events.recv().await {Ok(NodeEvent::Transfer(t)) if t.id == id => match t.state {@@ -2742,6 +2834,189 @@ async fn send_files(node: &Node, device: DeviceId, paths: &[PathBuf]) -> Result<}}+/// Builds a self-contained 48 kHz mono AAC-LC `.m4a` (MP4) file of `duration_secs`.+fn sample_m4a(duration_secs: u32) -> Vec<u8> {+ // 1024-sample 48 kHz mono AAC-LC frame (ID_SCE + HCB_1 tone + ID_END).+ const AAC_FRAME: [u8; 6] = [0x01, 0x48, 0x00, 0x84, 0x21, 0x7E];+ const SAMPLE_RATE: u32 = 48_000;+ let num_frames = (duration_secs.max(1) * SAMPLE_RATE).div_ceil(1024).max(1);+ let total_samples = num_frames * 1024;++ fn mp4_box(fourcc: &[u8; 4], payload: &[u8]) -> Vec<u8> {+ let len = (8 + payload.len()) as u32;+ let mut out = Vec::with_capacity(len as usize);+ out.extend_from_slice(&len.to_be_bytes());+ out.extend_from_slice(fourcc);+ out.extend_from_slice(payload);+ out+ }++ fn full_box(fourcc: &[u8; 4], version: u8, flags: u32, body: &[u8]) -> Vec<u8> {+ let mut payload = Vec::with_capacity(4 + body.len());+ payload.push(version);+ payload.extend_from_slice(&flags.to_be_bytes()[1..4]);+ payload.extend_from_slice(body);+ mp4_box(fourcc, &payload)+ }++ let mut ftyp_body = Vec::new();+ ftyp_body.extend_from_slice(b"M4A ");+ ftyp_body.extend_from_slice(&0u32.to_be_bytes());+ ftyp_body.extend_from_slice(b"M4A mp42isom\0\0\0\0");+ let ftyp = mp4_box(b"ftyp", &ftyp_body);++ let build_moov = |chunk_offset: u32| -> Vec<u8> {+ let mut mvhd = Vec::new();+ mvhd.extend_from_slice(&0u32.to_be_bytes()); // creation_time+ mvhd.extend_from_slice(&0u32.to_be_bytes()); // modification_time+ mvhd.extend_from_slice(&SAMPLE_RATE.to_be_bytes()); // timescale+ mvhd.extend_from_slice(&total_samples.to_be_bytes()); // duration+ mvhd.extend_from_slice(&0x0001_0000u32.to_be_bytes()); // rate 1.0+ mvhd.extend_from_slice(&0x0100u16.to_be_bytes()); // volume 1.0+ mvhd.extend_from_slice(&[0u8; 10]); // reserved+ for &m in &[0x0001_0000u32, 0, 0, 0, 0x0001_0000, 0, 0, 0, 0x4000_0000] {+ mvhd.extend_from_slice(&m.to_be_bytes());+ }+ mvhd.extend_from_slice(&[0u8; 24]); // pre_defined+ mvhd.extend_from_slice(&2u32.to_be_bytes()); // next_track_id+ let mvhd_box = full_box(b"mvhd", 0, 0, &mvhd);++ let mut tkhd = Vec::new();+ tkhd.extend_from_slice(&0u32.to_be_bytes()); // creation_time+ tkhd.extend_from_slice(&0u32.to_be_bytes()); // modification_time+ tkhd.extend_from_slice(&1u32.to_be_bytes()); // track_id+ tkhd.extend_from_slice(&0u32.to_be_bytes()); // reserved+ tkhd.extend_from_slice(&total_samples.to_be_bytes()); // duration+ tkhd.extend_from_slice(&[0u8; 8]); // reserved+ tkhd.extend_from_slice(&0u16.to_be_bytes()); // layer+ tkhd.extend_from_slice(&0u16.to_be_bytes()); // alternate_group+ tkhd.extend_from_slice(&0x0100u16.to_be_bytes()); // volume 1.0+ tkhd.extend_from_slice(&0u16.to_be_bytes()); // reserved+ for &m in &[0x0001_0000u32, 0, 0, 0, 0x0001_0000, 0, 0, 0, 0x4000_0000] {+ tkhd.extend_from_slice(&m.to_be_bytes());+ }+ tkhd.extend_from_slice(&0u32.to_be_bytes()); // width+ tkhd.extend_from_slice(&0u32.to_be_bytes()); // height+ let tkhd_box = full_box(b"tkhd", 0, 3, &tkhd);++ let mut mdhd = Vec::new();+ mdhd.extend_from_slice(&0u32.to_be_bytes()); // creation_time+ mdhd.extend_from_slice(&0u32.to_be_bytes()); // modification_time+ mdhd.extend_from_slice(&SAMPLE_RATE.to_be_bytes()); // timescale+ mdhd.extend_from_slice(&total_samples.to_be_bytes()); // duration+ mdhd.extend_from_slice(&0x55c4u16.to_be_bytes()); // "und"+ mdhd.extend_from_slice(&0u16.to_be_bytes()); // pre_defined+ let mdhd_box = full_box(b"mdhd", 0, 0, &mdhd);++ let mut hdlr = Vec::new();+ hdlr.extend_from_slice(&0u32.to_be_bytes()); // pre_defined+ hdlr.extend_from_slice(b"soun"); // handler_type+ hdlr.extend_from_slice(&[0u8; 12]); // reserved+ hdlr.extend_from_slice(b"SoundHandler\0");+ let hdlr_box = full_box(b"hdlr", 0, 0, &hdlr);++ let smhd_box = full_box(b"smhd", 0, 0, &[0u8; 4]);+ let url_box = full_box(b"url ", 0, 1, &[]);+ let mut dref = Vec::new();+ dref.extend_from_slice(&1u32.to_be_bytes());+ dref.extend_from_slice(&url_box);+ let dinf_box = mp4_box(b"dinf", &full_box(b"dref", 0, 0, &dref));++ // ESDescriptor for AAC-LC, 48000 Hz, mono (AudioSpecificConfig = [0x11, 0x88]).+ let esds_body: [u8; 27] = [+ 0x03, 25, 0x00, 0x01, 0x00, // ES_Descriptor (ES_ID=1)+ 0x04, 17, 0x40, 0x15, 0x00, 0x00, 0x00, // DecoderConfigDescriptor (AAC, audio)+ 0x00, 0x01, 0xF4, 0x00, // maxBitrate = 128000+ 0x00, 0x01, 0xF4, 0x00, // avgBitrate = 128000+ 0x05, 2, 0x11, 0x88, // DecoderSpecificInfo (AAC-LC 48kHz mono)+ 0x06, 1, 0x02, // SLConfigDescriptor+ ];+ let esds_box = full_box(b"esds", 0, 0, &esds_body);++ let mut mp4a = Vec::new();+ mp4a.extend_from_slice(&[0u8; 6]); // reserved+ mp4a.extend_from_slice(&1u16.to_be_bytes()); // data_reference_index+ mp4a.extend_from_slice(&[0u8; 8]); // reserved+ mp4a.extend_from_slice(&1u16.to_be_bytes()); // channelcount = 1+ mp4a.extend_from_slice(&16u16.to_be_bytes()); // samplesize = 16+ mp4a.extend_from_slice(&0u16.to_be_bytes()); // pre_defined+ mp4a.extend_from_slice(&0u16.to_be_bytes()); // reserved+ mp4a.extend_from_slice(&(SAMPLE_RATE << 16).to_be_bytes()); // samplerate 16.16+ mp4a.extend_from_slice(&esds_box);+ let mp4a_box = mp4_box(b"mp4a", &mp4a);++ let mut stsd = Vec::new();+ stsd.extend_from_slice(&1u32.to_be_bytes());+ stsd.extend_from_slice(&mp4a_box);+ let stsd_box = full_box(b"stsd", 0, 0, &stsd);++ let mut stts = Vec::new();+ stts.extend_from_slice(&1u32.to_be_bytes());+ stts.extend_from_slice(&num_frames.to_be_bytes());+ stts.extend_from_slice(&1024u32.to_be_bytes());+ let stts_box = full_box(b"stts", 0, 0, &stts);++ let mut stsc = Vec::new();+ stsc.extend_from_slice(&1u32.to_be_bytes());+ stsc.extend_from_slice(&1u32.to_be_bytes()); // first_chunk+ stsc.extend_from_slice(&num_frames.to_be_bytes()); // samples_per_chunk+ stsc.extend_from_slice(&1u32.to_be_bytes()); // sample_description_index+ let stsc_box = full_box(b"stsc", 0, 0, &stsc);++ let mut stsz = Vec::new();+ stsz.extend_from_slice(&(AAC_FRAME.len() as u32).to_be_bytes()); // constant sample_size+ stsz.extend_from_slice(&num_frames.to_be_bytes());+ let stsz_box = full_box(b"stsz", 0, 0, &stsz);++ let mut stco = Vec::new();+ stco.extend_from_slice(&1u32.to_be_bytes());+ stco.extend_from_slice(&chunk_offset.to_be_bytes());+ let stco_box = full_box(b"stco", 0, 0, &stco);++ let mut stbl_body = Vec::new();+ stbl_body.extend_from_slice(&stsd_box);+ stbl_body.extend_from_slice(&stts_box);+ stbl_body.extend_from_slice(&stsc_box);+ stbl_body.extend_from_slice(&stsz_box);+ stbl_body.extend_from_slice(&stco_box);+ let stbl_box = mp4_box(b"stbl", &stbl_body);++ let mut minf_body = Vec::new();+ minf_body.extend_from_slice(&smhd_box);+ minf_body.extend_from_slice(&dinf_box);+ minf_body.extend_from_slice(&stbl_box);+ let minf_box = mp4_box(b"minf", &minf_body);++ let mut mdia_body = Vec::new();+ mdia_body.extend_from_slice(&mdhd_box);+ mdia_body.extend_from_slice(&hdlr_box);+ mdia_body.extend_from_slice(&minf_box);+ let mdia_box = mp4_box(b"mdia", &mdia_body);++ let mut trak_body = Vec::new();+ trak_body.extend_from_slice(&tkhd_box);+ trak_body.extend_from_slice(&mdia_box);+ let trak_box = mp4_box(b"trak", &trak_body);++ let mut moov_body = Vec::new();+ moov_body.extend_from_slice(&mvhd_box);+ moov_body.extend_from_slice(&trak_box);+ mp4_box(b"moov", &moov_body)+ };++ let moov_len = build_moov(0).len();+ let chunk_offset = (ftyp.len() + moov_len + 8) as u32;+ let moov = build_moov(chunk_offset);+ let mdat_payload = AAC_FRAME.repeat(num_frames as usize);+ let mdat = mp4_box(b"mdat", &mdat_payload);++ let mut out = Vec::with_capacity(ftyp.len() + moov.len() + mdat.len());+ out.extend_from_slice(&ftyp);+ out.extend_from_slice(&moov);+ out.extend_from_slice(&mdat);+ out+}+/// "3:07".fn clock(ms: u64) -> String {let s = ms / 1000;@@ -2852,6 +3127,14 @@ async fn watch(node: &Node, fetch_photos: bool) -> Result<()> {}}+fn format_marker_time(ms: u64) -> String {+ let total_secs = ms / 1000;+ let millis = ms % 1000;+ let mins = total_secs / 60;+ let secs = total_secs % 60;+ format!("{mins:02}:{secs:02}.{millis:03}")+}+fn print_event(node: &Node, event: &NodeEvent) {let name = |id: &DeviceId| {node.paired_devices()@@ -2961,7 +3244,49 @@ fn print_event(node: &Node, event: &NodeEvent) {NodeEvent::Transfer(t) if t.direction == Direction::Incoming => match &t.state {TransferState::Done { saved } => {for path in saved {- println!("{}: received {}", name(&t.device), path.display());+ if t.recording {+ if !t.markers.is_empty() {+ let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("Recording");+ let markers_path = path.with_file_name(format!("{stem}.markers.txt"));+ let mut text = String::new();+ for (i, m) in t.markers.iter().enumerate() {+ let label = m.label.as_deref().unwrap_or_default();+ if label.is_empty() {+ text.push_str(&format!(+ "{} Marker {}\n",+ format_marker_time(m.at_ms),+ i + 1+ ));+ } else {+ text.push_str(&format!("{} {label}\n", format_marker_time(m.at_ms)));+ }+ }+ let _ = std::fs::write(&markers_path, text);+ }+ let markers_summary = if t.markers.is_empty() {+ String::new()+ } else {+ let list: Vec<String> = t+ .markers+ .iter()+ .enumerate()+ .map(|(i, m)| match &m.label {+ Some(l) if !l.is_empty() => {+ format!("{} ({l})", format_marker_time(m.at_ms))+ }+ _ => format!("{} (Marker {})", format_marker_time(m.at_ms), i + 1),+ })+ .collect();+ format!(" [markers: {}]", list.join(", "))+ };+ println!(+ "{}: received recording {}{markers_summary}",+ name(&t.device),+ path.display()+ );+ } else {+ println!("{}: received {}", name(&t.device), path.display());+ }}}TransferState::Failed(why) => println!("{}: a transfer failed ({why:?})", name(&t.device)),diff --git a/core/nectarlink-core/src/features.rs b/core/nectarlink-core/src/features.rsindex 6e280fc..26e0618 100644--- a/core/nectarlink-core/src/features.rs+++ b/core/nectarlink-core/src/features.rs@@ -333,6 +333,7 @@ pub const DEVICE_TOGGLES: &[(&str, bool)] = &[("files", true),("media", true),("photos", true),+ ("recordings", true),("pc_actions", true),("mirroring", true),// Controlling this PC's mouse and keyboard is opt-in.@@ -668,6 +669,12 @@ pub const FEATURES: &[FeatureDef] = &[requires: &[phone("photos.read", Unlock::Permission(Permission::Photos)), DeviceToggle("photos")],partial: None,},+ FeatureDef {+ id: "files.recordings",+ group: FeatureGroup::Files,+ requires: &[phone("files.transfer", UPDATE), desktop("recorder", UPDATE), DeviceToggle("recordings")],+ partial: None,+ },// MirroringFeatureDef {id: "mirroring.view",@@ -813,6 +820,7 @@ mod tests {"pc.power","files.transfer","files.browse",+ "recorder","media.control","media.remote","input.inject",diff --git a/core/nectarlink-core/src/lib.rs b/core/nectarlink-core/src/lib.rsindex 4ff3d6f..d61d1a1 100644--- a/core/nectarlink-core/src/lib.rs+++ b/core/nectarlink-core/src/lib.rs@@ -74,8 +74,8 @@ pub use node::Node;pub use notifications::NotificationError;pub use remote::{ButtonAction, INPUT_INJECT, KeyMod, MouseButton, RemoteInput, SlideAction, remote_keys};pub use transfer::{- Direction, FileSource, OutgoingFile, Transfer, TransferFailure, TransferState, outgoing_paths,- safe_file_name,+ Direction, FileSource, OutgoingFile, RECORDER, RecordingMarker, Transfer, TransferFailure, TransferState,+ outgoing_paths, safe_file_name,};pub(crate) fn device_id(key: &iroh::PublicKey) -> DeviceId {diff --git a/core/nectarlink-core/src/node.rs b/core/nectarlink-core/src/node.rsindex d4d5bc7..03a4918 100644--- a/core/nectarlink-core/src/node.rs+++ b/core/nectarlink-core/src/node.rs@@ -882,6 +882,19 @@ impl Node {transfer::send(&self.shared, peer, files).await}+ /// Sends a voice recording and its markers to a paired PC; returns the+ /// transfer's ID. Progress and the outcome arrive as+ /// [`NodeEvent::Transfer`]; the transfer waits for the PC to connect and+ /// resumes after interruptions.+ pub async fn send_recording(+ &self,+ peer: DeviceId,+ file: transfer::OutgoingFile,+ markers: Vec<transfer::RecordingMarker>,+ ) -> Result<String> {+ transfer::send_recording(&self.shared, peer, file, markers).await+ }+/// Cancels a transfer in either direction. Unknown IDs are ignored.pub fn cancel_transfer(&self, id: &str) {if let Some(cancel) = lock(&self.shared.transfers).get(id) {diff --git a/core/nectarlink-core/src/transfer.rs b/core/nectarlink-core/src/transfer.rsindex d6e7d4a..d711586 100644--- a/core/nectarlink-core/src/transfer.rs+++ b/core/nectarlink-core/src/transfer.rs@@ -12,6 +12,7 @@ use std::{use bytes::Bytes;use iroh::endpoint::{ReadError, RecvStream, SendStream, VarInt, WriteError};+pub use nectarlink_protocol::messages::{RecordingMarker, files::RECORDER};use nectarlink_protocol::{DeviceId, Envelope, ErrorCode,messages::{@@ -27,6 +28,8 @@ use crate::{Error, Result, events::NodeEvent, node::Shared, session::Session};/// The device toggle that allows files for a device.pub(crate) const TOGGLE: &str = "files";+/// The device toggle that allows voice recordings for a device.+pub(crate) const RECORDINGS_TOGGLE: &str = "recordings";/// How long a sender keeps trying to reach the device before giving up.const RETRY_FOR: Duration = Duration::from_secs(10 * 60);@@ -102,6 +105,10 @@ pub struct Transfer {pub total: u64,pub done: u64,pub state: TransferState,+ /// True when this transfer is a voice recording (`docs/protocol/recorder.md`).+ pub recording: bool,+ /// Timestamped markers placed during the recording.+ pub markers: Vec<RecordingMarker>,}/// Never prints file names (protocol v0 §11).@@ -115,6 +122,8 @@ impl std::fmt::Debug for Transfer {.field("done", &self.done).field("total", &self.total).field("state", &self.state)+ .field("recording", &self.recording)+ .field("markers", &self.markers.len()).finish()}}@@ -288,13 +297,60 @@ impl Reporter {/// Starts sending files; progress and the outcome arrive as/// [`NodeEvent::Transfer`]. Returns the transfer's ID.pub(crate) async fn send(shared: &Arc<Shared>, peer: DeviceId, files: Vec<OutgoingFile>) -> Result<String> {- if files.is_empty() || files.len() > files::MAX_FILES {+ send_inner(shared, peer, files, false, Vec::new()).await+}++/// Starts sending a voice recording and its markers (`docs/protocol/recorder.md`);+/// progress and the outcome arrive as [`NodeEvent::Transfer`]. Returns the transfer's ID.+pub(crate) async fn send_recording(+ shared: &Arc<Shared>,+ peer: DeviceId,+ mut file: OutgoingFile,+ markers: Vec<RecordingMarker>,+) -> Result<String> {+ file.folder = None;+ let clean_markers = sanitize_markers(markers);+ send_inner(shared, peer, vec![file], true, clean_markers).await+}++fn sanitize_markers(markers: Vec<RecordingMarker>) -> Vec<RecordingMarker> {+ markers+ .into_iter()+ .take(files::MAX_MARKERS)+ .map(|m| {+ let label = m.label.and_then(|raw| {+ let mut clean: String = raw+ .chars()+ .map(|c| if c.is_control() { ' ' } else { c })+ .collect::<String>()+ .trim()+ .to_owned();+ while clean.len() > files::MAX_MARKER_LABEL_BYTES {+ clean.pop();+ }+ let trimmed = clean.trim();+ (!trimmed.is_empty()).then(|| trimmed.to_owned())+ });+ RecordingMarker { at_ms: m.at_ms, label }+ })+ .collect()+}++async fn send_inner(+ shared: &Arc<Shared>,+ peer: DeviceId,+ files: Vec<OutgoingFile>,+ recording: bool,+ markers: Vec<RecordingMarker>,+) -> Result<String> {+ if files.is_empty() || files.len() > files::MAX_FILES || (recording && files.len() != 1) {return Err(Error::Protocol("send between 1 and 5000 files".into()));}if !shared.store.is_paired(&peer)? {return Err(Error::NotPaired);}- if !shared.toggle_on(&peer, TOGGLE) {+ let toggle = if recording { RECORDINGS_TOGGLE } else { TOGGLE };+ if !shared.toggle_on(&peer, toggle) {return Err(Error::Denied);}let mut opened = Vec::with_capacity(files.len());@@ -316,8 +372,11 @@ pub(crate) async fn send(shared: &Arc<Shared>, peer: DeviceId, files: Vec<Outgoilet entries: Vec<FileEntry> = opened.iter().map(|(entry, _)| entry.clone()).collect();let id = new_id();// The whole offer has to fit in one frame.- let offer = Envelope::new(files::OFFER, &FilesOffer { id: id.clone(), files: entries.clone() })- .map_err(|e| Error::Protocol(e.to_string()))?;+ let offer = Envelope::new(+ files::OFFER,+ &FilesOffer { id: id.clone(), files: entries.clone(), recording, markers: markers.clone() },+ )+ .map_err(|e| Error::Protocol(e.to_string()))?;if offer.to_cbor().len() > nectarlink_protocol::MAX_FRAME_LEN {return Err(Error::TooLarge);}@@ -330,6 +389,8 @@ pub(crate) async fn send(shared: &Arc<Shared>, peer: DeviceId, files: Vec<Outgoitotal: entries.iter().map(|e| e.size).fold(0, u64::saturating_add),done: 0,state: TransferState::Waiting,+ recording,+ markers,};let id = transfer.id.clone();// The user's cancel only: shutting down interrupts a transfer (so it@@ -411,6 +472,8 @@ async fn attempt(let offer = FilesOffer {id: reporter.transfer.id.clone(),files: files.iter().map(|(entry, _)| entry.clone()).collect(),+ recording: reporter.transfer.recording,+ markers: reporter.transfer.markers.clone(),};let (Ok(header), Ok(offer)) =(Envelope::new(types::STREAM, &header), Envelope::new(files::OFFER, &offer))@@ -593,7 +656,14 @@ async fn receive(shared: Arc<Shared>, peer: DeviceId, mut send: SendStream, mutlet Some(offer) = offer.filter(FilesOffer::is_valid) else {return refuse(&mut send, ErrorCode::BadMessage, "invalid offer").await;};- if !shared.toggle_on(&peer, TOGGLE) {+ if offer.recording {+ if !shared.local_capabilities().iter().any(|c| c == RECORDER) {+ return refuse(&mut send, ErrorCode::Unsupported, "recordings aren't supported").await;+ }+ if !shared.toggle_on(&peer, RECORDINGS_TOGGLE) {+ return refuse(&mut send, ErrorCode::Denied, "recordings are off for this device").await;+ }+ } else if !shared.toggle_on(&peer, TOGGLE) {return refuse(&mut send, ErrorCode::Denied, "files are off for this device").await;}let dir = shared.incoming_dir().join(peer.to_string()).join(&offer.id);@@ -623,6 +693,8 @@ async fn receive(shared: Arc<Shared>, peer: DeviceId, mut send: SendStream, muttotal: offer.total_size(),done: have.iter().sum(),state: TransferState::Running,+ recording: offer.recording,+ markers: offer.markers.clone(),};let mut reporter = Reporter::new(shared.clone(), transfer);reporter.set(TransferState::Running);diff --git a/core/nectarlink-core/tests/two_devices.rs b/core/nectarlink-core/tests/two_devices.rsindex 6f21444..a4390fb 100644--- a/core/nectarlink-core/tests/two_devices.rs+++ b/core/nectarlink-core/tests/two_devices.rs@@ -2184,3 +2184,75 @@ async fn remote_input_needs_toggle_and_delivers_motion_keys_and_slides() {);assert!(phone.node.remote_move(pc_id, 99999.0, 0.0).await.is_err());}++#[tokio::test(flavor = "multi_thread")]+async fn voice_recordings_arrive_with_markers_and_respect_capability_and_toggle() {+ use nectarlink_core::{RECORDER, RecordingMarker, TransferFailure};++ let mut pc = device("Desktop", DeviceKind::Desktop).await;+ let mut phone = device("Pixel", DeviceKind::Phone).await;+ pair_qr(&mut pc, &mut phone).await;+ let (pc_id, phone_id) = (pc.node.device_id(), phone.node.device_id());+ let src = tempfile::tempdir().unwrap();+ let audio = data(64 * 1024 + 31, 42);+ let markers = vec![+ RecordingMarker { at_ms: 1_250, label: Some("Intro".into()) },+ RecordingMarker { at_ms: 4_800, label: None },+ ];++ // Without the `recorder` capability on the PC, a recording transfer is refused as unsupported.+ let tid = phone+ .node+ .send_recording(pc_id, outgoing(src.path(), "rec1.m4a", &audio), markers.clone())+ .await+ .unwrap();+ let failure = wait_transfer(&mut phone, &tid, "refused without capability", |t| match &t.state {+ TransferState::Failed(f) => Some(f.clone()),+ _ => None,+ })+ .await;+ assert!(+ matches!(failure, TransferFailure::Other(ref s) if s.to_ascii_lowercase().contains("unsupported")),+ "{failure:?}"+ );++ // The PC announces `recorder`.+ pc.node.update_power(PowerLevel::NotApplicable, vec![RECORDER.into()]).await;+ wait_for(&mut phone, "files.recordings available", |e| match e {+ NodeEvent::Capabilities(m)+ if m.device == pc_id && m.state("files.recordings") == Some(FeatureState::Available) =>+ {+ Some(())+ }+ _ => None,+ })+ .await;++ // The recording arrives on the PC and is reported with `recording == true` and its markers.+ let tid = phone+ .node+ .send_recording(pc_id, outgoing(src.path(), "Recording.m4a", &audio), markers.clone())+ .await+ .unwrap();+ let (received_paths, got_recording, got_markers) =+ wait_transfer(&mut pc, &tid, "recording received", |t| {+ saved(t).map(|paths| (paths, t.recording, t.markers.clone()))+ })+ .await;+ assert!(got_recording);+ assert_eq!(got_markers, markers);+ assert_eq!(received_paths.len(), 1);+ assert_eq!(std::fs::read(&received_paths[0]).unwrap(), audio);+ wait_transfer(&mut phone, &tid, "recording sent", saved).await;++ // Turning off the `recordings` toggle on the PC denies incoming recordings while regular files still work.+ pc.node.set_device_toggle(phone_id, "recordings", false).unwrap();+ let tid =+ phone.node.send_recording(pc_id, outgoing(src.path(), "rec2.m4a", &audio), Vec::new()).await.unwrap();+ let denied = wait_transfer(&mut phone, &tid, "denied by toggle", |t| match &t.state {+ TransferState::Failed(f) => Some(f.clone()),+ _ => None,+ })+ .await;+ assert_eq!(denied, TransferFailure::Denied);+}diff --git a/core/nectarlink-ffi/src/lib.rs b/core/nectarlink-ffi/src/lib.rsindex a64dc38..e28ef11 100644--- a/core/nectarlink-ffi/src/lib.rs+++ b/core/nectarlink-ffi/src/lib.rs@@ -299,6 +299,13 @@ pub enum TransferStatus {Cancelled,}+/// A timestamped marker within a voice recording (docs/protocol/recorder.md).+#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]+pub struct RecordingMarker {+ pub at_ms: u64,+ pub label: Option<String>,+}+/// A file transfer (docs/protocol/files.md).#[derive(Clone, PartialEq, Eq, uniffi::Record)]pub struct Transfer {@@ -313,6 +320,10 @@ pub struct Transfer {pub total: u64,pub done: u64,pub status: TransferStatus,+ /// True when this transfer is a voice recording from the phone's recorder.+ pub recording: bool,+ /// Markers captured during the recording.+ pub markers: Vec<RecordingMarker>,}/// Never prints file names (protocol v0 §11).@@ -1083,6 +1094,18 @@ impl From<Notification> for core::Notification {}}+impl From<core::RecordingMarker> for RecordingMarker {+ fn from(m: core::RecordingMarker) -> Self {+ RecordingMarker { at_ms: m.at_ms, label: m.label }+ }+}++impl From<RecordingMarker> for core::RecordingMarker {+ fn from(m: RecordingMarker) -> Self {+ core::RecordingMarker { at_ms: m.at_ms, label: m.label }+ }+}+impl From<core::Transfer> for Transfer {fn from(t: core::Transfer) -> Self {Transfer {@@ -1114,6 +1137,8 @@ impl From<core::Transfer> for Transfer {},core::TransferState::Cancelled => TransferStatus::Cancelled,},+ recording: t.recording,+ markers: t.markers.into_iter().map(Into::into).collect(),}}}@@ -1825,6 +1850,21 @@ impl NectarlinkNode {self.run(async move { Ok(node.send_files(id, files).await?) }).await}+ /// Sends a voice recording and its markers to a paired PC; returns the+ /// transfer's ID. Progress arrives as `Event::Transfer`.+ pub async fn send_recording(+ &self,+ id: String,+ file: FileToSend,+ markers: Vec<RecordingMarker>,+ ) -> Result<String> {+ let id = parse_id(&id)?;+ let file = file_to_send(file)?;+ let markers = markers.into_iter().map(Into::into).collect();+ let node = self.node.clone();+ self.run(async move { Ok(node.send_recording(id, file, markers).await?) }).await+ }+/// Cancels a transfer in either direction.pub fn cancel_transfer(&self, transfer_id: String) {self.node.cancel_transfer(&transfer_id);diff --git a/core/nectarlink-protocol/src/messages.rs b/core/nectarlink-protocol/src/messages.rsindex 57c8c5d..d133800 100644--- a/core/nectarlink-protocol/src/messages.rs+++ b/core/nectarlink-protocol/src/messages.rs@@ -1493,6 +1493,42 @@ pub mod files {/// A file's folder: at most this many bytes and this many levels.pub const MAX_FOLDER_BYTES: usize = 1024;pub const MAX_FOLDER_DEPTH: usize = 32;+ /// Offered by PCs that save and convert voice recordings (`docs/protocol/recorder.md`).+ pub const RECORDER: &str = "recorder";+ /// Most markers on one voice recording.+ pub const MAX_MARKERS: usize = 256;+ /// Most UTF-8 bytes in a marker's label.+ pub const MAX_MARKER_LABEL_BYTES: usize = 256;+}++/// A timestamped marker placed during a voice recording (`docs/protocol/recorder.md`).+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct RecordingMarker {+ /// Elapsed milliseconds from the start of the recording (excluding pauses).+ pub at_ms: u64,+ /// Optional user label for the marker.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub label: Option<String>,+}++/// Never prints the marker's label (protocol v0 §11).+impl std::fmt::Debug for RecordingMarker {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ f.debug_struct("RecordingMarker")+ .field("at_ms", &self.at_ms)+ .field("has_label", &self.label.is_some())+ .finish()+ }+}++impl RecordingMarker {+ pub fn is_valid(&self) -> bool {+ self.label.as_ref().is_none_or(|l| {+ !l.trim().is_empty()+ && l.len() <= files::MAX_MARKER_LABEL_BYTES+ && !l.chars().any(char::is_control)+ })+ }}/// One file of an offer.@@ -1518,12 +1554,23 @@ impl std::fmt::Debug for FileEntry {pub struct FilesOffer {pub id: String,pub files: Vec<FileEntry>,+ /// True when this transfer is a voice recording (`docs/protocol/recorder.md`).+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]+ pub recording: bool,+ /// Timestamped markers placed during the recording.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub markers: Vec<RecordingMarker>,}/// Never prints file names (protocol v0 §11).impl std::fmt::Debug for FilesOffer {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- f.debug_struct("FilesOffer").field("id", &self.id).field("files", &self.files.len()).finish()+ f.debug_struct("FilesOffer")+ .field("id", &self.id)+ .field("files", &self.files.len())+ .field("recording", &self.recording)+ .field("markers", &self.markers.len())+ .finish()}}@@ -1558,8 +1605,16 @@ pub fn is_valid_transfer_id(id: &str) -> bool {impl FilesOffer {pub fn is_valid(&self) -> bool {+ let files_ok = if self.recording {+ self.files.len() == 1+ && self.files[0].folder.is_none()+ && self.markers.len() <= files::MAX_MARKERS+ && self.markers.iter().all(RecordingMarker::is_valid)+ } else {+ (1..=files::MAX_FILES).contains(&self.files.len()) && self.markers.is_empty()+ };is_valid_transfer_id(&self.id)- && (1..=files::MAX_FILES).contains(&self.files.len())+ && files_ok&& self.files.iter()@@ -2001,6 +2056,8 @@ mod tests {let offer = |id: &str, names: &[&str]| FilesOffer {id: id.into(),files: names.iter().map(|n| FileEntry { name: (*n).into(), size: 1, folder: None }).collect(),+ recording: false,+ markers: Vec::new(),};assert!(offer("abcdefghijklmnop", &["photo.jpg", "Résumé (final).pdf"]).is_valid());for bad in ["", ".", "..", "a/b", "a\\b", "x\u{0}y", "tab\there"] {@@ -2017,6 +2074,8 @@ mod tests {let offer = |folder: &str| FilesOffer {id: "abcdefghijklmnop".into(),files: vec![FileEntry { name: "a.jpg".into(), size: 1, folder: Some(folder.into()) }],+ recording: false,+ markers: Vec::new(),};for good in ["Trip", "Trip/Day 1", "Trip/Day 1/raw"] {assert!(offer(good).is_valid(), "{good:?}");@@ -2032,6 +2091,60 @@ mod tests {assert!(!format!("{:?}", offer("Secret")).contains("Secret"));}+ #[test]+ fn recording_offers_and_markers_are_validated() {+ let rec = FilesOffer {+ id: "abcdefghijklmnop".into(),+ files: vec![FileEntry { name: "Recording.m4a".into(), size: 4096, folder: None }],+ recording: true,+ markers: vec![+ RecordingMarker { at_ms: 1200, label: None },+ RecordingMarker { at_ms: 5400, label: Some("Action item".into()) },+ ],+ };+ assert!(rec.is_valid());+ assert!(!format!("{:?}", rec.markers[1]).contains("Action item"));+ let env = Envelope::new(files::OFFER, &rec).unwrap();+ let back: FilesOffer = Envelope::from_cbor(&env.to_cbor()).unwrap().body().unwrap();+ assert_eq!(back, rec);++ // Recordings must be a single file without a folder.+ assert!(+ !FilesOffer {+ files: vec![+ FileEntry { name: "a.m4a".into(), size: 1, folder: None },+ FileEntry { name: "b.m4a".into(), size: 1, folder: None },+ ],+ ..rec.clone()+ }+ .is_valid()+ );+ assert!(+ !FilesOffer {+ files: vec![FileEntry { name: "a.m4a".into(), size: 1, folder: Some("dir".into()) }],+ ..rec.clone()+ }+ .is_valid()+ );+ // Non-recordings cannot carry markers.+ assert!(!FilesOffer { recording: false, ..rec.clone() }.is_valid());+ // Blank or control-character marker labels are rejected.+ assert!(+ !FilesOffer {+ markers: vec![RecordingMarker { at_ms: 0, label: Some(" ".into()) }],+ ..rec.clone()+ }+ .is_valid()+ );+ assert!(+ !FilesOffer {+ markers: vec![RecordingMarker { at_ms: 0, label: Some("bad\nlabel".into()) }],+ ..rec+ }+ .is_valid()+ );+ }+#[test]fn mirror_input_is_checked() {let touch = MirrorInput::Touch { action: TouchAction::Down, x: 0.5, y: 1.0 };diff --git a/desktop/app/Cargo.toml b/desktop/app/Cargo.tomlindex 59c931d..77761ce 100644--- a/desktop/app/Cargo.toml+++ b/desktop/app/Cargo.toml@@ -54,6 +54,7 @@ windows = { workspace = true, features = ["Win32_System_Power","Win32_System_Registry","Win32_System_Shutdown",+ "Win32_System_SystemInformation","Win32_System_Threading","Win32_System_WinRT","Win32_UI_Input_KeyboardAndMouse",diff --git a/desktop/app/qml/components/TransferItem.qml b/desktop/app/qml/components/TransferItem.qmlindex 32b2f17..bd45e84 100644--- a/desktop/app/qml/components/TransferItem.qml+++ b/desktop/app/qml/components/TransferItem.qml@@ -9,6 +9,7 @@ Item {required property string transferIdrequired property string deviceNamerequired property bool incoming+ required property bool recordingrequired property string titlerequired property real totalrequired property real done@@ -69,7 +70,7 @@ Item {Icon {anchors.centerIn: parentwidth: 18; height: 18- path: item.incoming ? Icons.folder : Icons.send+ path: item.incoming ? (item.recording ? Icons.mic : Icons.folder) : Icons.sendcolor: Theme.graphite ? Theme.surfaceContent : Theme.secondaryContainerContent}}diff --git a/desktop/app/qml/pages/SettingsPage.qml b/desktop/app/qml/pages/SettingsPage.qmlindex 85622a4..254ea4d 100644--- a/desktop/app/qml/pages/SettingsPage.qml+++ b/desktop/app/qml/pages/SettingsPage.qml@@ -1,5 +1,6 @@// SPDX-License-Identifier: GPL-3.0-or-laterimport QtQuick+import QtQuick.Dialogsimport app.nectarlink// Settings: appearance, behavior, paired devices and what they may do, and@@ -24,6 +25,7 @@ Item {contacts: qsTr("Contacts"),clipboard: qsTr("Clipboard"),files: qsTr("Files"),+ recordings: qsTr("Voice recordings"),media: qsTr("Media playing on either device"),photos: qsTr("Photos"),pc_actions: qsTr("Lock and sleep this PC"),@@ -31,6 +33,12 @@ Item {remote_files: qsTr("Browse this PC's files while away")})+ FolderDialog {+ id: recordingsFolderPicker+ title: qsTr("Save recordings in")+ onAccepted: Preferences.chooseRecordingsFolder(selectedFolder.toString())+ }+Flickable {anchors.fill: parentcontentHeight: column.height + Theme.contentPadding * 2@@ -205,6 +213,54 @@ Item {}}+ // ---- Recordings ----+ Txt { text: qsTr("Recordings"); role: "label"; muted: true }+ Card {+ width: parent.width+ Column {+ width: parent.width+ ListRow {+ width: parent.width+ iconPath: Icons.folder+ title: qsTr("Save recordings in")+ description: Preferences.recordingsFolder+ Row {+ spacing: 8+ Button {+ visible: !Preferences.recordingsFolderIsDefault+ variant: "text"+ size: "sm"+ text: qsTr("Reset")+ onClicked: Preferences.resetRecordingsFolder()+ }+ Button {+ variant: "tonal"+ size: "sm"+ text: qsTr("Choose folder")+ onClicked: recordingsFolderPicker.open()+ }+ }+ }+ Divider { width: parent.width }+ ListRow {+ width: parent.width+ iconPath: Icons.mic+ title: qsTr("Format")+ description: qsTr("Keep M4A as recorded, or convert on this PC.")+ Segmented {+ options: [+ { value: "m4a", label: "M4A" },+ { value: "mp3", label: "MP3" },+ { value: "wav", label: "WAV" },+ { value: "flac", label: "FLAC" }+ ]+ value: Preferences.recordingsFormat+ onPicked: (value) => Preferences.recordingsFormat = value+ }+ }+ }+ }+// ---- Connection ----Txt { text: qsTr("Connection"); role: "label"; muted: true }Card {diff --git a/desktop/app/src/bridge/prefs.rs b/desktop/app/src/bridge/prefs.rsindex 0630c11..e86409a 100644--- a/desktop/app/src/bridge/prefs.rs+++ b/desktop/app/src/bridge/prefs.rs@@ -2,6 +2,7 @@//! `Preferences`: the app's look and behavior, saved whenever it changes.use std::{+ path::PathBuf,pin::Pin,sync::{Mutex,@@ -10,11 +11,11 @@ use std::{};use cxx_qt::CxxQtType;-use cxx_qt_lib::QString;+use cxx_qt_lib::{QString, QUrl};use crate::{core_host,- settings::{ColorMode, Settings, Theme},+ settings::{ColorMode, RecordingFormat, Settings, Theme},};#[cxx_qt::bridge]@@ -49,7 +50,20 @@ pub mod qobject {#[qproperty(bool, auto_update)]/// Tell when a phone's battery is low, or full.#[qproperty(bool, battery_alerts)]+ /// Folder where voice recordings from phones are saved.+ #[qproperty(QString, recordings_folder)]+ /// Whether `recordings_folder` is the default (`Documents\Nectarlink Recordings`).+ #[qproperty(bool, recordings_folder_is_default)]+ /// "m4a", "mp3", "wav" or "flac".+ #[qproperty(QString, recordings_format)]type Preferences = super::PreferencesRust;++ /// Sets the folder where voice recordings are saved (from a `file:` URL or path).+ #[qinvokable]+ fn choose_recordings_folder(self: Pin<&mut Preferences>, url: &QString);+ /// Resets the recordings folder to `Documents\Nectarlink Recordings`.+ #[qinvokable]+ fn reset_recordings_folder(self: Pin<&mut Preferences>);}impl cxx_qt::Initialize for Preferences {}@@ -67,8 +81,13 @@ pub struct PreferencesRust {start_with_windows: bool,auto_update: bool,battery_alerts: bool,+ recordings_folder: QString,+ recordings_folder_is_default: bool,+ recordings_format: QString,/// What the user chose (`start_with_windows` shows the default until then).start_choice: Option<bool>,+ /// Custom recordings folder if chosen (`None` means default).+ custom_recordings_folder: Option<PathBuf>,}impl cxx_qt::Initialize for qobject::Preferences {@@ -93,6 +112,12 @@ impl cxx_qt::Initialize for qobject::Preferences {self.as_mut().set_battery_alerts(settings.battery_alerts);self.as_mut().set_start_with_windows(crate::startup::effective(settings.start_with_windows));self.as_mut().rust_mut().start_choice = settings.start_with_windows;+ let effective_folder = crate::recordings::effective_folder(settings.recordings_folder.as_deref());+ self.as_mut().set_recordings_folder(QString::from(&effective_folder.to_string_lossy().into_owned()));+ self.as_mut().set_recordings_folder_is_default(settings.recordings_folder.is_none());+ self.as_mut().rust_mut().custom_recordings_folder = settings.recordings_folder.clone();+ self.as_mut().set_recordings_format(QString::from(settings.recordings_format.as_str()));+ crate::recordings::init(&settings);// Save after any change (connected after loading, so loading doesn't// rewrite the file).@@ -133,10 +158,44 @@ impl cxx_qt::Initialize for qobject::Preferences {p.save();}).release();+ self.as_mut()+ .on_recordings_format_changed(|p| {+ let fmt = RecordingFormat::from_str_lossy(&String::from(&p.recordings_format));+ crate::recordings::set_format(fmt);+ p.save();+ })+ .release();}}impl qobject::Preferences {+ pub fn choose_recordings_folder(mut self: Pin<&mut Self>, url: &QString) {+ let raw = QUrl::from(url)+ .to_local_file()+ .map(|p| String::from(&p))+ .filter(|s| !s.is_empty())+ .unwrap_or_else(|| String::from(url));+ let trimmed = raw.trim();+ if trimmed.is_empty() {+ return;+ }+ let path = PathBuf::from(trimmed);+ self.as_mut().rust_mut().custom_recordings_folder = Some(path.clone());+ self.as_mut().set_recordings_folder(QString::from(&path.to_string_lossy().into_owned()));+ self.as_mut().set_recordings_folder_is_default(false);+ crate::recordings::set_folder(Some(path));+ self.save();+ }++ pub fn reset_recordings_folder(mut self: Pin<&mut Self>) {+ let default = crate::recordings::default_folder();+ self.as_mut().rust_mut().custom_recordings_folder = None;+ self.as_mut().set_recordings_folder(QString::from(&default.to_string_lossy().into_owned()));+ self.as_mut().set_recordings_folder_is_default(true);+ crate::recordings::set_folder(None);+ self.save();+ }+fn save(self: Pin<&mut Self>) {let p = self.rust();let settings = Settings {@@ -154,6 +213,8 @@ impl qobject::Preferences {auto_update: p.auto_update,battery_alerts: p.battery_alerts,start_with_windows: p.start_choice,+ recordings_folder: p.custom_recordings_folder.clone(),+ recordings_format: RecordingFormat::from_str_lossy(&String::from(&p.recordings_format)),};save_in_background(settings);}diff --git a/desktop/app/src/bridge/transfers.rs b/desktop/app/src/bridge/transfers.rsindex 63bb2eb..3d537a3 100644--- a/desktop/app/src/bridge/transfers.rs+++ b/desktop/app/src/bridge/transfers.rs@@ -138,6 +138,7 @@ const ROLES: &[&str] = &["deviceId","deviceName","incoming",+ "recording","title","fileCount","total",@@ -158,6 +159,7 @@ fn role_value(row: &Row, role: &str) -> QVariant {"deviceId" => text(&t.device.to_string()),"deviceName" => text(&row.device_name),"incoming" => QVariant::from(&(t.direction == Direction::Incoming)),+ "recording" => QVariant::from(&t.recording),"title" => text(&match t.names.as_slice() {[one] => one.clone(),[first, rest @ ..] => format!("{first} and {} more", rest.len()),@@ -325,6 +327,8 @@ mod tests {total: 400,done: 100,state: TransferState::Done { saved: vec![PathBuf::from(r"C:\Downloads\a.jpg")] },+ recording: false,+ markers: Vec::new(),},rate: 0.0,sampled: Instant::now(),diff --git a/desktop/app/src/core_host.rs b/desktop/app/src/core_host.rsindex 5997cf0..705b2cd 100644--- a/desktop/app/src/core_host.rs+++ b/desktop/app/src/core_host.rs@@ -105,6 +105,7 @@ async fn run(data_dir: PathBuf, platform: Arc<dyn Platform>) {nectarlink_core::MIRROR_VIEW.into(),nectarlink_core::MIRROR_LISTEN.into(),nectarlink_core::INPUT_INJECT.into(),+ nectarlink_core::RECORDER.into(),];let node = match Node::start(config, platform).await {Ok(node) => node,diff --git a/desktop/app/src/main.rs b/desktop/app/src/main.rsindex d483a35..d7843d7 100644--- a/desktop/app/src/main.rs+++ b/desktop/app/src/main.rs@@ -27,6 +27,7 @@ mod notifications;mod palette;mod photos;mod qr;+mod recordings;mod remote;mod send_to;mod settings;@@ -253,6 +254,7 @@ fn main() -> ExitCode {win::smtc::start(media::on_flyout);win::media_sessions::start(media::local_changed);let settings = settings::Settings::load(&data_dir);+ recordings::init(&settings);send_to::set_enabled(settings.send_to_menu);battery::set_enabled(settings.battery_alerts);// A test instance (own data folder) leaves the user's menu and sign-indiff --git a/desktop/app/src/notifications.rs b/desktop/app/src/notifications.rsindex db53f1b..3570862 100644--- a/desktop/app/src/notifications.rs+++ b/desktop/app/src/notifications.rs@@ -194,7 +194,10 @@ pub fn on_toast(event: ToastEvent) {ToastEvent::Opened { device, key } if device == crate::transfers::TOAST_GROUP => {return crate::transfers::open(std::path::Path::new(key));}- ToastEvent::Action { device, key, .. } if device == crate::transfers::TOAST_GROUP => {+ ToastEvent::Action { device, key, action } if device == crate::transfers::TOAST_GROUP => {+ if action == crate::transfers::ACTION_OPEN {+ return crate::transfers::open(std::path::Path::new(key));+ }return crate::transfers::show_in_folder(std::path::Path::new(key));}ToastEvent::Dismissed { device, .. } if device == crate::transfers::TOAST_GROUP => return,diff --git a/desktop/app/src/recordings.rs b/desktop/app/src/recordings.rsnew file mode 100644index 0000000..59fd46a--- /dev/null+++ b/desktop/app/src/recordings.rs@@ -0,0 +1,816 @@+// SPDX-License-Identifier: GPL-3.0-or-later+//! Voice recordings received from a paired phone (docs/protocol/recorder.md):+//! naming by date and time without overwriting, optional Media Foundation+//! conversion (`M4A` kept as recorded, `MP3`, `WAV`, or `FLAC`), marker sidecar+//! files (`<stem>.markers.txt`), and the Windows notification on completion.++#![allow(unsafe_code)]++use std::{+ fs,+ path::{Path, PathBuf},+ sync::Mutex,+ time::{Instant, SystemTime},+};++use nectarlink_core::{RecordingMarker, Transfer, TransferState};+use windows::{+ Win32::{+ Media::MediaFoundation::{+ IMFAttributes, IMFMediaType, IMFSample, IMFSourceReader, MF_MT_AUDIO_AVG_BYTES_PER_SECOND,+ MF_MT_AUDIO_BITS_PER_SAMPLE, MF_MT_AUDIO_NUM_CHANNELS, MF_MT_AUDIO_SAMPLES_PER_SECOND,+ MF_MT_MAJOR_TYPE, MF_MT_SUBTYPE, MF_SOURCE_READER_FIRST_AUDIO_STREAM,+ MF_SOURCE_READERF_ENDOFSTREAM, MF_TRANSCODE_CONTAINERTYPE, MF_VERSION, MFAudioFormat_FLAC,+ MFAudioFormat_MP3, MFAudioFormat_PCM, MFCreateAttributes, MFCreateMediaType,+ MFCreateSinkWriterFromURL, MFCreateSourceReaderFromURL, MFMediaType_Audio, MFSTARTUP_NOSOCKET,+ MFShutdown, MFStartup, MFT_ENUM_FLAG_ALL, MFTranscodeContainerType_MP3,+ MFTranscodeGetAudioOutputAvailableTypes,+ },+ System::{+ Com::{COINIT_MULTITHREADED, CoInitializeEx},+ SystemInformation::GetLocalTime,+ },+ },+ core::{HSTRING, Interface},+};++use crate::{+ core_host,+ settings::{RecordingFormat, Settings},+ transfers::{ACTION_OPEN, ACTION_SHOW, TOAST_GROUP},+ win::toast::{self, Toast},+};++#[derive(Debug, Default)]+struct RuntimeConfig {+ folder: Option<PathBuf>,+ format: RecordingFormat,+ updated_at: Option<SystemTime>,+}++static CONFIG: Mutex<RuntimeConfig> =+ Mutex::new(RuntimeConfig { folder: None, format: RecordingFormat::M4a, updated_at: None });++/// Initializes the in-memory recording preferences from loaded settings.+pub fn init(settings: &Settings) {+ let mut cfg = CONFIG.lock().unwrap_or_else(|e| e.into_inner());+ cfg.folder = settings.recordings_folder.clone();+ cfg.format = settings.recordings_format;+ cfg.updated_at = Some(SystemTime::now());+}++pub fn set_folder(folder: Option<PathBuf>) {+ let mut cfg = CONFIG.lock().unwrap_or_else(|e| e.into_inner());+ cfg.folder = folder;+ cfg.updated_at = Some(SystemTime::now());+}++pub fn set_format(format: RecordingFormat) {+ let mut cfg = CONFIG.lock().unwrap_or_else(|e| e.into_inner());+ cfg.format = format;+ cfg.updated_at = Some(SystemTime::now());+}++/// Default folder: `Documents\Nectarlink Recordings`.+pub fn default_folder() -> PathBuf {+ dirs::document_dir()+ .unwrap_or_else(|| core_host::host().data_dir.join("recordings"))+ .join("Nectarlink Recordings")+}++/// The folder where recordings go right now (`configured` if set, otherwise+/// `Documents\Nectarlink Recordings`).+pub fn effective_folder(configured: Option<&Path>) -> PathBuf {+ configured.filter(|p| !p.as_os_str().is_empty()).map(Path::to_path_buf).unwrap_or_else(default_folder)+}++fn active_config() -> (PathBuf, RecordingFormat) {+ let data_dir = &core_host::host().data_dir;+ let settings_path = data_dir.join("desktop-settings.json");+ let disk_mtime = fs::metadata(&settings_path).and_then(|m| m.modified()).ok();+ let cfg = CONFIG.lock().unwrap_or_else(|e| e.into_inner());+ let disk_is_newer = match (disk_mtime, cfg.updated_at) {+ (Some(m), Some(u)) => m > u,+ (Some(_), None) => true,+ _ => false,+ };+ if disk_is_newer {+ drop(cfg);+ let loaded = Settings::load(data_dir);+ let folder = effective_folder(loaded.recordings_folder.as_deref());+ return (folder, loaded.recordings_format);+ }+ (effective_folder(cfg.folder.as_deref()), cfg.format)+}++/// Formats a recording's base name (`Recording 2026-10-07 14.32`).+pub fn format_recording_stem(year: u16, month: u16, day: u16, hour: u16, minute: u16) -> String {+ format!("Recording {year:04}-{month:02}-{day:02} {hour:02}.{minute:02}")+}++/// Base name for a recording saved right now, in local time.+pub fn current_recording_stem() -> String {+ // SAFETY: GetLocalTime always succeeds and writes a SYSTEMTIME struct.+ let st = unsafe { GetLocalTime() };+ format_recording_stem(st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute)+}++/// The name the phone gave a recording (`Recording 2026-10-07 14.32`, from+/// when it started), so one that waited for the PC keeps its own time.+/// `None` for anything else.+pub fn stem_from_phone(name: &str) -> Option<String> {+ let stem = Path::new(name).file_stem()?.to_str()?;+ // The phone's own " (2)" for two in a minute goes; this folder numbers its own.+ let stem = stem.rsplit_once(" (").filter(|(_, n)| n.ends_with(')')).map_or(stem, |(s, _)| s);+ let time = stem.strip_prefix("Recording ")?;+ let ok = time.len() == "2026-10-07 14.32".len()+ && time.chars().enumerate().all(|(i, c)| match i {+ 4 | 7 => c == '-',+ 10 => c == ' ',+ 13 => c == '.',+ _ => c.is_ascii_digit(),+ });+ ok.then(|| stem.to_owned())+}++/// Picks `dir/<stem>.<ext>`, or `dir/<stem> (2).<ext>` and so on if either the+/// audio file or its `.markers.txt` companion already exists. Never overwrites.+pub fn unique_recording_path(dir: &Path, stem: &str, ext: &str) -> PathBuf {+ let ext = ext.trim_start_matches('.');+ let first = dir.join(format!("{stem}.{ext}"));+ let first_markers = dir.join(format!("{stem}.markers.txt"));+ if !first.exists() && !first_markers.exists() {+ return first;+ }+ (2..)+ .map(|n| {+ let candidate_stem = format!("{stem} ({n})");+ (dir.join(format!("{candidate_stem}.{ext}")), dir.join(format!("{candidate_stem}.markers.txt")))+ })+ .find(|(audio, markers)| !audio.exists() && !markers.exists())+ .map(|(audio, _)| audio)+ .expect("a free recording file name exists")+}++/// Companion marker file path next to `audio_path` (`<stem>.markers.txt`).+pub fn markers_path_for(audio_path: &Path) -> PathBuf {+ let stem = audio_path.file_stem().and_then(|s| s.to_str()).unwrap_or("Recording");+ audio_path.with_file_name(format!("{stem}.markers.txt"))+}++/// Formats recording markers as human-readable lines (`MM:SS.mmm <label>`).+pub fn format_markers(markers: &[RecordingMarker]) -> String {+ let mut out = String::new();+ for (i, m) in markers.iter().enumerate() {+ let ts = format_timestamp_ms(m.at_ms);+ match m.label.as_deref().map(str::trim).filter(|l| !l.is_empty()) {+ Some(label) => out.push_str(&format!("{ts} {label}\n")),+ None => out.push_str(&format!("{ts} Marker {}\n", i + 1)),+ }+ }+ out+}++fn format_timestamp_ms(ms: u64) -> String {+ let total_secs = ms / 1000;+ let millis = ms % 1000;+ let hours = total_secs / 3600;+ let mins = (total_secs % 3600) / 60;+ let secs = total_secs % 60;+ if hours > 0 {+ format!("{hours:02}:{mins:02}:{secs:02}.{millis:03}")+ } else {+ format!("{mins:02}:{secs:02}.{millis:03}")+ }+}++/// Moves or converts a received `.m4a` recording into `dest_dir` under `stem`+/// in `format`, falling back to keeping the original `.m4a` if conversion+/// fails, and writes `<stem>.markers.txt` when `markers` is non-empty.+pub fn save_received_recording(+ src_m4a: &Path,+ dest_dir: &Path,+ stem: &str,+ format: RecordingFormat,+ markers: &[RecordingMarker],+) -> std::io::Result<PathBuf> {+ fs::create_dir_all(dest_dir)?;++ let final_path = match format {+ RecordingFormat::M4a => {+ let dest = unique_recording_path(dest_dir, stem, "m4a");+ move_file(src_m4a, &dest)?;+ dest+ }+ RecordingFormat::Mp3 | RecordingFormat::Wav | RecordingFormat::Flac => {+ let dest = unique_recording_path(dest_dir, stem, format.as_str());+ match convert_audio(src_m4a, &dest, format) {+ Ok(()) if dest.exists() && fs::metadata(&dest).is_ok_and(|m| m.len() > 0) => {+ let _ = fs::remove_file(src_m4a);+ dest+ }+ Ok(()) => {+ let _ = fs::remove_file(&dest);+ tracing::warn!(format = %format.as_str(), "converted audio was empty; keeping original .m4a");+ let fallback = unique_recording_path(dest_dir, stem, "m4a");+ move_file(src_m4a, &fallback)?;+ fallback+ }+ Err(e) => {+ let _ = fs::remove_file(&dest);+ tracing::warn!(error = %e, format = %format.as_str(), "audio conversion failed; keeping original .m4a");+ let fallback = unique_recording_path(dest_dir, stem, "m4a");+ move_file(src_m4a, &fallback)?;+ fallback+ }+ }+ }+ };++ if !markers.is_empty() {+ let markers_file = markers_path_for(&final_path);+ if let Err(e) = fs::write(&markers_file, format_markers(markers)) {+ tracing::warn!(error = %e, "can't write recording markers file");+ }+ }++ Ok(final_path)+}++fn move_file(src: &Path, dest: &Path) -> std::io::Result<()> {+ if fs::rename(src, dest).is_ok() {+ return Ok(());+ }+ fs::copy(src, dest)?;+ let _ = fs::remove_file(src);+ Ok(())+}++struct MfSession;++impl MfSession {+ fn start() -> windows::core::Result<Self> {+ // SAFETY: plain COM and Media Foundation initialization for this worker thread.+ unsafe {+ let _ = CoInitializeEx(None, COINIT_MULTITHREADED);+ MFStartup(MF_VERSION, MFSTARTUP_NOSOCKET)?;+ }+ Ok(Self)+ }+}++impl Drop for MfSession {+ fn drop(&mut self) {+ // SAFETY: balances MFStartup in MfSession::start.+ unsafe {+ let _ = MFShutdown();+ }+ }+}++/// Converts `src` (`.m4a`) to `dest` in `format` (`Mp3`, `Wav`, or `Flac`)+/// using Windows Media Foundation.+pub fn convert_audio(src: &Path, dest: &Path, format: RecordingFormat) -> windows::core::Result<()> {+ let _mf = MfSession::start()?;+ let stream_idx = MF_SOURCE_READER_FIRST_AUDIO_STREAM.0 as u32;++ // SAFETY: Media Foundation COM interfaces with owned parameters.+ unsafe {+ let reader: IMFSourceReader = MFCreateSourceReaderFromURL(&HSTRING::from(src.as_os_str()), None)?;+ let pcm_req: IMFMediaType = MFCreateMediaType()?;+ pcm_req.SetGUID(&MF_MT_MAJOR_TYPE, &MFMediaType_Audio)?;+ pcm_req.SetGUID(&MF_MT_SUBTYPE, &MFAudioFormat_PCM)?;+ pcm_req.SetUINT32(&MF_MT_AUDIO_BITS_PER_SAMPLE, 16)?;+ reader.SetCurrentMediaType(stream_idx, None, &pcm_req)?;++ let pcm_type: IMFMediaType = reader.GetCurrentMediaType(stream_idx)?;+ let sample_rate = pcm_type.GetUINT32(&MF_MT_AUDIO_SAMPLES_PER_SECOND)?;+ let channels = pcm_type.GetUINT32(&MF_MT_AUDIO_NUM_CHANNELS)?;++ match format {+ RecordingFormat::M4a => {+ fs::copy(src, dest).map_err(|e| {+ windows::core::Error::from_hresult(windows::core::HRESULT::from_win32(+ e.raw_os_error().unwrap_or(1) as u32,+ ))+ })?;+ Ok(())+ }+ RecordingFormat::Wav => write_decoded_wav(&reader, stream_idx, sample_rate, channels, dest),+ RecordingFormat::Mp3 => {+ transcode_with_sink_writer(&reader, stream_idx, &pcm_type, sample_rate, channels, dest, true)+ }+ RecordingFormat::Flac => {+ transcode_with_sink_writer(&reader, stream_idx, &pcm_type, sample_rate, channels, dest, false)+ }+ }+ }+}++unsafe fn write_decoded_wav(+ reader: &IMFSourceReader,+ stream_idx: u32,+ sample_rate: u32,+ channels: u32,+ dest: &Path,+) -> windows::core::Result<()> {+ let mut pcm_bytes = Vec::new();+ loop {+ let mut flags = 0u32;+ let mut sample: Option<IMFSample> = None;+ // SAFETY: valid out-pointers for ReadSample.+ unsafe {+ reader.ReadSample(stream_idx, 0, None, Some(&mut flags), None, Some(&mut sample))?;+ }+ if flags & (MF_SOURCE_READERF_ENDOFSTREAM.0 as u32) != 0 {+ break;+ }+ if let Some(sample) = sample {+ // SAFETY: buffer is locked while copied and unlocked immediately.+ unsafe {+ let buffer = sample.ConvertToContiguousBuffer()?;+ let mut ptr = std::ptr::null_mut();+ let mut len = 0u32;+ buffer.Lock(&mut ptr, None, Some(&mut len))?;+ if !ptr.is_null() && len > 0 {+ pcm_bytes.extend_from_slice(std::slice::from_raw_parts(ptr, len as usize));+ }+ buffer.Unlock()?;+ }+ }+ }++ let ch = u16::try_from(channels.clamp(1, 2)).unwrap_or(1);+ let block_align = ch * 2;+ let byte_rate = sample_rate * u32::from(block_align);+ let data_len = u32::try_from(pcm_bytes.len()).unwrap_or(u32::MAX);+ let mut wav = Vec::with_capacity(44 + pcm_bytes.len());+ wav.extend_from_slice(b"RIFF");+ wav.extend_from_slice(&36u32.saturating_add(data_len).to_le_bytes());+ wav.extend_from_slice(b"WAVEfmt ");+ wav.extend_from_slice(&16u32.to_le_bytes());+ wav.extend_from_slice(&1u16.to_le_bytes()); // PCM+ wav.extend_from_slice(&ch.to_le_bytes());+ wav.extend_from_slice(&sample_rate.to_le_bytes());+ wav.extend_from_slice(&byte_rate.to_le_bytes());+ wav.extend_from_slice(&block_align.to_le_bytes());+ wav.extend_from_slice(&16u16.to_le_bytes());+ wav.extend_from_slice(b"data");+ wav.extend_from_slice(&data_len.to_le_bytes());+ wav.extend_from_slice(&pcm_bytes);++ fs::write(dest, wav).map_err(|_| windows::core::Error::from_thread())+}++unsafe fn transcode_with_sink_writer(+ reader: &IMFSourceReader,+ stream_idx: u32,+ pcm_type: &IMFMediaType,+ sample_rate: u32,+ channels: u32,+ dest: &Path,+ mp3: bool,+) -> windows::core::Result<()> {+ let subtype = if mp3 { MFAudioFormat_MP3 } else { MFAudioFormat_FLAC };+ // SAFETY: Media Foundation sink writer setup and sample loop.+ unsafe {+ let out_type = choose_encoder_output_type(&subtype, sample_rate, channels, mp3)?;+ let mut attrs: Option<IMFAttributes> = None;+ if mp3 {+ MFCreateAttributes(&mut attrs, 1)?;+ if let Some(a) = &attrs {+ a.SetGUID(&MF_TRANSCODE_CONTAINERTYPE, &MFTranscodeContainerType_MP3)?;+ }+ }+ let writer = MFCreateSinkWriterFromURL(&HSTRING::from(dest.as_os_str()), None, attrs.as_ref())?;+ let out_stream = writer.AddStream(&out_type)?;+ writer.SetInputMediaType(out_stream, pcm_type, None)?;+ writer.BeginWriting()?;++ loop {+ let mut flags = 0u32;+ let mut timestamp = 0i64;+ let mut sample: Option<IMFSample> = None;+ reader.ReadSample(+ stream_idx,+ 0,+ None,+ Some(&mut flags),+ Some(&mut timestamp),+ Some(&mut sample),+ )?;+ if flags & (MF_SOURCE_READERF_ENDOFSTREAM.0 as u32) != 0 {+ break;+ }+ if let Some(sample) = sample {+ let _ = sample.SetSampleTime(timestamp);+ writer.WriteSample(out_stream, &sample)?;+ }+ }+ writer.Finalize()?;+ }+ Ok(())+}++unsafe fn choose_encoder_output_type(+ subtype: &windows::core::GUID,+ sample_rate: u32,+ channels: u32,+ mp3: bool,+) -> windows::core::Result<IMFMediaType> {+ // SAFETY: queries Media Foundation's registered audio encoder output types.+ unsafe {+ if let Ok(collection) =+ MFTranscodeGetAudioOutputAvailableTypes(subtype, MFT_ENUM_FLAG_ALL.0 as u32, None)+ {+ let count = collection.GetElementCount().unwrap_or(0);+ let mut best: Option<(IMFMediaType, u32)> = None;+ for i in 0..count {+ let Ok(unk) = collection.GetElement(i) else { continue };+ let Ok(mt) = unk.cast::<IMFMediaType>() else { continue };+ let Ok(sr) = mt.GetUINT32(&MF_MT_AUDIO_SAMPLES_PER_SECOND) else { continue };+ let Ok(ch) = mt.GetUINT32(&MF_MT_AUDIO_NUM_CHANNELS) else { continue };+ if sr != sample_rate || ch != channels {+ continue;+ }+ if !mp3+ && let Ok(bits) = mt.GetUINT32(&MF_MT_AUDIO_BITS_PER_SAMPLE)+ && bits != 16+ {+ continue;+ }+ let byterate = mt.GetUINT32(&MF_MT_AUDIO_AVG_BYTES_PER_SECOND).unwrap_or(16_000);+ // Prefer ~128 kbps (16000 B/s) for MP3.+ let dist = byterate.abs_diff(16_000);+ if best.as_ref().is_none_or(|(_, best_dist)| dist < *best_dist) {+ best = Some((mt, dist));+ }+ }+ if let Some((chosen, _)) = best {+ return Ok(chosen);+ }+ }++ let mt: IMFMediaType = MFCreateMediaType()?;+ mt.SetGUID(&MF_MT_MAJOR_TYPE, &MFMediaType_Audio)?;+ mt.SetGUID(&MF_MT_SUBTYPE, subtype)?;+ mt.SetUINT32(&MF_MT_AUDIO_SAMPLES_PER_SECOND, sample_rate)?;+ mt.SetUINT32(&MF_MT_AUDIO_NUM_CHANNELS, channels)?;+ if mp3 {+ mt.SetUINT32(&MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 16_000)?;+ } else {+ mt.SetUINT32(&MF_MT_AUDIO_BITS_PER_SAMPLE, 16)?;+ }+ Ok(mt)+ }+}++/// Handles a completed incoming voice recording transfer off the UI thread:+/// moves/converts the file into the Recordings folder, writes markers when+/// present, updates the transfer entry in Home, and posts the Windows toast.+pub fn on_done(transfer: Transfer) {+ let TransferState::Done { ref saved } = transfer.state else { return };+ let Some(src) = saved.first().cloned() else { return };+ let (dest_dir, format) = active_config();+ let stem = transfer.names.first().and_then(|n| stem_from_phone(n)).unwrap_or_else(current_recording_stem);++ core_host::spawn(async move {+ let markers = transfer.markers.clone();+ let src_for_job = src.clone();+ let dir_for_job = dest_dir.clone();+ let result = tokio::task::spawn_blocking(move || {+ save_received_recording(&src_for_job, &dir_for_job, &stem, format, &markers)+ })+ .await;++ let final_path = match result {+ Ok(Ok(path)) => path,+ Ok(Err(e)) => {+ tracing::warn!(error = %e, "couldn't move or convert recording; keeping received path");+ src+ }+ Err(e) => {+ tracing::warn!(error = %e, "recording task panicked");+ src+ }+ };++ let file_name = final_path+ .file_name()+ .and_then(|n| n.to_str())+ .map(str::to_owned)+ .unwrap_or_else(|| "Recording.m4a".into());++ let mut updated = transfer.clone();+ updated.names = vec![file_name.clone()];+ if let Ok(meta) = fs::metadata(&final_path) {+ updated.total = meta.len();+ updated.done = meta.len();+ }+ updated.state = TransferState::Done { saved: vec![final_path.clone()] };+ core_host::host().hub.update(|s| s.update_transfer(updated, Instant::now()));++ let device = core_host::host()+ .hub+ .read(|s| s.name_of(&transfer.device))+ .unwrap_or_else(|| "your phone".into());++ let body = if transfer.markers.is_empty() {+ file_name+ } else if transfer.markers.len() == 1 {+ format!("{file_name} · 1 marker")+ } else {+ format!("{file_name} · {} markers", transfer.markers.len())+ };++ toast::show(Toast {+ device: TOAST_GROUP.into(),+ key: final_path.to_string_lossy().into_owned(),+ title: format!("Recording from {device} saved"),+ body,+ attribution: "Nectarlink".into(),+ icon: None,+ image: None,+ actions: vec![(ACTION_OPEN.into(), "Open".into()), (ACTION_SHOW.into(), "Show in folder".into())],+ reply: None,+ silent: false,+ progress: None,+ call: false,+ });+ });+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn recordings_keep_the_phones_time() {+ assert_eq!(+ stem_from_phone("Recording 2026-10-07 14.32.m4a").as_deref(),+ Some("Recording 2026-10-07 14.32")+ );+ assert_eq!(+ stem_from_phone("Recording 2026-10-07 14.32 (2).m4a").as_deref(),+ Some("Recording 2026-10-07 14.32")+ );+ assert_eq!(stem_from_phone("Recording ../../x.m4a"), None);+ assert_eq!(stem_from_phone("Voice 2026-10-07 14.32.m4a"), None);+ assert_eq!(stem_from_phone("Recording 2026-10-07 14.32 extra.m4a"), None);+ }++ /// Builds a valid 48 kHz mono AAC-LC `.m4a` file for Media Foundation tests.+ fn test_m4a(duration_secs: u32) -> Vec<u8> {+ const AAC_FRAME: [u8; 6] = [0x01, 0x48, 0x00, 0x84, 0x21, 0x7E];+ const SAMPLE_RATE: u32 = 48_000;+ let num_frames = (duration_secs.max(1) * SAMPLE_RATE).div_ceil(1024).max(1);+ let total_samples = num_frames * 1024;++ fn mp4_box(fourcc: &[u8; 4], payload: &[u8]) -> Vec<u8> {+ let len = (8 + payload.len()) as u32;+ let mut out = Vec::with_capacity(len as usize);+ out.extend_from_slice(&len.to_be_bytes());+ out.extend_from_slice(fourcc);+ out.extend_from_slice(payload);+ out+ }++ fn full_box(fourcc: &[u8; 4], version: u8, flags: u32, body: &[u8]) -> Vec<u8> {+ let mut payload = Vec::with_capacity(4 + body.len());+ payload.push(version);+ payload.extend_from_slice(&flags.to_be_bytes()[1..4]);+ payload.extend_from_slice(body);+ mp4_box(fourcc, &payload)+ }++ let mut ftyp_body = Vec::new();+ ftyp_body.extend_from_slice(b"M4A ");+ ftyp_body.extend_from_slice(&0u32.to_be_bytes());+ ftyp_body.extend_from_slice(b"M4A mp42isom\0\0\0\0");+ let ftyp = mp4_box(b"ftyp", &ftyp_body);++ let build_moov = |chunk_offset: u32| -> Vec<u8> {+ let mut mvhd = Vec::new();+ mvhd.extend_from_slice(&0u32.to_be_bytes());+ mvhd.extend_from_slice(&0u32.to_be_bytes());+ mvhd.extend_from_slice(&SAMPLE_RATE.to_be_bytes());+ mvhd.extend_from_slice(&total_samples.to_be_bytes());+ mvhd.extend_from_slice(&0x0001_0000u32.to_be_bytes());+ mvhd.extend_from_slice(&0x0100u16.to_be_bytes());+ mvhd.extend_from_slice(&[0u8; 10]);+ for &m in &[0x0001_0000u32, 0, 0, 0, 0x0001_0000, 0, 0, 0, 0x4000_0000] {+ mvhd.extend_from_slice(&m.to_be_bytes());+ }+ mvhd.extend_from_slice(&[0u8; 24]);+ mvhd.extend_from_slice(&2u32.to_be_bytes());+ let mvhd_box = full_box(b"mvhd", 0, 0, &mvhd);++ let mut tkhd = Vec::new();+ tkhd.extend_from_slice(&0u32.to_be_bytes());+ tkhd.extend_from_slice(&0u32.to_be_bytes());+ tkhd.extend_from_slice(&1u32.to_be_bytes());+ tkhd.extend_from_slice(&0u32.to_be_bytes());+ tkhd.extend_from_slice(&total_samples.to_be_bytes());+ tkhd.extend_from_slice(&[0u8; 8]);+ tkhd.extend_from_slice(&0u16.to_be_bytes());+ tkhd.extend_from_slice(&0u16.to_be_bytes());+ tkhd.extend_from_slice(&0x0100u16.to_be_bytes());+ tkhd.extend_from_slice(&0u16.to_be_bytes());+ for &m in &[0x0001_0000u32, 0, 0, 0, 0x0001_0000, 0, 0, 0, 0x4000_0000] {+ tkhd.extend_from_slice(&m.to_be_bytes());+ }+ tkhd.extend_from_slice(&0u32.to_be_bytes());+ tkhd.extend_from_slice(&0u32.to_be_bytes());+ let tkhd_box = full_box(b"tkhd", 0, 3, &tkhd);++ let mut mdhd = Vec::new();+ mdhd.extend_from_slice(&0u32.to_be_bytes());+ mdhd.extend_from_slice(&0u32.to_be_bytes());+ mdhd.extend_from_slice(&SAMPLE_RATE.to_be_bytes());+ mdhd.extend_from_slice(&total_samples.to_be_bytes());+ mdhd.extend_from_slice(&0x55c4u16.to_be_bytes());+ mdhd.extend_from_slice(&0u16.to_be_bytes());+ let mdhd_box = full_box(b"mdhd", 0, 0, &mdhd);++ let mut hdlr = Vec::new();+ hdlr.extend_from_slice(&0u32.to_be_bytes());+ hdlr.extend_from_slice(b"soun");+ hdlr.extend_from_slice(&[0u8; 12]);+ hdlr.extend_from_slice(b"SoundHandler\0");+ let hdlr_box = full_box(b"hdlr", 0, 0, &hdlr);++ let smhd_box = full_box(b"smhd", 0, 0, &[0u8; 4]);+ let url_box = full_box(b"url ", 0, 1, &[]);+ let mut dref = Vec::new();+ dref.extend_from_slice(&1u32.to_be_bytes());+ dref.extend_from_slice(&url_box);+ let dinf_box = mp4_box(b"dinf", &full_box(b"dref", 0, 0, &dref));++ let esds_body: [u8; 27] = [+ 0x03, 25, 0x00, 0x01, 0x00, 0x04, 17, 0x40, 0x15, 0x00, 0x00, 0x00, 0x00, 0x01, 0xF4, 0x00,+ 0x00, 0x01, 0xF4, 0x00, 0x05, 2, 0x11, 0x88, 0x06, 1, 0x02,+ ];+ let esds_box = full_box(b"esds", 0, 0, &esds_body);++ let mut mp4a = Vec::new();+ mp4a.extend_from_slice(&[0u8; 6]);+ mp4a.extend_from_slice(&1u16.to_be_bytes());+ mp4a.extend_from_slice(&[0u8; 8]);+ mp4a.extend_from_slice(&1u16.to_be_bytes());+ mp4a.extend_from_slice(&16u16.to_be_bytes());+ mp4a.extend_from_slice(&0u16.to_be_bytes());+ mp4a.extend_from_slice(&0u16.to_be_bytes());+ mp4a.extend_from_slice(&(SAMPLE_RATE << 16).to_be_bytes());+ mp4a.extend_from_slice(&esds_box);+ let mp4a_box = mp4_box(b"mp4a", &mp4a);++ let mut stsd = Vec::new();+ stsd.extend_from_slice(&1u32.to_be_bytes());+ stsd.extend_from_slice(&mp4a_box);+ let stsd_box = full_box(b"stsd", 0, 0, &stsd);++ let mut stts = Vec::new();+ stts.extend_from_slice(&1u32.to_be_bytes());+ stts.extend_from_slice(&num_frames.to_be_bytes());+ stts.extend_from_slice(&1024u32.to_be_bytes());+ let stts_box = full_box(b"stts", 0, 0, &stts);++ let mut stsc = Vec::new();+ stsc.extend_from_slice(&1u32.to_be_bytes());+ stsc.extend_from_slice(&1u32.to_be_bytes());+ stsc.extend_from_slice(&num_frames.to_be_bytes());+ stsc.extend_from_slice(&1u32.to_be_bytes());+ let stsc_box = full_box(b"stsc", 0, 0, &stsc);++ let mut stsz = Vec::new();+ stsz.extend_from_slice(&(AAC_FRAME.len() as u32).to_be_bytes());+ stsz.extend_from_slice(&num_frames.to_be_bytes());+ let stsz_box = full_box(b"stsz", 0, 0, &stsz);++ let mut stco = Vec::new();+ stco.extend_from_slice(&1u32.to_be_bytes());+ stco.extend_from_slice(&chunk_offset.to_be_bytes());+ let stco_box = full_box(b"stco", 0, 0, &stco);++ let mut stbl_body = Vec::new();+ stbl_body.extend_from_slice(&stsd_box);+ stbl_body.extend_from_slice(&stts_box);+ stbl_body.extend_from_slice(&stsc_box);+ stbl_body.extend_from_slice(&stsz_box);+ stbl_body.extend_from_slice(&stco_box);+ let stbl_box = mp4_box(b"stbl", &stbl_body);++ let mut minf_body = Vec::new();+ minf_body.extend_from_slice(&smhd_box);+ minf_body.extend_from_slice(&dinf_box);+ minf_body.extend_from_slice(&stbl_box);+ let minf_box = mp4_box(b"minf", &minf_body);++ let mut mdia_body = Vec::new();+ mdia_body.extend_from_slice(&mdhd_box);+ mdia_body.extend_from_slice(&hdlr_box);+ mdia_body.extend_from_slice(&minf_box);+ let mdia_box = mp4_box(b"mdia", &mdia_body);++ let mut trak_body = Vec::new();+ trak_body.extend_from_slice(&tkhd_box);+ trak_body.extend_from_slice(&mdia_box);+ let trak_box = mp4_box(b"trak", &trak_body);++ let mut moov_body = Vec::new();+ moov_body.extend_from_slice(&mvhd_box);+ moov_body.extend_from_slice(&trak_box);+ mp4_box(b"moov", &moov_body)+ };++ let moov_len = build_moov(0).len();+ let chunk_offset = (ftyp.len() + moov_len + 8) as u32;+ let moov = build_moov(chunk_offset);+ let mdat_payload = AAC_FRAME.repeat(num_frames as usize);+ let mdat = mp4_box(b"mdat", &mdat_payload);++ let mut out = Vec::with_capacity(ftyp.len() + moov.len() + mdat.len());+ out.extend_from_slice(&ftyp);+ out.extend_from_slice(&moov);+ out.extend_from_slice(&mdat);+ out+ }++ #[test]+ fn naming_and_collision_avoidance_never_overwrite() {+ let dir = tempfile::tempdir().unwrap();+ let stem = format_recording_stem(2026, 10, 7, 14, 32);+ assert_eq!(stem, "Recording 2026-10-07 14.32");++ let p1 = unique_recording_path(dir.path(), &stem, "m4a");+ assert_eq!(p1, dir.path().join("Recording 2026-10-07 14.32.m4a"));+ fs::write(&p1, b"first").unwrap();++ let p2 = unique_recording_path(dir.path(), &stem, "m4a");+ assert_eq!(p2, dir.path().join("Recording 2026-10-07 14.32 (2).m4a"));+ fs::write(&p2, b"second").unwrap();++ // Even if only the marker file for (3) exists, (3) is skipped so it isn't overwritten.+ fs::write(dir.path().join("Recording 2026-10-07 14.32 (3).markers.txt"), b"m").unwrap();+ let p4 = unique_recording_path(dir.path(), &stem, "m4a");+ assert_eq!(p4, dir.path().join("Recording 2026-10-07 14.32 (4).m4a"));+ }++ #[test]+ fn marker_files_format_timestamps_and_labels() {+ let markers = vec![+ RecordingMarker { at_ms: 1_250, label: Some("Intro".into()) },+ RecordingMarker { at_ms: 65_000, label: None },+ RecordingMarker { at_ms: 3_661_005, label: Some("Wrap-up".into()) },+ ];+ let text = format_markers(&markers);+ assert_eq!(text, "00:01.250 Intro\n01:05.000 Marker 2\n01:01:01.005 Wrap-up\n");+ }++ #[test]+ fn media_foundation_converts_m4a_to_m4a_mp3_wav_and_flac_with_markers() {+ let dir = tempfile::tempdir().unwrap();+ let stem = "Recording 2026-10-07 14.32";+ let markers = vec![+ RecordingMarker { at_ms: 500, label: Some("Start".into()) },+ RecordingMarker { at_ms: 1_500, label: None },+ ];++ for format in+ [RecordingFormat::M4a, RecordingFormat::Mp3, RecordingFormat::Wav, RecordingFormat::Flac]+ {+ let src = dir.path().join(format!("incoming-{}.m4a", format.as_str()));+ fs::write(&src, test_m4a(2)).unwrap();+ let out_dir = dir.path().join(format.as_str());+ let saved = save_received_recording(&src, &out_dir, stem, format, &markers).unwrap();+ assert!(!src.exists(), "temporary incoming file is removed for {}", format.as_str());+ assert_eq!(+ saved.extension().and_then(|e| e.to_str()),+ Some(format.as_str()),+ "saved in requested format {}",+ format.as_str()+ );+ let bytes = fs::read(&saved).unwrap();+ assert!(bytes.len() > 100, "{} output has non-trivial size ({} B)", format.as_str(), bytes.len());+ match format {+ RecordingFormat::M4a => assert_eq!(&bytes[4..8], b"ftyp"),+ RecordingFormat::Wav => {+ assert_eq!(&bytes[0..4], b"RIFF");+ assert_eq!(&bytes[8..12], b"WAVE");+ }+ RecordingFormat::Flac => assert_eq!(&bytes[0..4], b"fLaC"),+ RecordingFormat::Mp3 => {+ // Either ID3 tag or MP3 frame sync (0xFF 0xFB / 0xF3 / 0xF2).+ assert!(+ &bytes[0..3] == b"ID3" || (bytes[0] == 0xFF && (bytes[1] & 0xE0) == 0xE0),+ "valid MP3 header: {:02X?}",+ &bytes[..4]+ );+ }+ }+ let marker_path = markers_path_for(&saved);+ assert!(marker_path.exists(), "marker file written next to {}", saved.display());+ assert_eq!(fs::read_to_string(&marker_path).unwrap(), "00:00.500 Start\n00:01.500 Marker 2\n");+ }+ }+}diff --git a/desktop/app/src/settings.rs b/desktop/app/src/settings.rsindex 3b7e511..b107425 100644--- a/desktop/app/src/settings.rs+++ b/desktop/app/src/settings.rs@@ -29,6 +29,36 @@ pub enum ColorMode {Dark,}+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]+#[serde(rename_all = "lowercase")]+pub enum RecordingFormat {+ #[default]+ M4a,+ Mp3,+ Wav,+ Flac,+}++impl RecordingFormat {+ pub fn as_str(self) -> &'static str {+ match self {+ RecordingFormat::M4a => "m4a",+ RecordingFormat::Mp3 => "mp3",+ RecordingFormat::Wav => "wav",+ RecordingFormat::Flac => "flac",+ }+ }++ pub fn from_str_lossy(s: &str) -> RecordingFormat {+ match s.trim().to_ascii_lowercase().as_str() {+ "mp3" => RecordingFormat::Mp3,+ "wav" => RecordingFormat::Wav,+ "flac" => RecordingFormat::Flac,+ _ => RecordingFormat::M4a,+ }+ }+}+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]#[serde(default, rename_all = "camelCase")]pub struct Settings {@@ -54,6 +84,11 @@ pub struct Settings {/// doesn't.#[serde(skip_serializing_if = "Option::is_none")]pub start_with_windows: Option<bool>,+ /// Where voice recordings from phones are saved (`None` = `Documents\Nectarlink Recordings`).+ #[serde(skip_serializing_if = "Option::is_none")]+ pub recordings_folder: Option<PathBuf>,+ /// Output format for saved voice recordings (`m4a`, `mp3`, `wav`, or `flac`).+ pub recordings_format: RecordingFormat,}impl Default for Settings {@@ -69,6 +104,8 @@ impl Default for Settings {auto_update: true,battery_alerts: true,start_with_windows: None,+ recordings_folder: None,+ recordings_format: RecordingFormat::default(),}}}@@ -133,6 +170,8 @@ mod tests {auto_update: false,battery_alerts: false,start_with_windows: Some(true),+ recordings_folder: Some(PathBuf::from(r"C:\Recordings")),+ recordings_format: RecordingFormat::Flac,};settings.save(dir.path()).unwrap();assert_eq!(Settings::load(dir.path()), settings);diff --git a/desktop/app/src/state.rs b/desktop/app/src/state.rsindex 730206b..44aa4a9 100644--- a/desktop/app/src/state.rs+++ b/desktop/app/src/state.rs@@ -894,6 +894,8 @@ mod tests {total: 1000,done,state,+ recording: false,+ markers: Vec::new(),}}diff --git a/desktop/app/src/transfers.rs b/desktop/app/src/transfers.rsindex 85f182f..a303147 100644--- a/desktop/app/src/transfers.rs+++ b/desktop/app/src/transfers.rs@@ -16,6 +16,8 @@ use crate::{/// The toast "device" for received-file notifications; their key is the/// saved file's path.pub const TOAST_GROUP: &str = "files";+/// The "Open" toast action.+pub const ACTION_OPEN: &str = "open";/// The "Show in folder" toast action.pub const ACTION_SHOW: &str = "show";@@ -77,6 +79,9 @@ pub fn on_event(event: &NodeEvent) {return;}let TransferState::Done { saved } = &t.state else { return };+ if t.recording {+ return crate::recordings::on_done(t.clone());+ }let Some(first) = saved.first() else { return };let device = core_host::host().hub.read(|s| s.name_of(&t.device)).unwrap_or_else(|| "your phone".into());let title = title(t);diff --git a/docs/PLAN.md b/docs/PLAN.mdindex 62296c0..13a5fa8 100644--- a/docs/PLAN.md+++ b/docs/PLAN.md@@ -186,7 +186,7 @@ current Android. Talking through the PC comes with the HFP item above.| Control phone media from PC. Phone media appears **in Windows' own media flyout** with artwork | P0 🟢 || Control PC media from phone (media notification with artwork, seek, volume) | P0 🟢 || PC volume and output device switch from phone | P1 |-| **Voice Recorder → PC**: record with the phone's (better) mic, hit send, and the file lands on the PC in your chosen format (Opus/M4A/MP3/WAV/FLAC) and folder. Optional: record *straight into* the PC (live stream, appears when you stop), noise suppression, markers | P1 🟢 |+| **Voice Recorder → PC**: record with the phone's (better) mic, hit send, and the file lands on the PC in your chosen format (Opus/M4A/MP3/WAV/FLAC) and folder. Optional: record *straight into* the PC (live stream, appears when you stop), noise suppression, markers ✅ | P1 🟢 || Phone as speaker / headphones for PC audio | P2 || Phone as live microphone for PC apps | P2 (needs a virtual audio driver, evaluate) |diff --git a/docs/architecture/capabilities.md b/docs/architecture/capabilities.mdindex 44f42ed..42e295e 100644--- a/docs/architecture/capabilities.md+++ b/docs/architecture/capabilities.md@@ -121,7 +121,7 @@ the OS (`android` → phone, `windows`/`macos` → desktop).## Per-device toggles`notifications`, `messages`, `calls`, `contacts`, `clipboard`, `files`,-`media`, `photos`, `pc_actions`, `mirroring` (on by default) and+`media`, `photos`, `recordings`, `pc_actions`, `mirroring` (on by default) and`remote_input`, `remote_files` (off by default). Toggles are thisdevice's policy for that peer and are stored locally, so a feature the PCuser switched off is Locked on the PC while the phone may still show it asdiff --git a/docs/protocol/capabilities.md b/docs/protocol/capabilities.mdindex 1c9e108..678be26 100644--- a/docs/protocol/capabilities.md+++ b/docs/protocol/capabilities.md@@ -66,5 +66,6 @@ capability is missing.| `mirror.listen` | Plays a mirrored phone's sound ([mirroring](mirror.md)) | app update || `files.browse` | Lets a paired phone browse and fetch its files | app update || `input.inject` | Accepts pointer, keyboard and presentation input ([remote input](remote.md)) | app update |+| `recorder` | Saves and converts voice recordings from a phone ([recorder](recorder.md)) | app update || `deck.actions` | Runs Deck actions | app update || `addon.vcam` | The virtual camera add-on is installed | installing the add-on |diff --git a/docs/protocol/files.md b/docs/protocol/files.mdindex cbfc871..773abe2 100644--- a/docs/protocol/files.md+++ b/docs/protocol/files.md@@ -39,6 +39,11 @@ is, as names joined by `/`, starting with the sent folder's own (`Trip`,of them, in at most 1,024 bytes. A folder's files are listed together.Empty folders aren't sent.+**Voice recordings.** When a phone sends a voice recording+([`recorder.md`](recorder.md)), `files.offer` sets `"recording": true` on a+single-file offer (without `folder`) and may include `"markers"`: up to 256+entries `{ at_ms: uint, label?: text }`.+Receivers **MUST** reject an offer that breaks these rules with`BAD_MESSAGE`, and still pick their own safe names for writing (see §4). Thewhole offer is one frame (v0 §3), which limits how many files with long@@ -50,8 +55,10 @@ The receiver answers on the same stream:t = "files.accept" b = { have: [uint] } // bytes already received, per file```-or `error` (`DENIED`: the user turned files off for this device; `BUSY`:-not enough space or too many transfers) and closes the stream.+or `error` (`DENIED`: the user turned files or recordings off for this+device; `UNSUPPORTED`: a recording was offered to a device without+`recorder`; `BUSY`: not enough space or too many transfers) and closes the+stream.The sender then writes the files' bytes, raw and back to back: for eachfile, from `have[i]` to its `size`. A file whose `have` equals its `size`diff --git a/docs/protocol/recorder.md b/docs/protocol/recorder.mdnew file mode 100644index 0000000..027fe7e--- /dev/null+++ b/docs/protocol/recorder.md@@ -0,0 +1,87 @@+# Voice recorder (`recorder`)++Records a voice note on the phone and sends it to a paired PC through the+resumable `files` stream (`docs/protocol/files.md`), along with any markers+added during recording.++## 1. Capability & toggle++| Item | Value | Notes |+|---|---|---|+| Desktop capability | `recorder` | Announced in `hello.caps` / `hello.update` by PCs that save and convert voice recordings |+| Phone capability | `files.transfer` | Base capability on every build |+| Per-device toggle | `recordings` | Default `true` on both devices |+| Feature ID | `files.recordings` | Available when phone offers `files.transfer`, desktop offers `recorder`, and `recordings` toggle is on |++## 2. Wire format++Voice recordings travel on the `files` stream (`nectarlink/1/files`,+`op: "send"`, `v: 1`) as a single-file `files.offer` with `recording: true`+and optional `markers`:++```json+{+ "t": "files.offer",+ "id": 1,+ "b": {+ "id": "AbCdEfGhIjKlMnOpQrStUv",+ "files": [+ { "name": "Recording 2026-10-07 14.32.m4a", "size": 194560 }+ ],+ "recording": true,+ "markers": [+ { "at_ms": 4200 },+ { "at_ms": 18500, "label": "Action item" }+ ]+ }+}+```++### Validation rules++- When `recording` is `true`:+ - `files` must contain **exactly 1** entry, and its `folder` must be `None`.+ - `markers` may contain `0..=256` (`MAX_MARKERS`) entries.+ - Each `RecordingMarker` has `at_ms: u64` (elapsed recording milliseconds,+ excluding paused time) and optional `label: Option<String>` (1–256 UTF-8+ bytes after trimming, with no control characters).+- When `recording` is `false` (or omitted):+ - `markers` must be empty.++### Refusal codes++Before accepting a `files.offer` with `recording: true`, the receiver checks:++1. **Capability:** If the receiver does not advertise `recorder`, it replies+ with `err` (`code: "unsupported"`) and closes the stream.+2. **Toggle:** If the `recordings` per-device toggle is off for this sender,+ it replies with `err` (`code: "denied"`) and closes the stream.++### Resumability & offline queueing++Because recordings use `files.offer` and `files.accept`, an interrupted+recording transfer resumes from `files.accept.have` when the connection returns,+and a recording stopped while the PC is offline waits in `Waiting` state and+transfers automatically once the PC reconnects.++## 3. Desktop storage & conversion++When a recording transfer (`recording: true`) completes on the PC:++1. **Folder & naming:** Saved in the user's configured Recordings folder+ (default `Documents\Nectarlink Recordings`) under the name the phone gave+ it, from when recording started (so one that waited for the PC keeps its+ time), or else the time it arrived: `Recording YYYY-MM-DD HH.MM.<ext>` (or `Recording YYYY-MM-DD HH.MM (2).<ext>`+ if that name is already taken; existing files are never overwritten).+2. **Format conversion:** Converted off the UI thread with Windows Media+ Foundation to the user's chosen format (`m4a` as recorded without+ re-encoding, `mp3`, `wav`, or `flac`). If conversion fails, the original+ `.m4a` is kept in the Recordings folder.+3. **Markers file:** When `markers` is non-empty, a companion UTF-8 text file+ `<stem>.markers.txt` (for example,+ `Recording 2026-10-07 14.32.markers.txt`) is written next to the audio file,+ one marker per line (`MM:SS.mmm <label>` or `HH:MM:SS.mmm <label>`;+ one without a label reads `Marker <n>`).+4. **Notification:** A Windows toast `"Recording from <phone> saved"` is shown+ with **Open** and **Show in folder** actions, and the transfer entry's saved+ path is updated to the final file in the Recordings folder.