import type { ImRtcApi } from '#/api/im/rtc'
|
|
import { computed, ref } from 'vue'
|
|
import { defineStore } from 'pinia'
|
|
import { getCurrentUserId } from '#/views/im/utils/auth'
|
|
import {
|
ImConversationType,
|
type ImRtcCallEndReasonValue,
|
ImRtcCallStage,
|
type ImRtcCallStageValue,
|
ImRtcCallStatus,
|
type ImRtcParticipantStatusValue
|
} from '../../utils/constants'
|
import { useFriendStore } from './friendStore'
|
import { useGroupStore } from './groupStore'
|
|
type GroupActiveCallCache = {
|
participantsLoaded?: boolean // 是否已拉取完整参与者列表
|
} & ImRtcApi.RtcGroupCallRespVO
|
|
// RTC_CALL 通话信令载荷；按 status 区分子类型语义
|
export interface ImRtcCallNotification {
|
status: ImRtcParticipantStatusValue
|
room: string
|
conversationType: number
|
mediaType: number
|
groupId?: number
|
// INVITE 专属：被叫接通需要的 LiveKit 连接参数 + 主叫展示信息
|
livekitUrl?: string
|
token?: string
|
inviterUserId?: number
|
inviterNickname?: string
|
inviterAvatar?: string
|
// INVITE 专属：本次被邀请人列表；包含收件人自身，前端来电小条按需过滤展示「邀请的其他人」
|
inviteeIds?: number[]
|
// REJECT 专属：操作者展示信息（其它子类型走 RTC_CALL_END）
|
operatorUserId?: number
|
operatorNickname?: string
|
operatorAvatar?: string
|
}
|
|
// RTC_PARTICIPANT_CONNECTED 通话参与者加入载荷（LiveKit webhook 转推）
|
export interface ImRtcParticipantConnectedNotification {
|
room: string
|
userId: number
|
conversationType: number
|
groupId?: number
|
// 群聊场景非邀请成员首次填充胶囊条用
|
mediaType?: number
|
inviterUserId?: number
|
}
|
|
// RTC_PARTICIPANT_DISCONNECTED 通话参与者离开载荷（LiveKit webhook 转推）
|
export interface ImRtcParticipantDisconnectedNotification {
|
room: string
|
userId: number
|
conversationType: number
|
groupId?: number
|
}
|
|
// RTC_CALL_END 通话结束载荷（入消息流；私聊渲染消息气泡，群聊渲染系统提示行）
|
export interface ImRtcCallEndNotification {
|
room: string
|
conversationType: number
|
mediaType: number
|
endReason: ImRtcCallEndReasonValue
|
durationSeconds?: number
|
// 操作者聚合字段：HANGUP/CANCEL/REJECT 触发人；webhook 兜底为 null
|
operatorUserId?: number
|
operatorNickname?: string
|
operatorAvatar?: string
|
}
|
|
export const useRtcStore = defineStore('imRtc', () => {
|
/** 当前阶段 */
|
const stage = ref<ImRtcCallStageValue>(ImRtcCallStage.IDLE)
|
/** 当前通话；invite / accept / refreshToken 拿到的完整信息 */
|
const call = ref<ImRtcApi.RtcCallRespVO | null>(null)
|
/** 来电载荷；仅 INCOMING 阶段使用；status 固定 INVITING，其它字段 INVITE 专属 */
|
const incomingPayload = ref<ImRtcCallNotification | null>(null)
|
/** 进入 RUNNING 的时间戳；用于通话时长展示；reset 时清零 */
|
const startedAt = ref(0)
|
|
/** 是否处于通话相关阶段 */
|
const isActive = computed(() => stage.value !== ImRtcCallStage.IDLE)
|
|
/**
|
* 对端展示名；按阶段 + 会话类型分支：
|
* INCOMING 取来电载荷的 inviterNickname；群通话取群名；私聊查 friendStore 反查对端 userId
|
*/
|
const peerNickname = computed<string>(() => {
|
if (stage.value === ImRtcCallStage.INCOMING) {
|
return incomingPayload.value?.inviterNickname || ''
|
}
|
const c = call.value
|
if (!c) return ''
|
if (c.conversationType === ImConversationType.GROUP) {
|
return useGroupStore().getGroup(c.groupId ?? 0)?.name || ''
|
}
|
const peerUserId = resolvePrivatePeerUserId(c)
|
return (peerUserId && useFriendStore().getFriend(peerUserId)?.nickname) || ''
|
})
|
|
/** 对端头像；策略同 peerNickname */
|
const peerAvatar = computed<string>(() => {
|
if (stage.value === ImRtcCallStage.INCOMING) {
|
return incomingPayload.value?.inviterAvatar || ''
|
}
|
const c = call.value
|
if (!c) return ''
|
if (c.conversationType === ImConversationType.GROUP) {
|
return useGroupStore().getGroup(c.groupId ?? 0)?.avatar || ''
|
}
|
const peerUserId = resolvePrivatePeerUserId(c)
|
return (peerUserId && useFriendStore().getFriend(peerUserId)?.avatar) || ''
|
})
|
|
/** 私聊场景对端 userId：自己是主叫则取首个 invitee，否则取 inviter */
|
function resolvePrivatePeerUserId(c: ImRtcApi.RtcCallRespVO): number | undefined {
|
const myId = getCurrentUserId()
|
return c.inviterId === myId ? c.inviteeIds?.[0] : c.inviterId
|
}
|
|
/** 群活跃通话索引；groupId -> 群通话摘要；用于群聊顶部胶囊条 */
|
const groupActiveCalls = ref<Map<number, GroupActiveCallCache>>(new Map())
|
|
/**
|
* 已退出 / 已拒绝的用户编号集合；群通话场景内 pending 占位渲染时排除；
|
* 来源：参与者离开通知 + 群通话单人拒绝的 operatorUserId；通话结束（reset）时清空
|
*/
|
const leftUserIds = ref<Set<number>>(new Set())
|
|
/** 是否已记录某 userId 已退出 / 拒绝 */
|
function isUserLeft(userId: number): boolean {
|
return leftUserIds.value.has(userId)
|
}
|
|
/** 标记某个 userId 已退出 / 拒绝；用于 pending 占位渲染时排除 */
|
function markUserLeft(userId: number) {
|
if (!userId || leftUserIds.value.has(userId)) {
|
return
|
}
|
leftUserIds.value = new Set([...leftUserIds.value, userId])
|
}
|
|
/**
|
* 主叫发起通话；按会话类型 + status 决定 stage；
|
* 群通话：发起人直接进 RUNNING 多人卡片视图，房内可能只有自己，等其他人陆续加入；
|
* 私聊：按 status 走；RUNNING（已加入已有通话场景）→ RUNNING；CREATED → INVITING 等被叫接通
|
*/
|
function startInviting(data: ImRtcApi.RtcCallRespVO) {
|
call.value = data
|
// 群通话场景写入本地胶囊条缓存
|
syncGroupActiveCall(data)
|
// 更新 stage 状态
|
if (data.conversationType === ImConversationType.GROUP) {
|
stage.value = ImRtcCallStage.RUNNING
|
startedAt.value = Date.now()
|
return
|
}
|
const running = data.status === ImRtcCallStatus.RUNNING
|
stage.value = running ? ImRtcCallStage.RUNNING : ImRtcCallStage.INVITING
|
if (running) {
|
startedAt.value = Date.now()
|
}
|
}
|
|
/** 被叫收到来电；切到 INCOMING；接收 RTC_CALL(INVITE) payload */
|
function showIncoming(payload: ImRtcCallNotification) {
|
if (isActive.value) {
|
return
|
}
|
incomingPayload.value = payload
|
stage.value = ImRtcCallStage.INCOMING
|
// 按 inviter 兜底首次填充胶囊条
|
syncGroupActiveCall({
|
conversationType: payload.conversationType,
|
room: payload.room,
|
groupId: payload.groupId,
|
mediaType: payload.mediaType,
|
inviterId: payload.inviterUserId ?? 0,
|
joinedUserIds: payload.inviterUserId ? [payload.inviterUserId] : [],
|
inviteeIds: payload.inviteeIds
|
})
|
}
|
|
/** 进入通话中阶段 */
|
function enterRunning(data: ImRtcApi.RtcCallRespVO) {
|
call.value = data
|
// 离开 INCOMING 阶段；清空来电载荷
|
incomingPayload.value = null
|
stage.value = ImRtcCallStage.RUNNING
|
startedAt.value = Date.now()
|
// 接通后用 RespVO 完整覆盖胶囊条
|
syncGroupActiveCall(data)
|
}
|
|
/**
|
* 群通话场景同步本地 groupActiveCalls 缓存；非群通话或缺 groupId 直接返回；
|
* 不依赖后端 webhook 推送的 RTC_PARTICIPANT_CONNECTED 首次填充，避免胶囊条出现延迟；
|
* 被叫场景通知载荷无 joinedUserIds，调用方按主叫人兜底，后续 getActiveCall / 参与者事件刷新成完整列表
|
*/
|
function syncGroupActiveCall(input: {
|
conversationType: number
|
groupId?: number
|
inviteeIds?: number[]
|
inviterId: number
|
joinedUserIds?: number[]
|
mediaType: number
|
room: string
|
}) {
|
if (input.conversationType !== ImConversationType.GROUP || !input.groupId) {
|
return
|
}
|
// 写入或更新群活跃通话缓存
|
setGroupCall({
|
room: input.room,
|
groupId: input.groupId,
|
mediaType: input.mediaType,
|
inviterId: input.inviterId,
|
joinedUserIds: input.joinedUserIds ?? [],
|
inviteeIds: input.inviteeIds ?? []
|
})
|
}
|
|
/** 重置；通话结束统一调用 */
|
function reset() {
|
stage.value = ImRtcCallStage.IDLE
|
call.value = null
|
incomingPayload.value = null
|
startedAt.value = 0
|
leftUserIds.value = new Set()
|
}
|
|
/** 通话中追加被邀请人；让 participants 网格出现 pending 占位、胶囊条同步更新 */
|
function appendInvitees(userIds: number[]) {
|
if (!call.value || userIds.length === 0) {
|
return
|
}
|
const existing = call.value.inviteeIds ?? []
|
const merged = [...new Set([...existing, ...userIds])]
|
if (merged.length === existing.length) {
|
return
|
}
|
call.value = { ...call.value, inviteeIds: merged }
|
syncGroupActiveCall(call.value)
|
}
|
|
// ==================== 群通话胶囊条状态 ====================
|
|
/**
|
* 群通话开始 / 状态刷新：写入 / 更新 groupActiveCalls；展示用「胶囊条」；
|
* 房内成员同步交给 LiveKit 客户端事件（ParticipantConnected / Disconnected）；
|
* 胶囊条不实时刷新 joinedUserIds / inviteeIds，展开 / 加入时再走 getActiveCall 接口拉最新
|
*/
|
function setGroupCall(payload: ImRtcApi.RtcGroupCallRespVO, participantsLoaded?: boolean) {
|
if (!payload?.groupId) {
|
return
|
}
|
useGroupStore().markGroupActiveCallLoaded(payload.groupId)
|
// 浅比较：room / mediaType / joinedUserIds / inviteeIds 都没变就跳过，避免下游 watcher 无意义重算
|
const existing = groupActiveCalls.value.get(payload.groupId)
|
const nextParticipantsLoaded =
|
participantsLoaded ?? (existing?.room === payload.room && !!existing.participantsLoaded)
|
if (
|
existing &&
|
isSameGroupCall(existing, payload) &&
|
!!existing.participantsLoaded === nextParticipantsLoaded
|
) {
|
return
|
}
|
const newGroupActiveCalls = new Map(groupActiveCalls.value)
|
newGroupActiveCalls.set(payload.groupId, {
|
...payload,
|
participantsLoaded: nextParticipantsLoaded
|
})
|
groupActiveCalls.value = newGroupActiveCalls
|
}
|
|
/** 清空指定群的通话缓存 */
|
function clearGroupCallCache(groupId?: number) {
|
if (!groupId) {
|
groupActiveCalls.value = new Map()
|
return
|
}
|
const next = new Map(groupActiveCalls.value)
|
next.delete(groupId)
|
groupActiveCalls.value = next
|
}
|
|
/** 判断群通话是否已补齐 */
|
function isGroupCallParticipantsLoaded(groupId: number, room?: string): boolean {
|
const call = groupActiveCalls.value.get(groupId)
|
return (
|
!!groupId &&
|
!!room &&
|
!!call &&
|
call.room === room &&
|
!!call.participantsLoaded
|
)
|
}
|
|
/** 两条群通话摘要内容相等（room / mediaType / inviterId / 两个 userId 数组逐项相等） */
|
function isSameGroupCall(a: ImRtcApi.RtcGroupCallRespVO, b: ImRtcApi.RtcGroupCallRespVO): boolean {
|
if (a.room !== b.room || a.mediaType !== b.mediaType || a.inviterId !== b.inviterId) {
|
return false
|
}
|
return isSameNumberList(a.joinedUserIds ?? [], b.joinedUserIds ?? []) &&
|
isSameNumberList(a.inviteeIds ?? [], b.inviteeIds ?? [])
|
}
|
|
/** 判断两个用户编号列表是否逐项相等 */
|
function isSameNumberList(a: number[], b: number[]): boolean {
|
if (a.length !== b.length) {
|
return false
|
}
|
return a.every((item, index) => item === b[index])
|
}
|
|
/** 群通话结束：从 groupActiveCalls 移除；胶囊条消失 */
|
function removeGroupCall(groupId: number, room?: string) {
|
if (!groupId) {
|
return
|
}
|
const existing = groupActiveCalls.value.get(groupId)
|
if (room && existing?.room !== room) {
|
return
|
}
|
clearGroupCallCache(groupId)
|
useGroupStore().markGroupActiveCallLoaded(groupId)
|
}
|
|
/** 获取群当前活跃通话；用于胶囊条按 groupId 查询 */
|
function getGroupCall(groupId: number): ImRtcApi.RtcGroupCallRespVO | undefined {
|
return groupActiveCalls.value.get(groupId)
|
}
|
|
/** 通话参与者加入：把 userId 加进 joinedUserIds；群聊场景无活跃记录时首次填充胶囊条 */
|
function applyParticipantConnected(payload: ImRtcParticipantConnectedNotification) {
|
const isGroup = payload.conversationType === ImConversationType.GROUP
|
if (!isGroup || !payload.groupId) {
|
return
|
}
|
// 胶囊条懒填充：本端可能在通话开始后才打开该群会话，没收到过 setGroupCall；
|
// 此处用加入通知建一条最小记录，inviteeIds 留空，展开 popover / 加入时再走 getActiveCall 补
|
const existing = groupActiveCalls.value.get(payload.groupId)
|
if (!existing) {
|
setGroupCall({
|
room: payload.room,
|
groupId: payload.groupId,
|
mediaType: payload.mediaType ?? 0,
|
inviterId: payload.inviterUserId ?? 0,
|
joinedUserIds: [payload.userId],
|
inviteeIds: []
|
})
|
return
|
}
|
if (existing.room !== payload.room) {
|
return
|
}
|
const joined = existing.joinedUserIds ?? []
|
if (joined.includes(payload.userId)) {
|
return
|
}
|
setGroupCall({ ...existing, joinedUserIds: [...joined, payload.userId] })
|
}
|
|
/** 通话参与者离开：从 joinedUserIds 移除；同时标记 leftUserIds（pending 占位渲染排除） */
|
function applyParticipantDisconnected(payload: ImRtcParticipantDisconnectedNotification) {
|
markUserLeft(payload.userId)
|
const isGroup = payload.conversationType === ImConversationType.GROUP
|
if (!isGroup || !payload.groupId) {
|
return
|
}
|
dropFromGroupActiveCall(payload.groupId, payload.room, payload.userId)
|
}
|
|
/** 群通话单人拒绝邀请：标记 leftUserIds + 从胶囊条 inviteeIds 移除（私聊拒绝走 RTC_CALL_END，不入本通道） */
|
function applyParticipantRejected(
|
payload: Pick<ImRtcCallNotification, 'conversationType' | 'groupId' | 'operatorUserId' | 'room'>
|
) {
|
if (!payload.operatorUserId) {
|
return
|
}
|
markUserLeft(payload.operatorUserId)
|
if (payload.conversationType === ImConversationType.GROUP && payload.groupId) {
|
dropFromGroupActiveCall(payload.groupId, payload.room, payload.operatorUserId)
|
}
|
}
|
|
/** 群通话单人振铃超时；对 banner 的处理与拒接一致（语义独立、实现共享） */
|
function applyParticipantNoAnswer(
|
payload: Pick<ImRtcCallNotification, 'conversationType' | 'groupId' | 'operatorUserId' | 'room'>
|
) {
|
applyParticipantRejected(payload)
|
}
|
|
/** 从指定群活跃通话的 joined / pending 列表里同步移除某用户；用于 disconnect / reject 让胶囊条不再展示 */
|
function dropFromGroupActiveCall(groupId: number, room: string, userId: number) {
|
const existing = groupActiveCalls.value.get(groupId)
|
if (!existing || existing.room !== room) {
|
return
|
}
|
const joined = existing.joinedUserIds ?? []
|
const invitee = existing.inviteeIds ?? []
|
const nextJoined = joined.filter((id) => id !== userId)
|
const nextInvitee = invitee.filter((id) => id !== userId)
|
if (nextJoined.length === joined.length && nextInvitee.length === invitee.length) {
|
return
|
}
|
if (nextJoined.length === 0 && nextInvitee.length === 0) {
|
removeGroupCall(groupId, room)
|
return
|
}
|
setGroupCall({
|
...existing,
|
joinedUserIds: nextJoined,
|
inviteeIds: nextInvitee
|
})
|
}
|
|
return {
|
stage,
|
call,
|
incomingPayload,
|
peerNickname,
|
peerAvatar,
|
startedAt,
|
isActive,
|
startInviting,
|
showIncoming,
|
enterRunning,
|
reset,
|
appendInvitees,
|
markUserLeft,
|
isUserLeft,
|
setGroupCall,
|
isGroupCallParticipantsLoaded,
|
clearGroupCallCache,
|
removeGroupCall,
|
getGroupCall,
|
applyParticipantConnected,
|
applyParticipantDisconnected,
|
applyParticipantRejected,
|
applyParticipantNoAnswer
|
}
|
})
|
