tg-live-game-web/src/views/live-stream/composables/useStreamControl.ts

import { ref, type Ref } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import { useI18n } from 'vue-i18n'
import { startStreamTask, stopStreamTask, getStreamPlayback } from '@/api/stream-push'
import type { LiveStreamDTO } from '@/types'
import type { PlaybackInfo } from '../types'

export function useStreamControl(
  currentMediaStream: Ref<LiveStreamDTO | null>,
  playbackInfo: Ref<PlaybackInfo>,
  getList: () => Promise<void> | void
) {
  const { t } = useI18n({ useScope: 'global' })

  const streamStarting = ref(false)
  const streamStopping = ref(false)

  async function handleToggleStream(row: LiveStreamDTO, val: boolean) {
    if (val) {
      await handleStartStream(row)
    } else {
      await handleStopStream(row)
    }
  }

  async function handleStartStream(row: LiveStreamDTO) {
    if (!row.cameraId) {
      ElMessage.warning(t('请先配置摄像头'))
      return
    }

    row._starting = true
    try {
      const res = await startStreamTask({
        name: row.name,
        lssId: row.lssId,
        cameraId: row.cameraId,
        commandTemplate: row.commandTemplate
      })
      if (res.success) {
        ElMessage.success(t('推流任务已启动'))
        getList()
      } else {
        ElMessage.error(res.errMessage || t('启动失败'))
      }
    } catch (error) {
      console.error('启动推流失败', error)
      ElMessage.error(t('启动推流失败'))
    } finally {
      row._starting = false
    }
  }

  async function handleStartStreamFromPlayer() {
    if (!currentMediaStream.value) return

    if (!currentMediaStream.value.cameraId) {
      ElMessage.warning(t('请先配置摄像头'))
      return
    }

    streamStarting.value = true
    try {
      const res = await startStreamTask({
        name: currentMediaStream.value.name,
        lssId: currentMediaStream.value.lssId,
        cameraId: currentMediaStream.value.cameraId,
        commandTemplate: currentMediaStream.value.commandTemplate
      })
      if (res.success) {
        ElMessage.success(t('推流任务已启动'))
        currentMediaStream.value.status = '1'
        if (currentMediaStream.value.streamSn) {
          try {
            const playbackRes = await getStreamPlayback(currentMediaStream.value.streamSn)
            if (playbackRes.success && playbackRes.data) {
              playbackInfo.value = {
                ...playbackInfo.value,
                hlsUrl: playbackRes.data.hlsUrl,
                whepUrl: playbackRes.data.whepUrl,
                isLive: playbackRes.data.isLive
              }
            }
          } catch (e) {
            console.error('刷新播放信息失败', e)
          }
        }
        getList()
      } else {
        ElMessage.error(res.errMessage || t('启动失败'))
      }
    } catch (error) {
      console.error('启动推流失败', error)
      ElMessage.error(t('启动推流失败'))
    } finally {
      streamStarting.value = false
    }
  }

  async function handleStopStreamFromPlayer() {
    if (!currentMediaStream.value) return

    try {
      await ElMessageBox.confirm(t('确定要停止该推流任务吗？'), t('提示'), {
        type: 'warning',
        confirmButtonText: t('确定'),
        cancelButtonText: t('取消')
      })

      streamStopping.value = true
      const res = await stopStreamTask({
        taskId: currentMediaStream.value.taskStreamSn,
        lssId: currentMediaStream.value.lssId
      })
      if (res.success) {
        ElMessage.success(t('推流任务已停止'))
        currentMediaStream.value.status = '0'
        playbackInfo.value.isLive = false
        getList()
      } else {
        ElMessage.error(res.errMessage || t('停止失败'))
      }
    } catch (error) {
      if (error !== 'cancel') {
        console.error('停止推流失败', error)
        ElMessage.error(t('停止推流失败'))
      }
    } finally {
      streamStopping.value = false
    }
  }

  async function handleStopStream(row: LiveStreamDTO) {
    try {
      await ElMessageBox.confirm(t('确定要停止该推流任务吗？'), t('提示'), {
        type: 'warning',
        confirmButtonText: t('确定'),
        cancelButtonText: t('取消')
      })

      row._stopping = true
      const res = await stopStreamTask({ taskId: row.taskStreamSn, lssId: row.lssId })
      if (res.success) {
        ElMessage.success(t('推流任务已停止'))
        getList()
      } else {
        ElMessage.error(res.errMessage || t('停止失败'))
      }
    } catch (error) {
      if (error !== 'cancel') {
        console.error('停止推流失败', error)
        ElMessage.error(t('停止推流失败'))
      }
    } finally {
      row._stopping = false
    }
  }

  return {
    streamStarting,
    streamStopping,
    handleToggleStream,
    handleStartStream,
    handleStopStream,
    handleStartStreamFromPlayer,
    handleStopStreamFromPlayer
  }
}