package com.ld.sqysj

import android.content.Context
import android.media.AudioAttributes
import android.media.AudioFormat
import android.media.AudioManager
import android.media.AudioTrack
import android.media.MediaCodec
import android.media.MediaCodecInfo
import android.media.MediaFormat
import android.util.Log
import java.nio.ByteBuffer
import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.ThreadPoolExecutor
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger

/**
 * 音频解码器类，用于解码AAC音频数据并播放
 */
class AudioDecoder(private val context: Context) {
    companion object {
        private const val TAG = "AudioDecoder"
        private const val AUDIO_MIME_TYPE = "audio/mp4a-latm"
        private const val SAMPLE_RATE = 48000  // 默认采样率
        private const val CHANNEL_COUNT = 2    // 默认双声道
        private const val PCM_ENCODING = AudioFormat.ENCODING_PCM_16BIT // 16位PCM
        private const val BUFFER_SIZE = 16384  // 音频缓冲区大小
        private const val VOLUME_STEP = 0.1f   // 音量调整步长
        
        // 解码器状态常量
        private const val STATE_IDLE = 0
        private const val STATE_INITIALIZED = 1
        private const val STATE_RUNNING = 2
        private const val STATE_STOPPED = 3
        private const val STATE_ERROR = 4
    }

    // 解码器和播放器状态
    private var mediaCodec: MediaCodec? = null
    private var audioTrack: AudioTrack? = null
    private var isRunning = AtomicBoolean(false)
    private var isInitialized = AtomicBoolean(false)
    private var decoderState = STATE_IDLE // 添加解码器状态跟踪
    // 优化：使用专用的高优先级线程池，减少与视频处理的竞争
    private var threadPool = ThreadPoolExecutor(
        1, 1, 0L, TimeUnit.MILLISECONDS,
        LinkedBlockingQueue(100) // 限制队列大小，避免内存过度使用
    ).apply {
        // 设置线程工厂，使用更低的优先级，让视频处理优先
        threadFactory = object : java.util.concurrent.ThreadFactory {
            override fun newThread(r: Runnable): Thread {
                return Thread(r, "AudioDecoder-Thread").apply {
                    priority = Thread.MIN_PRIORITY + 1 // 低优先级
                    isDaemon = true
                }
            }
        }
    }

    // 音频参数
    private var sampleRate = SAMPLE_RATE
    private var channelCount = CHANNEL_COUNT
    private var adtsHeader: ByteArray? = null
    private var configData: ByteArray? = null
    private var presentationTimeUs = 0L
    private var volume = 0.7f  // 当前音量，范围0.0-1.0
    
    // 音频队列相关 - 优化：使用无锁队列提高性能
    private val audioDataQueue = java.util.concurrent.ConcurrentLinkedQueue<ByteArray>()
    private val maxQueueSize = 50 // 减少队列大小，降低延迟
    
    // 当前解码器状态
    private var currentDecoderState = STATE_IDLE

    // 音量控制
    private var currentVolume = 0.7f

    // 新增音频管理器
    private var audioManager: AudioManager? = null

    // 状态控制
    private val state = AtomicInteger(STATE_IDLE)
    private val isDecoding = AtomicBoolean(false)

    /**
     * 初始化音频解码器
     */
    fun initialize() {
        if (state.get() != STATE_IDLE) {
            Log.w(TAG, "解码器已初始化，当前状态: ${state.get()}")
            return
        }
        
        try {
            Log.d(TAG, "初始化音频解码器")
            
            // 获取AudioManager
            audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
            
            // 创建AudioTrack
            val minBufferSize = AudioTrack.getMinBufferSize(
                sampleRate,
                if (channelCount == 1) AudioFormat.CHANNEL_OUT_MONO else AudioFormat.CHANNEL_OUT_STEREO,
                AudioFormat.ENCODING_PCM_16BIT
            )
            
            val bufferSize = minBufferSize * 4
            
            // 创建音轨
            audioTrack = AudioTrack(
                AudioManager.STREAM_MUSIC,
                sampleRate,
                if (channelCount == 1) AudioFormat.CHANNEL_OUT_MONO else AudioFormat.CHANNEL_OUT_STEREO,
                AudioFormat.ENCODING_PCM_16BIT,
                bufferSize,
                AudioTrack.MODE_STREAM
            )
            
            // 启动AudioTrack
            audioTrack?.play()
            
            // 设置初始音量
            audioTrack?.setVolume(volume)
            
            // 更新状态
            state.set(STATE_INITIALIZED)
            isDecoding.set(true)
            
            Log.d(TAG, "音频解码器状态设置完成，准备启动解码线程")
            
            // **关键修复：启动解码循环**
            startDecodingThread()
            
            Log.d(TAG, "音频解码器初始化成功")
        } catch (e: Exception) {
            Log.e(TAG, "初始化音频解码器失败: 与服务器连接异常")
            state.set(STATE_ERROR)
            throw e
        }
    }

    // 新增：启动解码线程
    private fun startDecodingThread() {
        threadPool.execute {
            Log.d(TAG, "音频解码线程启动")
            decodeLoop()
        }
    }
    
    /**
     * 处理音频数据 - 修复版本，恢复音频处理
     */
    fun processAudioData(data: ByteArray) {
        if (state.get() != STATE_INITIALIZED && state.get() != STATE_RUNNING) {
            return
        }
        
        if (data.isEmpty()) return
        
        try {
            state.set(STATE_RUNNING)
            
            // 检查数据格式并立即处理，确保音频能正常工作
            if (data.size > 4 && data[0] == 0.toByte() && data[1] == 0.toByte() && 
                data[2] == 0.toByte() && data[3] == 3.toByte()) {
                
                val payloadType = data[4].toInt() and 0xFF
                Log.d(TAG, "收到自定义封装数据, payload_type: 0x${String.format("%02X", payloadType)}")
                
                if (payloadType == 0x11) {
                    // 音频配置数据 - 立即处理
                    val configData = data.copyOfRange(4, data.size)
                    handleAudioConfig(configData)
                } else if (payloadType == 0x21) {
                    // 音频数据帧 - 添加到队列异步处理
                    val audioData = data.copyOfRange(4, data.size)
                    addToQueue(audioData)
                }
            } else if (data.size > 0 && data[0] == 17.toByte()) {
                // AAC配置帧 - 立即处理
                Log.d(TAG, "收到AAC配置帧")
                handleAACConfigFrame(data)
            } else {
                // 原始音频数据 - 添加到队列
                addToQueue(data)
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "处理音频数据失败: 与服务器连接异常")
        }
    }

    // 新增：处理音频配置数据
    private fun handleAudioConfig(data: ByteArray) {
        try {
            Log.d(TAG, "处理音频配置数据，长度: ${data.size}, 数据: ${data.joinToString(" ") { String.format("%02X", it) }}")
            
            // 创建MediaCodec解码器
            if (mediaCodec == null) {
                mediaCodec = MediaCodec.createDecoderByType(AUDIO_MIME_TYPE)
                
                // 对于简单的配置数据，尝试创建默认格式
                val format = MediaFormat.createAudioFormat(AUDIO_MIME_TYPE, sampleRate, channelCount)
                
                // 如果数据长度合适，可能是AudioSpecificConfig
                if (data.size >= 2) {
                    format.setByteBuffer("csd-0", ByteBuffer.wrap(data))
                } else {
                    // 创建默认的AudioSpecificConfig
                    val defaultConfig = byteArrayOf(0x12.toByte(), 0x10.toByte()) // AAC-LC, 48kHz, 立体声
                    format.setByteBuffer("csd-0", ByteBuffer.wrap(defaultConfig))
                }
                
                format.setInteger(MediaFormat.KEY_AAC_PROFILE, android.media.MediaCodecInfo.CodecProfileLevel.AACObjectLC)
                format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, BUFFER_SIZE)
                
                // 配置MediaCodec
                mediaCodec?.configure(format, null, null, 0)
                mediaCodec?.start()
                
                Log.d(TAG, "音频解码器配置完成")
                
                // 确保状态正确
                if (state.get() == STATE_INITIALIZED) {
                    state.set(STATE_RUNNING)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "处理音频配置数据失败: 与服务器连接异常", e)
        }
    }

    // 新增：处理AAC配置帧
    private fun handleAACConfigFrame(data: ByteArray) {
        try {
            Log.d(TAG, "处理AAC配置帧，长度: ${data.size}")
            
            // 创建MediaCodec解码器
            if (mediaCodec == null) {
                mediaCodec = MediaCodec.createDecoderByType(AUDIO_MIME_TYPE)
                
                // 创建MediaFormat
                val format = MediaFormat.createAudioFormat(AUDIO_MIME_TYPE, sampleRate, channelCount)
                format.setByteBuffer("csd-0", ByteBuffer.wrap(data))
                
                // 配置MediaCodec
                mediaCodec?.configure(format, null, null, 0)
                mediaCodec?.start()
                
                Log.d(TAG, "AAC解码器配置完成")
                
                // 确保状态正确
                if (state.get() == STATE_INITIALIZED) {
                    state.set(STATE_RUNNING)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "处理AAC配置帧失败: 与服务器连接异常")
        }
    }
    
    /**
     * 处理媒体数据
     */
    private fun processMediaData(data: ByteArray) {
        try {
            val codec = mediaCodec
            if (codec == null) {
                Log.w(TAG, "MediaCodec未初始化，尝试创建默认解码器")
                // 如果没有配置数据，尝试创建默认解码器
                configureDefaultCodec()
                return
            }
            
            // 获取输入缓冲区索引
            val inputBufferIndex = codec.dequeueInputBuffer(1000) // 增加等待时间
            if (inputBufferIndex >= 0) {
                // 获取输入缓冲区
                val inputBuffer = codec.getInputBuffer(inputBufferIndex)
                if (inputBuffer != null) {
                    // 清空缓冲区并填充数据
                    inputBuffer.clear()
                    inputBuffer.put(data)
                    
                    // 递增时间戳
                    presentationTimeUs += 23220 // 约等于1024(AAC帧大小)/48000(采样率)*1000000(微秒)
                    
                    // 提交输入缓冲区
                    codec.queueInputBuffer(inputBufferIndex, 0, data.size, presentationTimeUs, 0)
                    
                    Log.v(TAG, "已提交音频数据到解码器: 大小=${data.size}, 时间戳=${presentationTimeUs}")
                } else {
                    Log.w(TAG, "获取输入缓冲区失败")
                }
            } else {
                Log.v(TAG, "无可用输入缓冲区，数据大小: ${data.size}")
            }
        } catch (e: Exception) {
            Log.e(TAG, "处理媒体数据失败: 与服务器连接异常")
        }
    }

    /**
     * 处理队列中的数据 - 优化版本
     */
    private fun processQueuedData() {
        // 优化：无锁队列，减少线程争用
        var processedCount = 0
        while (audioDataQueue.isNotEmpty() && processedCount < 10) { // 限制批处理数量
            val data = audioDataQueue.poll() ?: break
            processAudioDataInternal(data)
            processedCount++
        }
    }

    /**
     * 将数据添加到队列 - 优化版本
     */
    private fun addToQueue(data: ByteArray) {
        // 优化：使用无锁队列，避免同步阻塞
        if (audioDataQueue.size >= maxQueueSize) {
            // 移除一些旧数据，保持队列流畅
            repeat(5) {
                audioDataQueue.poll()
            }
        }
        audioDataQueue.offer(data)
    }
    
    /**
     * 内部音频数据处理 - 处理队列中的原始音频数据
     */
    private fun processAudioDataInternal(data: ByteArray) {
        try {
            // 这里处理的是已经提取出来的原始音频数据，直接解码
            processMediaData(data)
        } catch (e: Exception) {
            Log.e(TAG, "内部音频数据处理失败: 与服务器连接异常")
        }
    }

    /**
     * 检查是否是ADTS头
     */
    private fun isADTSHeader(data: ByteArray): Boolean {
        // 检查是否有足够的数据
        if (data.size < 7) return false
        
        // ADTS头的前3字节是固定的同步字: 0xFFF... 开头
        return (data[0].toInt() and 0xFF) == 0xFF && 
               (data[1].toInt() and 0xF0) == 0xF0
    }

    /**
     * 处理ADTS格式的数据
     */
    private fun handleADTSData(data: ByteArray) {
        try {
            // 存储ADTS头用于后续解析
            if (adtsHeader == null) {
                adtsHeader = data.copyOf(Math.min(data.size, 7))
                Log.d(TAG, "已获取ADTS头")
                
                // 从ADTS头解析音频配置
                parseADTSHeader(adtsHeader!!)
            }
            
            // 如果解码器尚未配置，现在配置它
            if (mediaCodec?.outputFormat == null) {
                configureCodec()
            }
            
            // 提取AAC数据（去掉ADTS头）
            val aacData = if (data.size > 7) {
                data.copyOfRange(7, data.size)
            } else {
                ByteArray(0)
            }
            
            // 将AAC数据提交到解码器
            queueInputBuffer(aacData)
        } catch (e: Exception) {
            Log.e(TAG, "处理ADTS数据失败", e)
        }
    }

    /**
     * 从ADTS头解析音频参数
     */
    private fun parseADTSHeader(header: ByteArray) {
        try {
            // 采样率索引在第3个字节的后4位和第4个字节的首2位
            val sampleRateIndex = (header[2].toInt() and 0x3C) shr 2
            
            // 通道配置在第3个字节的后1位和第4个字节的首2位
            val channelConfig = ((header[2].toInt() and 0x01) shl 2) or 
                              ((header[3].toInt() and 0xC0) shr 6)
            
            // 映射采样率索引到实际采样率
            sampleRate = when (sampleRateIndex) {
                0 -> 96000
                1 -> 88200
                2 -> 64000
                3 -> 48000
                4 -> 44100
                5 -> 32000
                6 -> 24000
                7 -> 22050
                8 -> 16000
                9 -> 12000
                10 -> 11025
                11 -> 8000
                else -> SAMPLE_RATE
            }
            
            // 设置声道数
            channelCount = if (channelConfig >= 1 && channelConfig <= 7) {
                if (channelConfig == 7) 8 else channelConfig
            } else {
                CHANNEL_COUNT
            }
            
            // 提取AudioSpecificConfig
            val audioObjectType = (header[2].toInt() and 0xC0) shr 6
            configData = ByteArray(2)
            configData!![0] = ((audioObjectType + 1) shl 3 or (sampleRateIndex shr 1)).toByte()
            configData!![1] = ((sampleRateIndex and 1) shl 7 or (channelConfig shl 3)).toByte()
            
            Log.d(TAG, "已解析ADTS头: 采样率=$sampleRate, 声道数=$channelCount")
        } catch (e: Exception) {
            Log.e(TAG, "解析ADTS头失败", e)
            // 使用默认值
            sampleRate = SAMPLE_RATE
            channelCount = CHANNEL_COUNT
        }
    }

    /**
     * 配置解码器
     */
    private fun configureCodec() {
        try {
            if (configData == null) {
                Log.w(TAG, "没有可用的音频配置数据")
                return
            }
            
            // 创建MediaFormat
            val format = MediaFormat.createAudioFormat(AUDIO_MIME_TYPE, sampleRate, channelCount)
            
            // 添加解码器所需的配置信息
            format.setByteBuffer("csd-0", ByteBuffer.wrap(configData!!))
            format.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC)
            format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, BUFFER_SIZE)
            
            // 配置解码器
            mediaCodec?.configure(format, null, null, 0)
            mediaCodec?.start()
            
            // 创建AudioTrack
            initAudioTrack()
            
            Log.d(TAG, "解码器已配置: $format")
        } catch (e: Exception) {
            Log.e(TAG, "配置解码器失败", e)
        }
    }

    /**
     * 处理自定义格式的音频数据
     */
    private fun handleCustomAudioData(data: ByteArray) {
        try {
            // 提取AAC数据 (跳过前4个字节的头部)
            val audioData = if (data.size > 4) {
                data.copyOfRange(4, data.size)
            } else {
                ByteArray(0)
            }
            
            Log.d(TAG, "提取的音频数据长度: ${audioData.size}")
            
            // 根据解码器状态处理
            if (decoderState == STATE_RUNNING) {
                // 解码器已启动，直接提交数据
                queueInputBuffer(audioData)
            } else if (decoderState == STATE_IDLE || decoderState == STATE_INITIALIZED) {
                // 解码器未配置，尝试配置
                if (configData == null) {
                    // 创建默认配置数据
                    configData = ByteArray(2)
                    configData!![0] = 0x12.toByte()  // AAC LC, 48kHz
                    configData!![1] = 0x10.toByte()  // 双声道
                }
                configureDefaultCodec()
                // 将数据添加到队列
                addToQueue(audioData)
            } else {
                // 解码器已配置但未启动，添加到队列
                addToQueue(audioData)
            }
        } catch (e: Exception) {
            Log.e(TAG, "处理自定义音频数据失败", e)
        }
    }
    
    /**
     * 配置默认的解码器
     */
    private fun configureDefaultCodec() {
        try {
            if (mediaCodec != null) {
                Log.d(TAG, "解码器已存在，跳过配置")
                return
            }
            
            Log.d(TAG, "配置默认解码器")
            
            // 创建MediaCodec解码器
            mediaCodec = MediaCodec.createDecoderByType(AUDIO_MIME_TYPE)
            
            // 创建默认格式
            val format = MediaFormat.createAudioFormat(AUDIO_MIME_TYPE, sampleRate, channelCount)
            format.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC)
            format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, BUFFER_SIZE * 2)
            
            // 如果有配置数据，则使用
            if (configData != null) {
                format.setByteBuffer("csd-0", ByteBuffer.wrap(configData!!))
            } else {
                // 创建默认配置数据
                val defaultConfig = ByteArray(2)
                defaultConfig[0] = 0x12.toByte()  // AAC LC, 48kHz
                defaultConfig[1] = 0x10.toByte()  // 双声道
                format.setByteBuffer("csd-0", ByteBuffer.wrap(defaultConfig))
            }
            
            // 配置解码器
            mediaCodec?.configure(format, null, null, 0)
            
            // 启动解码器
            mediaCodec?.start()
            
            // 确保状态正确
            if (state.get() == STATE_INITIALIZED) {
                state.set(STATE_RUNNING)
            }
            
            Log.d(TAG, "默认解码器配置完成")
        } catch (e: Exception) {
            Log.e(TAG, "配置默认解码器失败", e)
        }
    }

    /**
     * 初始化AudioTrack
     */
    private fun initAudioTrack() {
        try {
            Log.d(TAG, "初始化AudioTrack: 采样率=$sampleRate, 声道数=$channelCount")
            
            // 计算最小缓冲区大小
            val channelConfig = if (channelCount == 1) AudioFormat.CHANNEL_OUT_MONO else AudioFormat.CHANNEL_OUT_STEREO
            val minBufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, PCM_ENCODING)
            
            // 使用较大的缓冲区，避免播放中断
            val bufferSize = Math.max(minBufferSize * 4, BUFFER_SIZE * 4)
            
            Log.d(TAG, "AudioTrack最小缓冲区大小: $minBufferSize, 使用缓冲区大小: $bufferSize")
            
            // 创建AudioTrack
            val track = AudioTrack(
                AudioManager.STREAM_MUSIC,
                sampleRate,
                channelConfig,
                PCM_ENCODING,
                bufferSize,
                AudioTrack.MODE_STREAM
            )
            
            // 设置初始音量
            track.setVolume(volume)
            
            // 开始播放
            track.play()
            
            audioTrack = track
            
            Log.d(TAG, "AudioTrack初始化完成，状态: ${track.state}")
            
            // 检查AudioTrack状态
            if (track.state != AudioTrack.STATE_INITIALIZED) {
                Log.e(TAG, "AudioTrack未能正确初始化，状态: ${track.state}")
            } else {
                Log.d(TAG, "AudioTrack已开始播放")
            }
        } catch (e: Exception) {
            Log.e(TAG, "初始化AudioTrack失败", e)
        }
    }

    /**
     * 将数据提交到解码器输入缓冲区
     */
    private fun queueInputBuffer(data: ByteArray) {
        try {
            val codec = mediaCodec ?: return
            
            // 获取输入缓冲区
            val inputBufferId = codec.dequeueInputBuffer(10000L)
            if (inputBufferId >= 0) {
                val inputBuffer = codec.getInputBuffer(inputBufferId)
                if (inputBuffer != null) {
                    // 复制数据到缓冲区
                    inputBuffer.clear()
                    inputBuffer.put(data)
                    
                    // 递增时间戳
                    presentationTimeUs += 23220 // 约等于1024(AAC帧大小)/48000(采样率)*1000000(微秒)
                    
                    // 提交缓冲区
                    codec.queueInputBuffer(
                        inputBufferId, 0, 
                        data.size, presentationTimeUs, 0
                    )
                    
                    Log.d(TAG, "已提交音频数据到解码器: 大小=${data.size}, 时间戳=${presentationTimeUs}")
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "提交输入缓冲区失败", e)
        }
    }

    /**
     * 解码循环 - 修复版本，确保音频正常播放
     */
    private fun decodeLoop() {
        Log.d(TAG, "开始音频解码循环")
        
        try {
            val bufferInfo = MediaCodec.BufferInfo()
            
            while (isDecoding.get()) {
                try {
                    // 处理队列中的数据
                    processQueuedData()
                    
                    // 获取输出缓冲区
                    val codec = mediaCodec
                    if (codec == null) {
                        Thread.sleep(10)
                        continue
                    }
                    
                    val outIndex = codec.dequeueOutputBuffer(bufferInfo, 50) // 适中的等待时间
                    
                    when {
                        outIndex >= 0 -> {
                            // 获取输出数据
                            val outputBuffer = codec.getOutputBuffer(outIndex)
                            if (outputBuffer != null && bufferInfo.size > 0) {
                                // 读取PCM数据
                                val chunk = ByteArray(bufferInfo.size)
                                outputBuffer.position(bufferInfo.offset)
                                outputBuffer.limit(bufferInfo.offset + bufferInfo.size)
                                outputBuffer.get(chunk)
                                
                                // 播放音频
                                audioTrack?.let { track ->
                                    if (track.playState != AudioTrack.PLAYSTATE_PLAYING) {
                                        track.play()
                                        Log.d(TAG, "重新启动AudioTrack播放")
                                    }
                                    val written = track.write(chunk, 0, chunk.size)
                                    if (written > 0) {
                                        Log.v(TAG, "音频播放: 写入${written}字节")
                                    }
                                }
                            }
                            
                            // 释放输出缓冲区
                            codec.releaseOutputBuffer(outIndex, false)
                        }
                        outIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
                            val newFormat = codec.outputFormat
                            Log.d(TAG, "音频解码器输出格式变更: $newFormat")
                            resetAudioTrack(newFormat)
                        }
                        else -> {
                            // 没有输出时短暂休眠
                            Thread.sleep(10)
                        }
                    }
                    
                } catch (e: Exception) {
                    Log.e(TAG, "音频解码循环中出错", e)
                    Thread.sleep(100)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "音频解码循环出现异常", e)
        } finally {
            Log.d(TAG, "音频解码循环结束")
        }
    }

    /**
     * 释放资源
     */
    fun release() {
        try {
            // 停止解码循环
            isRunning.set(false)
            
            // 释放AudioTrack
            audioTrack?.stop()
            audioTrack?.release()
            audioTrack = null
            
            // 释放MediaCodec
            mediaCodec?.stop()
            mediaCodec?.release()
            mediaCodec = null
            
            // 重置变量
            adtsHeader = null
            configData = null
            presentationTimeUs = 0L
            
            Log.d(TAG, "已释放音频解码器资源")
        } catch (e: Exception) {
            Log.e(TAG, "释放资源失败", e)
        }
    }

    /**
     * 销毁解码器
     */
    fun dispose() {
        try {
            Log.d(TAG, "开始销毁音频解码器")
            
            // 停止解码循环
            isDecoding.set(false)
            
            // 释放MediaCodec和AudioTrack
            release()
            
            // 清理音频队列
            audioDataQueue.clear()
            
            // 关闭线程池
            threadPool.shutdown()
            if (!threadPool.awaitTermination(2, TimeUnit.SECONDS)) {
                Log.w(TAG, "线程池未能正常关闭，强制关闭")
                threadPool.shutdownNow()
            }
            
            // 重置所有状态
            state.set(STATE_IDLE)
            isInitialized.set(false)
            configData = null
            
            // 清理AudioManager引用
            audioManager = null
            
            // 强制垃圾回收
            System.gc()
            
            Log.d(TAG, "音频解码器销毁完成")
        } catch (e: Exception) {
            Log.e(TAG, "销毁音频解码器时出现异常", e)
        }
    }

    /**
     * 增加音量
     */
    fun increaseVolume() {
        try {
            val maxVolume = audioManager?.getStreamMaxVolume(AudioManager.STREAM_MUSIC) ?: 15
            val currentVolume = audioManager?.getStreamVolume(AudioManager.STREAM_MUSIC) ?: 0
            
            // 避免超出最大音量
            val newVolume = (currentVolume + 1).coerceAtMost(maxVolume)
            
            // 设置新音量
            audioManager?.setStreamVolume(AudioManager.STREAM_MUSIC, newVolume, 0)
            
            Log.d(TAG, "增加音量: $currentVolume -> $newVolume, 最大值: $maxVolume")
        } catch (e: Exception) {
            Log.e(TAG, "增加音量失败", e)
        }
    }
    
    /**
     * 降低音量
     */
    fun decreaseVolume() {
        try {
            val currentVolume = audioManager?.getStreamVolume(AudioManager.STREAM_MUSIC) ?: 0
            
            // 避免低于0
            val newVolume = (currentVolume - 1).coerceAtLeast(0)
            
            // 设置新音量
            audioManager?.setStreamVolume(AudioManager.STREAM_MUSIC, newVolume, 0)
            
            Log.d(TAG, "减小音量: $currentVolume -> $newVolume")
        } catch (e: Exception) {
            Log.e(TAG, "减小音量失败", e)
        }
    }
    
    /**
     * 切换静音状态
     */
    fun toggleMute() {
        try {
            val audioManager = audioManager ?: return
            
            // 获取当前静音状态
            val isMuted = audioManager.isStreamMute(AudioManager.STREAM_MUSIC)
            
            if (isMuted) {
                // 如果当前是静音，则取消静音
                audioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC, 
                    AudioManager.ADJUST_UNMUTE, 0)
                Log.d(TAG, "取消静音")
            } else {
                // 如果当前不是静音，则设为静音
                audioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC, 
                    AudioManager.ADJUST_MUTE, 0)
                Log.d(TAG, "设置静音")
            }
        } catch (e: Exception) {
            Log.e(TAG, "切换静音状态失败", e)
        }
    }

    /**
     * 重置AudioTrack
     */
    private fun resetAudioTrack(newFormat: MediaFormat?) {
        try {
            if (newFormat == null) {
                Log.w(TAG, "无法重置AudioTrack: 格式为null")
                return
            }
            
            // 更新采样率和声道数
            if (newFormat.containsKey(MediaFormat.KEY_SAMPLE_RATE)) {
                sampleRate = newFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE)
            }
            
            if (newFormat.containsKey(MediaFormat.KEY_CHANNEL_COUNT)) {
                channelCount = newFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
            }
            
            Log.d(TAG, "重置AudioTrack: 采样率=$sampleRate, 声道数=$channelCount")
            
            // 停止并释放旧的AudioTrack
            audioTrack?.let { track ->
                try {
                    if (track.state == AudioTrack.STATE_INITIALIZED) {
                        track.stop()
                    }
                    track.release()
                } catch (e: Exception) {
                    Log.e(TAG, "释放旧AudioTrack失败", e)
                }
            }
            
            // 重新初始化AudioTrack
            initAudioTrack()
            
            Log.d(TAG, "AudioTrack已重置")
        } catch (e: Exception) {
            Log.e(TAG, "重置AudioTrack失败", e)
        }
    }
} 



package com.ld.sqysj.network

import android.util.Log
import com.ld.sqysj.common.AppConstants
import com.ld.sqysj.decoder.H264Decoder
import com.ld.sqysj.AudioDecoder
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import okhttp3.*
import okio.ByteString
import org.json.JSONObject

class WebSocketManager {
    private var webSocket: WebSocket? = null
    private var decoder: H264Decoder? = null
    private var audioDecoder: AudioDecoder? = null
    private var isConnected: Boolean = false
    private var onLatencyResponse: ((Long) -> Unit)? = null
    private var onEncoderInfo: ((String) -> Unit)? = null
    
    companion object {
        private const val TAG = "WebSocketManager"
    }

    fun connect(
        urlParam: String,
        decoder: H264Decoder,
        audioDecoder: AudioDecoder?,
        scope: CoroutineScope,
        onConnectionStateChanged: (Boolean) -> Unit
    ) {
        this.decoder = decoder
        this.audioDecoder = audioDecoder
        
        val client = OkHttpClient()
        val request = Request.Builder()
            .url(AppConstants.WEBSOCKET_BASE_URL + urlParam)
            .build()

        connectInternal(request, scope, onConnectionStateChanged)
    }

    fun connectWithFullUrl(
        fullUrl: String,
        decoder: H264Decoder,
        audioDecoder: AudioDecoder?,
        scope: CoroutineScope,
        onConnectionStateChanged: (Boolean) -> Unit
    ) {
        this.decoder = decoder
        this.audioDecoder = audioDecoder
        
        val client = OkHttpClient()
        val request = Request.Builder()
            .url(fullUrl)
            .build()

        connectInternal(request, scope, onConnectionStateChanged)
    }

    private fun connectInternal(
        request: Request,
        scope: CoroutineScope,
        onConnectionStateChanged: (Boolean) -> Unit
    ) {
        val client = OkHttpClient()
        webSocket = client.newWebSocket(request, object : WebSocketListener() {
            override fun onOpen(webSocket: WebSocket, response: Response) {
                scope.launch {
                    isConnected = true
                    onConnectionStateChanged(true)
                    Log.d(TAG, "onOpen: Connection established.")
                }
            }

            override fun onMessage(webSocket: WebSocket, text: String) {
                Log.d(TAG, "onMessage: Received text message: $text")
                handleTextMessage(text)
            }

            override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
                val dataArray = bytes.toByteArray()
                
                // 优化：减少日志输出，避免性能影响
                if (dataArray.size <= 4) {
                    // 小数据包，直接发送给音频解码器
                    audioDecoder?.processAudioData(dataArray)
                    return
                }
                
                // 优化：简化H.264检测逻辑，提高效率
                val isH264 = when {
                    dataArray.size >= 4 && dataArray[0] == 0.toByte() && dataArray[1] == 0.toByte() && 
                    dataArray[2] == 0.toByte() && dataArray[3] == 1.toByte() -> true
                    dataArray.size >= 3 && dataArray[0] == 0.toByte() && dataArray[1] == 0.toByte() && 
                    dataArray[2] == 1.toByte() -> true
                    else -> false
                }
                
                if (isH264) {
                    // 视频数据 - 直接处理，减少日志
                    decoder?.onFrame(dataArray)
                } else {
                    // 音频数据 - 异步处理，避免阻塞
                    audioDecoder?.processAudioData(dataArray)
                }
            }

            override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
                Log.d(TAG, "onClosing: Peer is closing: $code / $reason")
            }

            override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
                scope.launch {
                    isConnected = false
                    onConnectionStateChanged(false)
                    decoder?.release()
                    Log.d(TAG, "onClosed: Connection confirmed closed.")
                }
            }

            override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
                scope.launch {
                    isConnected = false
                    onConnectionStateChanged(false)
                    decoder?.release()
                    Log.e(TAG, "onFailure: Connection failed.", t)
                }
            }
        })
    }

    fun disconnect() {
        Log.d(TAG, "开始断开WebSocket连接")
        
        try {
            // 取消WebSocket连接
            webSocket?.cancel()
            webSocket = null
            
            // 释放视频解码器
            decoder?.release()
            decoder = null
            
            // 释放音频解码器
            audioDecoder?.dispose()
            audioDecoder = null
            
            // 重置连接状态
            isConnected = false
            
            // 清理回调
            onLatencyResponse = null
            onEncoderInfo = null
            
            Log.d(TAG, "WebSocket连接断开完成")
        } catch (e: Exception) {
            Log.e(TAG, "断开WebSocket连接时出现异常", e)
        }
    }

    fun isConnected(): Boolean = isConnected

    /**
     * 设置延迟响应回调
     */
    fun setLatencyResponseCallback(callback: (Long) -> Unit) {
        onLatencyResponse = callback
    }
    
    /**
     * 设置编码器信息回调
     */
    fun setEncoderInfoCallback(callback: (String) -> Unit) {
        onEncoderInfo = callback
    }

    /**
     * 处理文本消息
     */
    private fun handleTextMessage(text: String) {
        try {
            val jsonMessage = JSONObject(text)
            
            // 检查是否包含延迟测量响应字段
            if (jsonMessage.has("now") && jsonMessage.has("timestamp")) {
                // 延迟测量响应
                val serverTimestamp = jsonMessage.optLong("now", 0)
                if (serverTimestamp > 0) {
                    onLatencyResponse?.invoke(serverTimestamp)
                    Log.d(TAG, "处理延迟测量响应: now=$serverTimestamp")
                }
                return
            }
            
            val msgType = jsonMessage.optInt("msg_type", -1)
            when (msgType) {
                1001 -> {
                    // 延迟测量请求
                    Log.d(TAG, "收到延迟测量请求")
                }
                200 -> {
                    // 编码器信息
                    val encoder = jsonMessage.optString("encoder", "")
                    if (encoder.isNotEmpty()) {
                        onEncoderInfo?.invoke(encoder)
                        Log.d(TAG, "收到编码器信息: $encoder")
                    }
                }
                else -> {
                    Log.d(TAG, "收到未处理的消息类型: $msgType")
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "处理文本消息失败: $text", e)
        }
    }

    /**
     * 发送消息到WebSocket
     */
    fun sendMessage(message: String): Boolean {
        return if (isConnected && webSocket != null) {
            val success = webSocket!!.send(message)
            if (success) {
                Log.d(TAG, "消息发送成功: $message")
            } else {
                Log.e(TAG, "消息发送失败: $message")
            }
            success
        } else {
            Log.w(TAG, "WebSocket未连接，无法发送消息: $message")
            false
        }
    }
}


package com.ld.sqysj.ui.components

import android.app.Activity
import android.content.pm.ActivityInfo
import android.util.Log
import android.view.Surface
import android.view.SurfaceHolder
import android.view.SurfaceView
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.viewinterop.AndroidView
import android.content.res.Configuration
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.windowInsetsPadding
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import com.ld.sqysj.R
import com.ld.sqysj.common.AppConstants
import com.ld.sqysj.decoder.H264Decoder
import com.ld.sqysj.network.WebSocketManager
import com.ld.sqysj.manager.TouchEventHandler
import com.ld.sqysj.ui.components.FloatingControlBall
import com.ld.sqysj.AudioDecoder
import com.ld.sqysj.CloudDiskActivity
import kotlinx.coroutines.launch
import kotlinx.coroutines.delay

@Composable
fun VideoStreamingScreen(
    wsUrl: String = "",
    deviceNickName: String = "云手机",
    deviceDesignation: String = "",
    userId: String = "",
    phoneId: String = ""
) {
    var isConnected by remember { mutableStateOf(false) }
    var isLoading by remember { mutableStateOf(true) }
    var isVideoReady by remember { mutableStateOf(false) }
    val webSocketManager = remember { WebSocketManager() }
    val decoderRef = remember { mutableStateOf<H264Decoder?>(null) }
    val audioDecoderRef = remember { mutableStateOf<AudioDecoder?>(null) }
    var surfaceRef by remember { mutableStateOf<Surface?>(null) }
    var isLandscape by remember { mutableStateOf(false) }
    var touchEventHandler by remember { mutableStateOf<TouchEventHandler?>(null) }
    
    // 显示模式状态：true为全屏模式，false为等比例模式
    var isFullScreenMode by remember { mutableStateOf(false) }
    
    // 音频开关状态
    var isAudioEnabled by remember { mutableStateOf(true) }
    
    // 视频分辨率状态
    var videoWidth by remember { mutableStateOf(1920) }
    var videoHeight by remember { mutableStateOf(1080) }
    // 视频尺寸是否已初始化
    var isVideoSizeReady by remember { mutableStateOf(false) }

    val scope = rememberCoroutineScope()
    val lifecycleOwner = LocalLifecycleOwner.current
    val context = LocalContext.current
    val configuration = LocalConfiguration.current
    
    // 屏幕方向变化处理函数
    val handleOrientationChange: (Boolean) -> Unit = { landscape: Boolean ->
        Log.d("VideoStreamingScreen", "Orientation change requested: ${if (landscape) "横屏" else "竖屏"}")
        
        // 立即更新方向状态，避免UI计算错误
        isLandscape = landscape
        
        // 异步处理Activity方向变化
        scope.launch {
            // 设置Activity的屏幕方向
            (context as? Activity)?.let { activity ->
                activity.requestedOrientation = if (landscape) {
                    ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
                } else {
                    ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
                }
            }
            
            Log.d("VideoStreamingScreen", "Orientation state updated: ${if (landscape) "横屏" else "竖屏"}")
        }
    }
    
    // 自动连接函数