直播

dependencies {
    // Compose
    implementation(platform("androidx.compose:compose-bom:2024.04.01"))
    implementation("androidx.compose.ui:ui")
    implementation("androidx.compose.material3:material3")
    
    // CameraX
    implementation("androidx.camera:camera-camera2:1.3.2")
    implementation("androidx.camera:camera-lifecycle:1.3.2")
    implementation("androidx.camera:camera-view:1.3.2")
    
    // 推流（基于 RTMP）
    implementation("com.rtmpstreamer:rtmp-stream-client:1.0.0") // 第三方RTMP推流库
    
    // 拉流播放（ExoPlayer）
    implementation("com.google.android.exoplayer:exoplayer:2.19.1")
    implementation("com.google.android.exoplayer:exoplayer-hls:2.19.1")
    implementation("com.google.android.exoplayer:exoplayer-flv:2.19.1")
    
    // WebSocket
    implementation("org.java-websocket:Java-WebSocket:1.5.4")
    
    // 网络
    implementation("com.squareup.okhttp3:okhttp:4.12.0")
}

@Composable
fun LivePushScreen(roomId: String, userId: String) {
    val context = LocalContext.current
    val coroutineScope = rememberCoroutineScope()
    var isPushing by remember { mutableStateOf(false) }
    val rtmpUrl = "rtmp://你的服务器IP:1935/live/$roomId"
    
    // CameraX 预览
    val previewView = remember { PreviewView(context) }
    LaunchedEffect(Unit) {
        // 初始化 CameraX
        val cameraProviderFuture = ProcessCameraProvider.getInstance(context)
        cameraProviderFuture.addListener({
            val cameraProvider = cameraProviderFuture.get()
            val preview = Preview.Builder().build().also {
                it.setSurfaceProvider(previewView.surfaceProvider)
            }
            // 绑定相机
            cameraProvider.bindToLifecycle(
                (context as LifecycleOwner),
                CameraSelector.DEFAULT_FRONT_CAMERA,
                preview
            )
        }, ContextCompat.getMainExecutor(context))
    }

    Column(
        modifier = Modifier.fillMaxSize(),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        // 相机预览
        AndroidView(
            factory = { previewView },
            modifier = Modifier
                .fillMaxWidth()
                .weight(1f)
        )
        
        // 推流控制按钮
        Button(
            onClick = {
                coroutineScope.launch {
                    if (!isPushing) {
                        // 开始推流
                        RTMPStreamClient.startPush(
                            url = rtmpUrl,
                            previewView = previewView,
                            audioSource = AudioSource.MIC,
                            videoEncoder = VideoEncoder.H264_HARDWARE
                        )
                        isPushing = true
                    } else {
                        // 停止推流
                        RTMPStreamClient.stopPush()
                        isPushing = false
                    }
                }
            },
            modifier = Modifier.padding(16.dp)
        ) {
            Text(if (isPushing) "停止直播" else "开始直播")
        }
    }
}

// 简易 RTMP 推流客户端（封装）
object RTMPStreamClient {
    private var rtmpPublisher: RTMPPublisher? = null

    fun startPush(
        url: String,
        previewView: PreviewView,
        audioSource: AudioSource,
        videoEncoder: VideoEncoder
    ) {
        rtmpPublisher = RTMPPublisher.Builder()
            .setUrl(url)
            .setPreviewView(previewView)
            .setAudioSource(audioSource)
            .setVideoEncoder(videoEncoder)
            .setVideoSize(1280, 720)
            .setFps(30)
            .build()
        rtmpPublisher?.start()
    }

    fun stopPush() {
        rtmpPublisher?.stop()
        rtmpPublisher = null
    }
}

@Composable
fun LivePullScreen(roomId: String) {
    val context = LocalContext.current
    val coroutineScope = rememberCoroutineScope()
    var messageText by remember { mutableStateOf("") }
    val messageList = remember { mutableStateListOf<String>() }
    
    // ExoPlayer 初始化
    val exoPlayer = remember {
        ExoPlayer.Builder(context)
            .build()
            .apply {
                val mediaItem = MediaItem.fromUri("http://你的服务器IP:8080/live/$roomId.flv")
                setMediaItem(mediaItem)
                prepare()
                play()
            }
    }
    
    // WebSocket 连接（弹幕/聊天）
    LaunchedEffect(roomId) {
        val webSocket = WebSocketClient(URI("ws://你的服务器IP:8080/ws/room/$roomId"))
        webSocket.connect()
        
        // 接收消息
        webSocket.setWebSocketListener(object : WebSocketListener() {
            override fun onMessage(webSocket: WebSocket, message: String) {
                coroutineScope.launch(Dispatchers.Main) {
                    messageList.add(message)
                }
            }
        })
        
        // 销毁时关闭连接
        onDispose {
            webSocket.close()
        }
    }

    Column(modifier = Modifier.fillMaxSize()) {
        // 视频播放
        AndroidView(
            factory = {
                StyledPlayerView(it).apply {
                    player = exoPlayer
                    useController = true
                }
            },
            modifier = Modifier
                .fillMaxWidth()
                .weight(1f)
        )
        
        // 弹幕/聊天区域
        LazyColumn(
            modifier = Modifier
                .fillMaxWidth()
                .weight(0.3f)
        ) {
            items(messageList) { msg ->
                Text(text = msg, modifier = Modifier.padding(8.dp))
            }
        }
        
        // 发送消息
        Row(modifier = Modifier.padding(8.dp)) {
            OutlinedTextField(
                value = messageText,
                onValueChange = { messageText = it },
                modifier = Modifier.weight(1f)
            )
            Button(
                onClick = {
                    // 发送WebSocket消息
                    coroutineScope.launch {
                        val webSocket = WebSocketClient(URI("ws://你的服务器IP:8080/ws/room/$roomId"))
                        webSocket.connectBlocking()
                        webSocket.send(messageText)
                        messageText = ""
                    }
                },
                modifier = Modifier.padding(start = 8.dp)
            ) {
                Text("发送")
            }
        }
    }
    
    // 生命周期管理
    DisposableEffect(Unit) {
        onDispose {
            exoPlayer.stop()
            exoPlayer.release()
        }
    }
}

@Composable
fun RoomListScreen(navController: NavController) {
    val context = LocalContext.current
    val roomList = remember { mutableStateListOf<Room>() }
    
    // 加载房间列表
    LaunchedEffect(Unit) {
        val okHttpClient = OkHttpClient()
        val request = Request.Builder()
            .url("http://你的服务器IP:8080/api/room/list")
            .build()
        val response = okHttpClient.newCall(request).execute()
        val responseBody = response.body?.string()
        // 解析JSON（简化示例，实际用Gson/Moshi）
        val rooms = Gson().fromJson(responseBody, Array<Room>::class.java).toList()
        roomList.addAll(rooms)
    }

    LazyColumn(modifier = Modifier.fillMaxSize()) {
        items(roomList) { room ->
            ListItem(
                headlineContent = { Text(room.title) },
                supportingContent = { Text("主播：${room.userId}") },
                modifier = Modifier
                    .clickable {
                        // 进入拉流页面
                        navController.navigate("live/pull/${room.roomId}")
                    }
                    .padding(8.dp)
            )
        }
    }
    
    // 创建房间按钮
    FloatingActionButton(
        onClick = {
            // 跳转到推流页面（简化：直接生成房间ID）
            val roomId = UUID.randomUUID().toString().substring(0, 8)
            navController.navigate("live/push/$roomId/user123")
        },
        modifier = Modifier
            .align(Alignment.BottomEnd)
            .padding(16.dp)
    ) {
        Icon(Icons.Default.Add, contentDescription = "创建房间")
    }
}

// 房间实体
data class Room(
    val roomId: String,
    val userId: String,
    val title: String,
    val createTime: String,
    val liveStatus: Boolean
)