Mobile versionFür Videoanrufe verwende ich LiveKit SDK. Im Moment ist die SDK-Version 2.11.0.
Vielleicht hilft dies zu klären, wo das Problem liegt:
Ein Benutzer drückt die Schaltfläche „Start“, wodurch MatchingViewModel.startMatching() aufgerufen wird. Danach ändert sich „matchingViewModel.connectionState“ in „.searching“. Ein anderer Benutzer drückt „Start“ und das Gleiche passiert.
Dann gibt die API Informationen für beide Benutzer zurück (
Code: Select all
myInfoAn diesem Punkt sollte die Verbindung zu LiveKit hergestellt werden.
In der MatchingWrapperView-Datei prüft die Methode „handleChangeRoomIdOrPartners“, ob eine Verbindung zu LiveKit hergestellt werden soll (wenn Partnerinformationen und eine Raum-ID verfügbar sind) oder die Verbindung zum Raum getrennt werden soll (wenn der Partner die Verbindung beendet). Aufruf).
Die connectRoom-Methode verwaltet die Verbindung zum LiveKit-Raum, aktiviert die Kamera und führt emitHasConnectedToLiveKit() aus (
Code: Select all
matchingViewModel.connectionStateBeim Testen von visionOS-Gerät + visionOS-Gerät oder iPhone oder visionOS-Simulator wird das Video vom iPhone meistens nicht auf dem visionOS-Gerät angezeigt. Seltener kommt es vor, dass das Video vom visionOS-Gerät nicht auf dem iPhone oder im Simulator angezeigt wird.
Beim Testen von iPhone + iPhone + visionOS-Simulator funktioniert normalerweise alles einwandfrei. Gelegentlich erscheint das Video nicht, aber das kommt viel seltener vor.
Hier ist der gesamte Code für die Kernfunktionalität. Wenn Sie zusätzlichen Code benötigen, lassen Sie es mich bitte wissen.
RoomModel.swift
Code: Select all
import Combine
import SwiftUI
final class RoomModel: Notifiable, ObservableObject {
@Injected var services: Services
private var cancellables: Set = Set()
var globalManager: RoomGlobalManager?
// var invitesManager: RoomInvitesManager?
// var eventsManager: RoomEventsManager?
@Published private(set) var socketConnected: Bool = false
@Published private(set) var shouldCall: Bool = false
@Published private(set) var roomId: String = ""
@Published private(set) var myInfo: UserProfileModel?
@Published private(set) var partners: [UserProfileModel] = []
@Published private(set) var joinedVideoPartners: [String] = []
@Published private(set) var myLiveKitToken: String = ""
@Published private(set) var timerValue: Int = -1
@Published private(set) var hasExtendedTimer: Bool = false
@Published private(set) var currentMaxTimerValue: Int = AppSettings
.callTimerValue
@Published private(set) var sentConnectUserRequests: [String] = []
@Published private var partnersSentConnectUserRequest: [String] = []
@Published private var friendsUsers: [String] = []
@Published private var usersOnline: [UserOnlineStatusModel] = []
private let socketService = SocketIOService.shared
private let userId: String
private let token: String
init(userId: String, token: String) {
self.userId = userId
self.token = token
setupManagers()
socketService.initSocket(userId: userId, token: token)
}
private func setupManagers() {
self.globalManager = RoomGlobalManager(
roomModel: self,
userId: userId,
token: token
)
// self.invitesManager = RoomInvitesManager(roomModel: self)
// self.eventsManager = RoomEventsManager(roomModel: self)
self.bindService()
}
var notificationModel: OrnamentNotificationModel?
func setNotificationModel(_ model: OrnamentNotificationModel) {
self.notificationModel = model
}
func destroySocket() {
socketService.disconnectAndDestroy()
}
func reset() {
roomId = ""
myInfo = nil
partners = []
joinedVideoPartners = []
myLiveKitToken = ""
timerValue = -1
hasExtendedTimer = false
currentMaxTimerValue = AppSettings.callTimerValue
}
private(set) var settingsViewModel: SettingsViewModel?
func bindSettingsViewModel(_ settingsViewModel: SettingsViewModel) {
self.settingsViewModel = settingsViewModel
}
}
// MARK: Variables
extension RoomModel {
var myId: String {
services.storageService.userProfile?.id ?? ""
}
}
extension RoomModel {
// MARK: Matching
func changeShouldCall(_ shouldCall: Bool) {
self.shouldCall = shouldCall
socketService.changeShouldCall(shouldCall: shouldCall)
UIApplication.shared.isIdleTimerDisabled = shouldCall
}
func endCall() {
self.changeShouldCall(false)
socketService.sendEnd()
self.reset()
}
func joinedVideo() {
socketService
.joinedVideo(
roomId: self.roomId,
meetTime: self.currentMaxTimerValue
)
}
// MARK: Listeners
private func bindService() {
socketService.onSocketConnected = { [weak self] in
self?.socketConnected = true
self?.changeUserOnline(
isOnline: true,
isBusy: false,
completion: self?.getUsersOnline
)
}
socketService.onSocketDisconnected = { [weak self] in
self?.socketConnected = false
self?.shouldCall = false
}
socketService.onShowNotification = { [weak self] payload in
guard let self = self else { return }
let notificationInfo = RoomModel.decodeNotificationInfo(
from: payload
)
guard let notificationInfo = notificationInfo else { return }
self.notificationModel?.showNotification(
OrnamentNotification(
title: notificationInfo.text,
message: notificationInfo.description,
type: notificationInfo.type,
customData: [
"roomId": self.roomId,
"hideOnEndCall": notificationInfo.hideOnEndCall
?? false,
],
customDuration: notificationInfo.customDuration
)
)
}
socketService.onError = { [weak self] text, description in
self?.notificationModel?.showNotification(
OrnamentNotification(
title: text,
message: description,
type: .error
)
)
SentryService
.sendMessage(
"Received error. Title: \(text) Description: \(description ?? "")"
)
}
// MARK: Matching listeners
socketService.onGetPartnerInfo = { [weak self] payload in
guard let self = self, self.shouldCall else { return }
let roomInfo = RoomModel.decodeRoomInfo(from: payload)
guard let roomInfo = roomInfo else { return }
var shouldUpdate: Bool
if self.partners.isEmpty {
shouldUpdate = true
} else {
let currentIDs = Set(self.partners.map { $0.id })
let newIDs = Set(roomInfo.partners.map { $0.id })
shouldUpdate = currentIDs != newIDs
}
guard shouldUpdate else { return }
self.roomId = roomInfo.roomId
self.myInfo = roomInfo.myInfo
self.partners = roomInfo.partners
self.myLiveKitToken = roomInfo.myLiveKitToken
if let friendIds = roomInfo.myInfo.friendIds, !friendIds.isEmpty {
for friendId in friendIds {
if !self.friendsUsers.contains(friendId) {
self.friendsUsers.append(friendId)
}
}
}
services.storageService.updateUserProfile(
\.matchesCount,
value: myInfo?.matchesCount
)
}
socketService.onPartnerLeft = { [weak self] partnerId in
guard let self = self, self.shouldCall else { return }
self.partners.removeAll {
$0.id == partnerId
}
if self.partners.isEmpty {
self.reset()
}
}
socketService.onPartnerJoinedVideo = { [weak self] userId in
guard let self = self, !userId.isEmpty else { return }
self.joinedVideoPartners.append(userId)
}
// MARK: Timer listeners
socketService.onTimerUpdate = { [weak self] timerValue in
self?.timerValue = timerValue
}
socketService.onTimerExtended = { time in
self.hasExtendedTimer = true
}
socketService.onTimerEnded = { [weak self] in
guard let self = self else { return }
self.reset()
}
// MARK: Users Online listenrs
socketService.onUserOnlineChanged = { [weak self] payload in
guard let self = self,
let userOnlineInfo = RoomModel.decodeUserOnlineInfo(
from: payload
)
else {
return
}
self.updateUserStatus(userOnlineInfo)
}
// MARK: Connect Book listeners
socketService.onConnectedUser = {
[weak self] userId, cancel, isFriends in
guard let self = self, !userId.isEmpty else { return }
if cancel {
self.partnersSentConnectUserRequest
.removeAll(where: { $0 == userId })
} else {
self.partnersSentConnectUserRequest.append(userId)
if self.sentConnectUserRequests.contains(userId) {
let partner = self.partners
.first(where: { $0.id == userId })
if settingsViewModel?.audioSettings?.allSounds == true {
services.soundService.playSound(
named: "Friend-Accepted",
duration: 3
)
}
self.notificationModel?.showNotification(
OrnamentNotification(
title: "Partner has accepted your connection",
type: .success,
contentView: {
AnyView(
AcceptedConnectionNotificationContentView(
user: partner ?? nil
)
)
}
)
)
NotificationCenter.default.post(
name: .didAddFriend,
object: nil,
userInfo: nil
)
}
}
}
socketService.onRemovedUser = { userId in
guard !userId.isEmpty else { return }
NotificationCenter.default.post(
name: .didRemoveUser,
object: nil,
userInfo: ["userId": userId]
)
self.removeFriendLocal(userId: userId)
// self.removeInvitation(fromUserId: userId)
}
}
}
Code: Select all
import Combine
import SwiftUI
final class RoomGlobalManager: ObservableObject {
private weak var roomModel: RoomModel?
let socketService = SocketIOService.shared
private let userId: String
private let token: String
init(roomModel: RoomModel, userId: String, token: String) {
self.roomModel = roomModel
self.userId = userId
self.token = token
}
// MARK: - Matching Methods
func startMatch() {
guard !(roomModel?.shouldCall ?? true) else { return }
roomModel?.changeShouldCall(true)
socketService.connect(userId: userId, token: token)
}
func restartMatch() {
socketService.connect(userId: userId, token: token)
}
func skip(completion: SocketAckCompletion? = nil) {
socketService.sendSkipCall(completion: completion)
roomModel?.reset()
}
}
Code: Select all
import Combine
@preconcurrency import LiveKit
import LiveKitComponents
import SwiftUI
let wsURL = "wss://*****.livekit.cloud"
enum ConnectionState {
case searching // when on waiting room, but play
case connecting // when receive roomID
case connected // users LiveKit connection started
case disconnecting // user has pressed exit/skip
case disconnected // when no lobby
var isNotConnected: Bool {
switch self {
case .disconnecting,
.searching,
.disconnected:
return true
default:
return false
}
}
}
enum ConnectionType {
case global
case invites
case events
}
class MatchingViewModel: NotifiableWrapper, ObservableObject {
@Injected private var services: Services
@Published private(set) var connectionType: ConnectionType? = nil
@Published private(set) var connectionState: ConnectionState = .disconnected
private var globalMatchingViewModel: GlobalMatchingViewModel?
private var currentMatchingViewModel: (any MatchingTypeViewModel)? {
switch connectionType {
case .global:
return globalMatchingViewModel
default:
return nil
}
}
override init() {
super.init()
setupViewModels()
}
private(set) var room: Room?
private(set) var roomModel: RoomModel?
private func setupViewModels() {
globalMatchingViewModel = GlobalMatchingViewModel()
setupStateObservers()
}
private func setupStateObservers() {
globalMatchingViewModel?.onStateChange = { [weak self] state in
self?.handleChildStateChange(.global, state: state)
}
}
func attachRoom(_ room: Room) {
self.room = room
globalMatchingViewModel?.attachRoom(room)
}
func bindSocket(_ roomModel: RoomModel) {
self.roomModel = roomModel
globalMatchingViewModel?.bindSocket(roomModel)
}
override func setNotificationModel(_ model: OrnamentNotificationModel) {
super.setNotificationModel(model)
globalMatchingViewModel?.setNotificationModel(model)
}
func changeConnectionType(_ newType: ConnectionType) {
guard newType != self.connectionType else { return }
if connectionState != .disconnected {
endCall(state: .disconnected, notifyChangeCallStatus: false)
}
self.connectionType = newType
self.connectionState = .disconnected
}
func changeConnectionState(
_ newState: ConnectionState,
connectionType: ConnectionType? = nil
) {
guard newState != self.connectionState else { return }
if let connectionType = connectionType {
self.connectionType = connectionType
}
self.connectionState = newState
}
private func handleChildStateChange(
_ type: ConnectionType,
state: ConnectionState
) {
if self.connectionType == nil {
self.connectionType = type
}
guard self.connectionType == type else { return }
self.connectionState = state
}
}
extension MatchingViewModel {
public func startMatching() {
currentMatchingViewModel?.startMatching()
}
public func skipOrEndCall() {
self.skip()
}
public func skip(completion: SocketAckCompletion? = nil) {
currentMatchingViewModel?.skip(completion: completion)
}
public func endCall(
state: ConnectionState,
notifyChangeCallStatus: Bool? = true
) {
if let currentVM = currentMatchingViewModel {
currentVM.endCall(
state: state,
notifyChangeCallStatus: notifyChangeCallStatus
)
} else {
print("end call - no current VM, executing directly")
DispatchQueue.main.async {
Task {
self.roomModel?.endCall()
await self.room?.disconnect()
self.changeConnectionState(state)
}
}
}
}
func emitHasConnectedToLiveKit() {
self.changeConnectionState(.connected)
roomModel?.joinedVideo()
}
}
protocol MatchingTypeViewModel: ObservableObject {
var onStateChange: ((ConnectionState) -> Void)? { get set }
func startMatching()
func skip(completion: SocketAckCompletion?)
func endCall(state: ConnectionState, notifyChangeCallStatus: Bool?)
}
Code: Select all
import Combine
@preconcurrency import LiveKit
import SwiftUI
class GlobalMatchingViewModel: NotifiableWrapper, MatchingTypeViewModel {
@Injected private var services: Services
var onStateChange: ((ConnectionState) -> Void)?
private(set) var room: Room?
private(set) var roomModel: RoomModel?
override init() {
super.init()
}
func attachRoom(_ room: Room) {
self.room = room
}
func bindSocket(_ roomModel: RoomModel) {
self.roomModel = roomModel
}
private func propagateState(_ newState: ConnectionState) {
onStateChange?(newState)
}
}
extension GlobalMatchingViewModel {
func startMatching() {
roomModel?.globalManager?.startMatch()
}
func skip(completion: SocketAckCompletion? = nil) {
DispatchQueue.main.async {
Task {
self.roomModel?.globalManager?.skip(completion: completion)
await self.room?.disconnect()
}
}
}
func endCall(
state: ConnectionState,
notifyChangeCallStatus: Bool? = true
) {
guard self.roomModel?.shouldCall == true else { return }
DispatchQueue.main.async {
Task {
self.roomModel?.endCall()
await self.room?.disconnect()
self.propagateState(state)
}
}
}
}
Code: Select all
import Combine
@preconcurrency import LiveKit
import LiveKitComponents
import SDWebImageSwiftUI
import SwiftUI
struct MatchingContentView: View {
@EnvironmentObject private var matchingViewModel: MatchingViewModel
@EnvironmentObject private var roomModel: RoomModel
@EnvironmentObject private var room: Room
@Environment(\.isFocused) var isFocused: Bool
@State private var partnerCountryName: String = ""
var body: some View {
Group {
GeometryReader { geometry in
VStack(spacing: 16) {
if matchingViewModel.connectionState.isNotConnected {
self.searchingStateView(geometry: geometry)
} else {
#if os(visionOS)
self.connectedStateView(geometry: geometry)
#else
ScrollView(.horizontal) {
ScrollView {
self.connectedStateView(geometry: geometry)
}
}
#endif
}
}
}
}
}
extension MatchingContentView {
//MARK: UI Views
private func searchingStateView(geometry: GeometryProxy) -> some View {
WaitingRoomView(geometry: geometry)
}
private func connectedStateView(geometry: GeometryProxy) -> some View {
Group {
#if os(visionOS)
HStack(spacing: 15) {
ParticipantsList(geometry: geometry)
ParticipantInfoView()
}
#else
ScrollView {
VStack(spacing: 15) {
ParticipantsList(geometry: geometry)
ParticipantInfoView()
}
.background(.gray.opacity(0.5))
}
#endif
}
.padding()
}
}
Code: Select all
import AVFoundation
import Combine
@preconcurrency import LiveKit
import LiveKitComponents
import SwiftUI
import os
struct MatchingWrapperView: View {
let content: () -> Content
init(@ViewBuilder content: @escaping () -> Content) {
self.content = content
}
@EnvironmentObject private var matchingViewModel: MatchingViewModel
@EnvironmentObject private var roomModel: RoomModel
@EnvironmentObject private var eventsViewModel: EventsViewModel
@EnvironmentObject private var settingsViewModel: SettingsViewModel
@EnvironmentObject private var notificationModel: OrnamentNotificationModel
@EnvironmentObject private var room: Room
@EnvironmentObject private var soundService: SoundService
@Environment(\.selection) private var selection
@State private var isConnecting = false
@State private var connectTask: Task? = nil
let logger = Logger(subsystem: "persona.vision", category: "LiveKit")
var body: some View {
content()
.onAppear {
self.handleConnectionStateChange(
from: nil,
to: matchingViewModel.connectionState
)
}
.onChange(of: room.connectionState) {
oldState,
newState in
guard roomModel.shouldCall else {
return
}
switch newState {
case .disconnected:
// here check selection status to start new matching or end it
if matchingViewModel.connectionState == .disconnecting {
if selection != 2 {
matchingViewModel
.changeConnectionState(
.disconnected,
connectionType: nil
)
roomModel.changeShouldCall(false)
return
} else {
matchingViewModel.changeConnectionState(.searching)
}
}
roomModel.globalManager?.restartMatch()
break
case .connected:
// if partners are empty skip call to prevent show empty partner info
if roomModel.partners.isEmpty {
matchingViewModel.changeConnectionState(.disconnecting)
self.notificationModel.showNotification(
OrnamentNotification(
title: "Failed to receive partner info",
type: .error,
customDuration: 5
)
)
}
case .disconnecting:
break
default:
break
}
}
.onChange(of: roomModel.partners.count) {
self.handleChangeRoomIdOrPartners()
}
.onChange(of: matchingViewModel.connectionState) {
oldState,
newState in
self.handleConnectionStateChange(
from: oldState,
to: newState
)
}
}
}
extension MatchingWrapperView {
// MARK: Functions
func connectRoom(token: String) {
guard room.connectionState == .disconnected else {
return
}
Task {
do {
try await room.connect(
url: wsURL,
token: token,
connectOptions: ConnectOptions(enableMicrophone: true)
)
} catch {
return
}
await enableCamera()
matchingViewModel.emitHasConnectedToLiveKit()
}
}
private func enableCamera(
maxRetries: Int = 10,
delaySeconds: Double = 0.5
) async {
#if !targetEnvironment(simulator)
do {
try await room.localParticipant.setCamera(enabled: true)
return
} catch {
}
#endif
}
private func reattemptConnect(token: String) {
Task { [self] in
self.connectRoom(token: token)
}
}
private func handleConnectionStateChange(
from oldState: ConnectionState?,
to newState: ConnectionState
) {
guard oldState != newState else { return }
print(
"Connection state changed: \(String(describing: oldState)) → \(newState)"
)
if newState == .searching {
matchingViewModel.startMatching()
if settingsViewModel.audioSettings?.waitingSound == true {
soundService.playAudio(
name: "music_for_waiting_with_delay",
type: "mp3",
volume: 0.5
)
}
} else if oldState == .searching && newState == .disconnected {
matchingViewModel.endCall(state: .disconnected)
soundService.stopAudio()
} else {
soundService.stopAudio()
}
}
@MainActor
func handleChangeRoomIdOrPartners() {
guard matchingViewModel.connectionState != .disconnected
else { return }
let hasRoomId = !roomModel.roomId.isEmpty
let hasPartner = !roomModel.partners.isEmpty
let isDisconnectedRoom = room.connectionState == .disconnected
let isConnected = matchingViewModel.connectionState == .connected
let isDisconnecting =
matchingViewModel.connectionState == .disconnecting
if hasRoomId, hasPartner, isDisconnectedRoom, !isConnected {
self.connectToLiveKit()
return
}
if isDisconnecting || isDisconnectedRoom {
return
}
matchingViewModel.changeConnectionState(.disconnecting)
Task {
await room.disconnect()
}
if self.notificationModel.notification?.contentView != nil {
self.notificationModel.dismissNotification()
}
}
func connectToLiveKit() {
matchingViewModel.changeConnectionState(.connecting)
let roomId = self.roomModel.roomId
let token = self.roomModel.myLiveKitToken
guard !roomId.isEmpty, !token.isEmpty else {
self.notificationModel.showNotification(
OrnamentNotification(
title: "Failed to receive room id or LiveKit token",
type: .error,
customDuration: 5
)
)
matchingViewModel.changeConnectionState(.searching)
SentryService
.sendMessage(
"Failed to receive room id or LiveKit token",
context: SentryContext(extra: ["userId": roomModel.myId])
)
return
}
connectRoom(token: token)
}
}
