@siteed/expo-audio-stream 2.1.0 → 2.2.1-beta.0

package/android/src/main/java/net/siteed/audiostream/AudioFileHandler.kt

@@ -1,131 +0,0 @@
-package net.siteed.audiostream
-
-import android.util.Log
-import java.io.File
-import java.io.IOException
-import java.io.OutputStream
-import java.io.RandomAccessFile
-import java.util.UUID
-
-class AudioFileHandler(private val filesDir: File) {
-    // Method to write WAV file header
-    fun writeWavHeader(out: OutputStream, sampleRateInHz: Int, channels: Int, bitDepth: Int) {
-        val header = ByteArray(44)
-        val byteRate = sampleRateInHz * channels * bitDepth / 8
-        val blockAlign = channels * bitDepth / 8
-
-        // RIFF/WAVE header
-        "RIFF".toByteArray().copyInto(header, 0)
-        // (file size - 8) to be updated later
-        header[4] = 0 // Placeholder
-        header[5] = 0 // Placeholder
-        header[6] = 0 // Placeholder
-        header[7] = 0 // Placeholder
-        "WAVE".toByteArray().copyInto(header, 8)
-        "fmt ".toByteArray().copyInto(header, 12)
-
-        // 16 for PCM
-        header[16] = 16
-        header[17] = 0
-        header[18] = 0
-        header[19] = 0
-
-        // PCM format ID
-        header[20] = 1 // Audio format 1 for PCM (not compressed)
-        header[21] = 0
-
-        // Number of channels
-        header[22] = (channels and 0xff).toByte()
-        header[23] = (channels shr 8 and 0xff).toByte()
-
-        // Sample rate
-        header[24] = (sampleRateInHz and 0xff).toByte()
-        header[25] = (sampleRateInHz shr 8 and 0xff).toByte()
-        header[26] = (sampleRateInHz shr 16 and 0xff).toByte()
-        header[27] = (sampleRateInHz shr 24 and 0xff).toByte()
-
-        // Byte rate
-        header[28] = (byteRate and 0xff).toByte()
-        header[29] = (byteRate shr 8 and 0xff).toByte()
-        header[30] = (byteRate shr 16 and 0xff).toByte()
-        header[31] = (byteRate shr 24 and 0xff).toByte()
-
-        // Block align
-        header[32] = (blockAlign and 0xff).toByte()
-        header[33] = (blockAlign shr 8 and 0xff).toByte()
-
-        // Bits per sample
-        header[34] = (bitDepth and 0xff).toByte()
-        header[35] = (bitDepth shr 8 and 0xff).toByte()
-
-        // Data chunk
-        "data".toByteArray().copyInto(header, 36)
-        // Data size to be updated later
-        header[40] = 0 // Placeholder
-        header[41] = 0 // Placeholder
-        header[42] = 0 // Placeholder
-        header[43] = 0 // Placeholder
-
-        out.write(header, 0, 44)
-    }
-
-    fun updateWavHeader(file: File) {
-        try {
-            RandomAccessFile(file, "rw").use { raf ->
-                val fileSize = raf.length()
-                val dataSize = fileSize - 44 // Subtract the header size
-
-                raf.seek(4) // Write correct file size, excluding the first 8 bytes of the RIFF header
-                raf.writeInt(Integer.reverseBytes((dataSize + 36).toInt()))
-
-                raf.seek(40) // Go to the data size position
-                raf.writeInt(Integer.reverseBytes(dataSize.toInt())) // Write the size of the data segment
-            }
-        } catch (e: IOException) {
-            println("Could not update WAV header: ${e.message}")
-        }
-    }
-
-    fun clearAudioStorage() {
-        filesDir.listFiles()?.forEach {
-            it.delete()
-        }
-    }
-
-    fun createAudioFile(extension: String): File {
-        val timestamp = System.currentTimeMillis()
-        val uuid = UUID.randomUUID().toString()
-        val filename = "recording_${timestamp}_${uuid}.${extension}"
-        
-        return try {
-            File(filesDir, filename).apply {
-                parentFile?.mkdirs() // Create directories if they don't exist
-                createNewFile()      // Create the file
-            }
-        } catch (e: Exception) {
-            Log.e(Constants.TAG, "Failed to create audio file", e)
-            throw e
-        }
-    }
-
-    fun deleteFile(file: File?): Boolean {
-        return try {
-            if (file == null) {
-                Log.w(Constants.TAG, "Attempted to delete null file")
-                false
-            } else if (!file.exists()) {
-                Log.w(Constants.TAG, "File does not exist: ${file.absolutePath}")
-                false
-            } else {
-                val wasDeleted = file.delete()
-                if (!wasDeleted) {
-                    Log.w(Constants.TAG, "Failed to delete file: ${file.absolutePath}")
-                }
-                wasDeleted
-            }
-        } catch (e: Exception) {
-            Log.e(Constants.TAG, "Error deleting file: ${file?.absolutePath}", e)
-            false
-        }
-    }
-}

package/android/src/main/java/net/siteed/audiostream/AudioFormatUtils.kt

@@ -1,103 +0,0 @@
-package net.siteed.audiostream
-
-import android.media.AudioFormat
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-
-object AudioFormatUtils {
-    /**
-     * Converts a byte array of audio data to a float array based on the given encoding.
-     * @param audioData The raw audio data in bytes.
-     * @param encoding The encoding format (e.g., "pcm_8bit", "pcm_16bit", "pcm_32bit").
-     * @return A float array with normalized audio samples in the range [-1.0, 1.0].
-     */
-    fun convertByteArrayToFloatArray(audioData: ByteArray, encoding: String): FloatArray {
-        return when (encoding) {
-            "pcm_8bit" -> {
-                val floatArray = FloatArray(audioData.size)
-                for (i in audioData.indices) {
-                    // Convert unsigned 8-bit to float in range [-1.0, 1.0]
-                    floatArray[i] = ((audioData[i].toInt() and 0xFF) - 128) / 128.0f
-                }
-                floatArray
-            }
-            "pcm_16bit" -> {
-                val floatArray = FloatArray(audioData.size / 2)
-                val buffer = ByteBuffer.wrap(audioData).order(ByteOrder.LITTLE_ENDIAN)
-                for (i in floatArray.indices) {
-                    floatArray[i] = buffer.short / 32768.0f // Normalize to [-1.0, 1.0]
-                }
-                floatArray
-            }
-            "pcm_32bit" -> {
-                val floatArray = FloatArray(audioData.size / 4)
-                val buffer = ByteBuffer.wrap(audioData).order(ByteOrder.LITTLE_ENDIAN)
-                for (i in floatArray.indices) {
-                    floatArray[i] = buffer.int / 2_147_483_648.0f // Normalize to [-1.0, 1.0]
-                }
-                floatArray
-            }
-            else -> {
-                // Default to 16-bit PCM if encoding is not recognized
-                val floatArray = FloatArray(audioData.size / 2)
-                val buffer = ByteBuffer.wrap(audioData).order(ByteOrder.LITTLE_ENDIAN)
-                for (i in floatArray.indices) {
-                    floatArray[i] = buffer.short / 32768.0f
-                }
-                floatArray
-            }
-        }
-    }
-
-    /**
-     * Calculates the bit depth (number of bits per sample) based on the encoding string.
-     * @param encoding The encoding format (e.g., "pcm_8bit", "pcm_16bit", "pcm_32bit").
-     * @return The bit depth as an integer.
-     */
-    fun getBitDepth(encoding: String): Int {
-        return when (encoding) {
-            "pcm_8bit" -> 8
-            "pcm_16bit" -> 16
-            "pcm_32bit" -> 32
-            else -> 16 // Default to 16-bit if not recognized
-        }
-    }
-
-    /**
-     * Determines the AudioFormat encoding constant based on the encoding string.
-     * @param encoding The encoding format (e.g., "pcm_8bit", "pcm_16bit", "pcm_32bit").
-     * @return The corresponding AudioFormat constant.
-     */
-    fun getAudioFormat(encoding: String): Int {
-        return when (encoding) {
-            "pcm_8bit" -> AudioFormat.ENCODING_PCM_8BIT
-            "pcm_16bit" -> AudioFormat.ENCODING_PCM_16BIT
-            "pcm_32bit" -> AudioFormat.ENCODING_PCM_FLOAT
-            else -> AudioFormat.ENCODING_PCM_16BIT // Default to 16-bit PCM
-        }
-    }
-
-    /**
-     * Converts audio data between different bit depths
-     * @param audioData The raw audio data
-     * @param sourceBitDepth The original bit depth
-     * @param targetBitDepth The desired bit depth
-     * @return The converted audio data
-     */
-    fun convertBitDepth(audioData: ByteArray, sourceBitDepth: Int, targetBitDepth: Int): ByteArray {
-        // First convert to float array for normalization
-        val floatArray = convertByteArrayToFloatArray(audioData, "pcm_${sourceBitDepth}bit")
-        
-        // Convert back to bytes with new bit depth
-        return when (targetBitDepth) {
-            8 -> floatArray.map { ((it + 1.0f) * 127.5f).toInt().toByte() }.toByteArray()
-            16 -> ByteBuffer.allocate(floatArray.size * 2).order(ByteOrder.LITTLE_ENDIAN).apply {
-                floatArray.forEach { asShortBuffer().put((it * 32767f).toInt().toShort()) }
-            }.array()
-            32 -> ByteBuffer.allocate(floatArray.size * 4).order(ByteOrder.LITTLE_ENDIAN).apply {
-                floatArray.forEach { putFloat(it) }
-            }.array()
-            else -> throw IllegalArgumentException("Unsupported target bit depth: $targetBitDepth")
-        }
-    }
-}

package/android/src/main/java/net/siteed/audiostream/AudioNotificationsManager.kt

@@ -1,435 +0,0 @@
-package net.siteed.audiostream
-
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.graphics.Color
-import android.os.Build
-import android.os.Handler
-import android.os.Looper
-import android.os.SystemClock
-import android.util.Log
-import android.view.View
-import android.widget.RemoteViews
-import androidx.core.app.NotificationCompat
-import java.lang.ref.WeakReference
-import java.util.Locale
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.Objects
-
-class AudioNotificationManager private constructor(context: Context) {
-    private val contextRef = WeakReference(context.applicationContext)
-    private val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-    private val mainHandler = Handler(Looper.getMainLooper())
-    private val isUpdating = AtomicBoolean(false)
-    private val isPaused = AtomicBoolean(false)
-
-    private var lastRemoteViewsUpdate = 0L
-    private var consecutiveUpdateFailures = 0
-    private var lastSuccessfulUpdate: Long = 0
-    private val maxUpdateFailures = 3
-    private val remoteViewsRefreshInterval = 10000L // Refresh RemoteViews every 10 seconds
-
-    private lateinit var notificationBuilder: NotificationCompat.Builder
-    private lateinit var remoteViews: RemoteViews
-    private lateinit var recordingConfig: RecordingConfig
-    private var recordingStartTime: Long = 0
-    private var pausedDuration: Long = 0
-    private var lastPauseTime: Long = 0
-    private var lastWaveformUpdate: Long = 0
-    private val waveformRenderer = WaveformRenderer()
-    private var lastNotificationHash: Int? = null
-
-    companion object {
-        private const val WAVEFORM_UPDATE_INTERVAL = 100L
-        private const val UPDATE_INTERVAL = 1000L
-
-        @Volatile
-        private var instance: AudioNotificationManager? = null
-
-        fun getInstance(context: Context): AudioNotificationManager {
-            return instance ?: synchronized(this) {
-                instance ?: AudioNotificationManager(context).also { instance = it }
-            }
-        }
-    }
-
-    fun initialize(config: RecordingConfig) {
-        recordingConfig = config
-        createNotificationChannel()
-        initializeNotification()
-    }
-
-    private fun createNotificationChannel() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                recordingConfig.notification.channelId,
-                recordingConfig.notification.channelName,
-                NotificationManager.IMPORTANCE_LOW
-            ).apply {
-                description = recordingConfig.notification.channelDescription
-                enableLights(false)
-                enableVibration(false)
-                setSound(null, null)
-                setShowBadge(false)
-                vibrationPattern = null
-            }
-
-            notificationManager.createNotificationChannel(channel)
-        }
-    }
-
-    private fun initializeNotification() {
-        val context = contextRef.get() ?: return
-        try {
-            remoteViews = RemoteViews(context.packageName, R.layout.notification_recording)
-            remoteViews.apply {
-                setTextViewText(R.id.notification_title, recordingConfig.notification.title)
-                setTextViewText(R.id.notification_text, recordingConfig.notification.text)
-                setTextViewText(R.id.notification_duration, formatDuration(0))
-                setViewVisibility(
-                    R.id.notification_waveform,
-                    if (recordingConfig.showWaveformInNotification &&
-                        recordingConfig.notification.waveform != null) View.VISIBLE else View.GONE
-                )
-            }
-
-            buildNotification(context)
-        } catch (e: Exception) {
-            Log.e(Constants.TAG, "Failed to initialize notification", e)
-        }
-    }
-
-    private fun buildNotification(context: Context) {
-        val iconResId = recordingConfig.notification.icon?.let {
-            getResourceIdByName(it)
-        } ?: R.drawable.ic_microphone
-
-        val pendingIntent = PendingIntent.getActivity(
-            context,
-            0,
-            context.packageManager.getLaunchIntentForPackage(context.packageName),
-            PendingIntent.FLAG_IMMUTABLE
-        )
-
-        // Configure notification builder with settings optimized for recording service
-        // and wearable device compatibility
-        notificationBuilder = NotificationCompat.Builder(context, recordingConfig.notification.channelId)
-            .setSmallIcon(iconResId)
-            .setContentIntent(pendingIntent)
-            .setOngoing(true)  // Notification cannot be dismissed by user
-            .setPriority(NotificationCompat.PRIORITY_HIGH)
-            .setCategory(NotificationCompat.CATEGORY_SERVICE)
-            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-            .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
-            .setCustomContentView(remoteViews)
-            .setCustomBigContentView(remoteViews)
-            .setStyle(NotificationCompat.DecoratedCustomViewStyle())
-            // Prevent repeated alerts and vibrations
-            .setOnlyAlertOnce(true)  // Only alert on first notification
-            .setVibrate(null)        // Disable vibration
-            .setDefaults(0)          // Clear all default notification behaviors
-            .setLocalOnly(true)      // Prevent notification from appearing on wearable devices
-
-        addNotificationActions(context)
-    }
-
-    private fun addNotificationActions(context: Context) {
-        // Clear existing actions first
-        notificationBuilder.clearActions()
-
-        // Create pause action
-        val pauseIntent = Intent(context, RecordingActionReceiver::class.java).apply {
-            action = RecordingActionReceiver.ACTION_PAUSE_RECORDING
-        }
-        val pausePendingIntent = PendingIntent.getBroadcast(
-            context,
-            0,
-            pauseIntent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        )
-
-        // Create resume action
-        val resumeIntent = Intent(context, RecordingActionReceiver::class.java).apply {
-            action = RecordingActionReceiver.ACTION_RESUME_RECORDING
-        }
-        val resumePendingIntent = PendingIntent.getBroadcast(
-            context,
-            1,
-            resumeIntent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        )
-
-        // Add only one pause/resume action based on current state
-        if (isPaused.get()) {
-            notificationBuilder.addAction(
-                R.drawable.ic_play,
-                "Resume",
-                resumePendingIntent
-            )
-        } else {
-            notificationBuilder.addAction(
-                R.drawable.ic_pause,
-                "Pause",
-                pausePendingIntent
-            )
-        }
-
-        // Add configured custom actions (only if they don't already exist)
-        val existingActions = mutableSetOf<String>()
-        recordingConfig.notification.actions.forEach { action ->
-            if (existingActions.add(action.intentAction)) { // Only add if action is unique
-                val intent = Intent(context, RecordingActionReceiver::class.java).apply {
-                    this.action = action.intentAction
-                }
-                val pendingIntent = PendingIntent.getBroadcast(
-                    context,
-                    action.intentAction.hashCode(),
-                    intent,
-                    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-                )
-                val actionIconResId = action.icon?.let { getResourceIdByName(it) }
-                    ?: R.drawable.ic_default_action_icon
-                notificationBuilder.addAction(actionIconResId, action.title, pendingIntent)
-            }
-        }
-    }
-
-    private fun updateNotificationActions() {
-        val context = contextRef.get() ?: return
-        try {
-            // Clear existing actions
-            notificationBuilder.clearActions()
-            // Add updated actions
-            addNotificationActions(context)
-
-            // Update the notification
-            val updatedNotification = notificationBuilder
-                .setCustomContentView(remoteViews)
-                .setCustomBigContentView(remoteViews)
-                .build()
-
-            notificationManager.notify(recordingConfig.notification.notificationId, updatedNotification)
-        } catch (e: Exception) {
-            Log.e(Constants.TAG, "Failed to update notification actions", e)
-        }
-    }
-
-    fun startUpdates(startTime: Long) {
-        recordingStartTime = startTime
-        pausedDuration = 0
-        isPaused.set(false)
-        updateNotificationActions() // Update actions when starting
-        if (!isUpdating.getAndSet(true)) {
-            scheduleUpdate()
-        }
-    }
-
-    private fun scheduleUpdate() {
-        mainHandler.postDelayed({
-            if (isUpdating.get() && !isPaused.get()) {
-                updateNotification()
-                scheduleUpdate()
-            }
-        }, UPDATE_INTERVAL)
-    }
-
-    fun updateNotification(audioData: FloatArray? = null) {
-        val context = contextRef.get() ?: return
-
-        try {
-            val currentTime = SystemClock.elapsedRealtime()
-            
-            // Calculate current notification state
-            val recordingDuration = if (isPaused.get()) {
-                lastPauseTime - recordingStartTime - pausedDuration
-            } else {
-                System.currentTimeMillis() - recordingStartTime - pausedDuration
-            }
-            
-            // Create a hash of the current notification state
-            val currentHash = Objects.hash(
-                recordingConfig.notification.title,
-                recordingConfig.notification.text,
-                formatDuration(recordingDuration),
-                isPaused.get()
-            )
-
-            val needsRemoteViewsRefresh = currentTime - lastRemoteViewsUpdate >= remoteViewsRefreshInterval ||
-                    consecutiveUpdateFailures >= maxUpdateFailures
-
-            // Only update if content changed or refresh needed
-            if (currentHash == lastNotificationHash && !needsRemoteViewsRefresh) {
-                // Update waveform only if needed
-                if (shouldUpdateWaveform(audioData, currentTime)) {
-                    updateWaveformOnly(audioData)
-                }
-                return
-            }
-
-            lastNotificationHash = currentHash
-
-            // Only recreate RemoteViews periodically or after failures
-            if (needsRemoteViewsRefresh) {
-                remoteViews = RemoteViews(context.packageName, R.layout.notification_recording)
-                lastRemoteViewsUpdate = currentTime
-                consecutiveUpdateFailures = 0
-            }
-
-            // Update RemoteViews content
-            remoteViews.apply {
-                setTextViewText(R.id.notification_title, recordingConfig.notification.title)
-                setTextViewText(R.id.notification_text, recordingConfig.notification.text)
-                setTextViewText(R.id.notification_duration, formatDuration(recordingDuration))
-
-                // Update waveform if needed
-                if (recordingConfig.showWaveformInNotification &&
-                    audioData != null &&
-                    audioData.isNotEmpty() &&
-                    currentTime - lastWaveformUpdate >= WAVEFORM_UPDATE_INTERVAL
-                ) {
-                    try {
-                        val waveformBitmap = waveformRenderer.generateWaveform(audioData, recordingConfig.notification.waveform)
-                        setImageViewBitmap(R.id.notification_waveform, waveformBitmap)
-                        lastWaveformUpdate = currentTime
-                    } catch (e: Exception) {
-                        Log.e(Constants.TAG, "Error generating waveform", e)
-                    }
-                }
-            }
-
-            // Only rebuild notification if RemoteViews was refreshed
-            if (needsRemoteViewsRefresh) {
-                notificationBuilder
-                    .setCustomContentView(remoteViews)
-                    .setCustomBigContentView(remoteViews)
-                    .setOnlyAlertOnce(true)
-                    .setOngoing(true)
-                addNotificationActions(context)
-            }
-
-            // Update the notification with disabled alerts
-            notificationManager.notify(
-                recordingConfig.notification.notificationId,
-                notificationBuilder
-                    .setOnlyAlertOnce(true)
-                    .setVibrate(null)
-                    .setDefaults(0)
-                    .build()
-            )
-
-            lastSuccessfulUpdate = currentTime
-            consecutiveUpdateFailures = 0
-
-        } catch (e: Exception) {
-            Log.e(Constants.TAG, "Error updating notification", e)
-            consecutiveUpdateFailures++
-
-            if (consecutiveUpdateFailures >= maxUpdateFailures) {
-                reinitializeNotification()
-            }
-        }
-    }
-
-    private fun shouldUpdateWaveform(audioData: FloatArray?, currentTime: Long): Boolean {
-        return recordingConfig.showWaveformInNotification &&
-                audioData != null &&
-                audioData.isNotEmpty() &&
-                currentTime - lastWaveformUpdate >= WAVEFORM_UPDATE_INTERVAL
-    }
-
-    private fun updateWaveformOnly(audioData: FloatArray?) {
-        if (audioData == null) return
-        
-        try {
-            val waveformBitmap = waveformRenderer.generateWaveform(audioData, recordingConfig.notification.waveform)
-            remoteViews.setImageViewBitmap(R.id.notification_waveform, waveformBitmap)
-            lastWaveformUpdate = SystemClock.elapsedRealtime()
-            
-            notificationManager.notify(
-                recordingConfig.notification.notificationId,
-                notificationBuilder
-                    .setCustomContentView(remoteViews)
-                    .setCustomBigContentView(remoteViews)
-                    .setOnlyAlertOnce(true)
-                    .setVibrate(null)
-                    .setDefaults(0)
-                    .build()
-            )
-        } catch (e: Exception) {
-            Log.e(Constants.TAG, "Error updating waveform", e)
-        }
-    }
-
-    private fun reinitializeNotification() {
-        try {
-            val context = contextRef.get() ?: return
-
-            // Force a RemoteViews refresh
-            remoteViews = RemoteViews(context.packageName, R.layout.notification_recording)
-            lastRemoteViewsUpdate = SystemClock.elapsedRealtime()
-
-            buildNotification(context)
-
-            notificationManager.notify(
-                recordingConfig.notification.notificationId,
-                notificationBuilder.build()
-            )
-
-            consecutiveUpdateFailures = 0
-            Log.d(Constants.TAG, "Successfully reinitialized notification")
-        } catch (e: Exception) {
-            Log.e(Constants.TAG, "Failed to reinitialize notification", e)
-        }
-    }
-
-    fun getNotification(): Notification = notificationBuilder.build()
-
-    fun pauseUpdates() {
-        isPaused.set(true)
-        lastPauseTime = System.currentTimeMillis()
-        updateNotificationActions() // Update actions when pausing
-    }
-
-    fun resumeUpdates() {
-        pausedDuration += System.currentTimeMillis() - lastPauseTime
-        isPaused.set(false)
-        updateNotificationActions() // Update actions when resuming
-        scheduleUpdate()
-    }
-
-    fun stopUpdates() {
-        isUpdating.set(false)
-        mainHandler.removeCallbacksAndMessages(null)
-        notificationManager.cancel(recordingConfig.notification.notificationId)
-        cleanup()
-    }
-
-    private fun cleanup() {
-        recordingStartTime = 0
-        pausedDuration = 0
-        lastPauseTime = 0
-        lastWaveformUpdate = 0
-        lastSuccessfulUpdate = 0
-        lastRemoteViewsUpdate = 0
-        consecutiveUpdateFailures = 0
-        isPaused.set(false)
-        isUpdating.set(false)
-    }
-
-    private fun getResourceIdByName(resourceName: String): Int {
-        val context = contextRef.get() ?: return R.drawable.ic_default_action_icon
-        return context.resources.getIdentifier(resourceName, "drawable", context.packageName)
-            .takeIf { it != 0 } ?: R.drawable.ic_default_action_icon
-    }
-
-    private fun formatDuration(durationMs: Long): String {
-        val totalSeconds = durationMs / 1000
-        val minutes = totalSeconds / 60
-        val seconds = totalSeconds % 60
-        return String.format(Locale.US, "%02d:%02d", minutes, seconds)
-    }
-}