diff --git a/pkg/rtc/localparticipant.go b/pkg/rtc/localparticipant.go index d2e9a481f..1c7c7ecd9 100644 --- a/pkg/rtc/localparticipant.go +++ b/pkg/rtc/localparticipant.go @@ -125,7 +125,7 @@ func (l *LocalParticipant) AddMigratedTrack(cid string, ti *livekit.TrackInfo) { } func (l *LocalParticipant) SetTrackMuted(trackID livekit.TrackID, muted bool) { - track := l.UptrackManager.SetTrackMuted(trackID, muted) + track := l.UptrackManager.SetPublishedTrackMuted(trackID, muted) if track != nil { // handled in UptrackManager for a published track, no need to update state of pending track return @@ -336,7 +336,7 @@ func (l *LocalParticipant) setupUptrackManager() { Logger: l.params.Logger, }) - l.UptrackManager.OnClose(l.onUptrackManagerClose) + l.UptrackManager.OnUptrackManagerClose(l.onUptrackManagerClose) } func (l *LocalParticipant) onUptrackManagerClose() { diff --git a/pkg/rtc/nooplocalmediatrack.go b/pkg/rtc/nooplocalmediatrack.go new file mode 100644 index 000000000..64a3241be --- /dev/null +++ b/pkg/rtc/nooplocalmediatrack.go @@ -0,0 +1,7 @@ +package rtc + +type NoOpLocalMediaTrack struct { +} + +func (t *NoOpLocalMediaTrack) NotifySubscriberNodeMediaLoss(_nodeID string, _fractionalLoss uint8) { +} diff --git a/pkg/rtc/nooplocalparticipant.go b/pkg/rtc/nooplocalparticipant.go new file mode 100644 index 000000000..90bcef27c --- /dev/null +++ b/pkg/rtc/nooplocalparticipant.go @@ -0,0 +1,190 @@ +package rtc + +import ( + "errors" + "time" + + "github.com/livekit/livekit-server/pkg/routing" + "github.com/livekit/livekit-server/pkg/rtc/types" + "github.com/livekit/protocol/livekit" + "github.com/pion/webrtc/v3" +) + +var ( + ErrUnimplemented = errors.New("unimplemented") +) + +type NoOpLocalParticipant struct { +} + +func (p *NoOpLocalParticipant) ProtocolVersion() types.ProtocolVersion { + return 0 +} + +func (p *NoOpLocalParticipant) ConnectedAt() time.Time { + return time.Time{} +} + +func (p *NoOpLocalParticipant) State() livekit.ParticipantInfo_State { + return livekit.ParticipantInfo_DISCONNECTED +} + +func (p *NoOpLocalParticipant) IsReady() bool { + return false +} + +func (p *NoOpLocalParticipant) IsRecorder() bool { + return false +} + +func (p *NoOpLocalParticipant) SubscriberAsPrimary() bool { + return false +} + +func (p *NoOpLocalParticipant) GetResponseSink() routing.MessageSink { + return nil +} + +func (p *NoOpLocalParticipant) SetResponseSink(_sink routing.MessageSink) { +} + +func (p *NoOpLocalParticipant) SetPermission(_permission *livekit.ParticipantPermission) { +} + +func (p *NoOpLocalParticipant) CanPublish() bool { + return false +} + +func (p *NoOpLocalParticipant) CanSubscribe() bool { + return false +} + +func (p *NoOpLocalParticipant) CanPublishData() bool { + return false +} + +func (p *NoOpLocalParticipant) AddICECandidate(_candidate webrtc.ICECandidateInit, _target livekit.SignalTarget) error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) HandleOffer(_sdp webrtc.SessionDescription) (webrtc.SessionDescription, error) { + return webrtc.SessionDescription{}, ErrUnimplemented +} + +func (p *NoOpLocalParticipant) AddTrack(_req *livekit.AddTrackRequest) { +} + +func (p *NoOpLocalParticipant) SetTrackMuted(_trackID livekit.TrackID, _muted bool, _fromAdmin bool) { +} + +func (p *NoOpLocalParticipant) SubscriberMediaEngine() *webrtc.MediaEngine { + return nil +} + +func (p *NoOpLocalParticipant) SubscriberPC() *webrtc.PeerConnection { + return nil +} + +func (p *NoOpLocalParticipant) HandleAnswer(_sdp webrtc.SessionDescription) error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) Negotiate() { +} + +func (p *NoOpLocalParticipant) ICERestart() error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) AddSubscribedTrack(_subTrack types.SubscribedTrack) { +} + +func (p *NoOpLocalParticipant) RemoveSubscribedTrack(_subTrack types.SubscribedTrack) { +} + +func (p *NoOpLocalParticipant) GetSubscribedTrack(_sid livekit.TrackID) types.SubscribedTrack { + return nil +} + +func (p *NoOpLocalParticipant) GetSubscribedTracks() []types.SubscribedTrack { + return nil +} + +func (p *NoOpLocalParticipant) GetSubscribedParticipants() []livekit.ParticipantID { + return nil +} + +func (t *NoOpLocalParticipant) GetAudioLevel() (level uint8, active bool) { + return SilentAudioLevel, false +} + +func (p *NoOpLocalParticipant) GetConnectionQuality() *livekit.ConnectionQualityInfo { + return &livekit.ConnectionQualityInfo{} +} + +func (p *NoOpLocalParticipant) SendJoinResponse( + _roomInfo *livekit.Room, + _otherParticipants []*livekit.ParticipantInfo, + _iceServers []*livekit.ICEServer, +) error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) SendParticipantUpdate(_participantsToUpdate []*livekit.ParticipantInfo, updatedAt time.Time) error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) SendSpeakerUpdate(_speakers []*livekit.SpeakerInfo) error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) SendDataPacket(_dp *livekit.DataPacket) error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) SendRoomUpdate(_room *livekit.Room) error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) SendConnectionQualityUpdate(_update *livekit.ConnectionQualityUpdate) error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) SubscriptionPermissionUpdate(_publisherID livekit.ParticipantID, _trackID livekit.TrackID, _allowed bool) { +} + +func (p *NoOpLocalParticipant) OnStateChange(_callback func(p types.Participant, oldState livekit.ParticipantInfo_State)) { +} + +func (p *NoOpLocalParticipant) OnTrackUpdated(_callback func(types.Participant, types.PublishedTrack)) { +} + +func (p *NoOpLocalParticipant) OnMetadataUpdate(_callback func(types.Participant)) { +} + +func (p *NoOpLocalParticipant) OnDataPacket(_callback func(types.Participant, *livekit.DataPacket)) { +} + +func (p *NoOpLocalParticipant) OnClose(_callback func(types.Participant, map[livekit.TrackID]livekit.ParticipantID)) { +} + +func (p *NoOpLocalParticipant) UpdateSubscribedQuality(_nodeID string, _trackID livekit.TrackID, _maxQuality livekit.VideoQuality) error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) UpdateMediaLoss(_nodeID string, _trackID livekit.TrackID, _fractionalLoss uint32) error { + return ErrUnimplemented +} + +func (p *NoOpLocalParticipant) SetMigrateState(_s types.MigrateState) { +} + +func (p *NoOpLocalParticipant) MigrateState() types.MigrateState { + return types.MigrateStateInit +} + +func (p *NoOpLocalParticipant) AddMigratedTrack(cid string, ti *livekit.TrackInfo) { +} + +func (p *NoOpLocalParticipant) SetPreviousAnswer(_previous *webrtc.SessionDescription) { +} diff --git a/pkg/rtc/nooplocalpublishedtrack.go b/pkg/rtc/nooplocalpublishedtrack.go new file mode 100644 index 000000000..f5d82161e --- /dev/null +++ b/pkg/rtc/nooplocalpublishedtrack.go @@ -0,0 +1,20 @@ +package rtc + +type NoOpLocalPublishedTrack struct { +} + +func (t *NoOpLocalPublishedTrack) GetAudioLevel() (level uint8, active bool) { + return SilentAudioLevel, false +} + +func (t *NoOpLocalPublishedTrack) GetConnectionScore() float64 { + return 0 +} + +func (t *NoOpLocalPublishedTrack) SdpCid() (sdpCid string) { + return +} + +func (t *NoOpLocalPublishedTrack) SignalCid() (signalCid string) { + return +} diff --git a/pkg/rtc/participant.go b/pkg/rtc/participant.go index d79bb18cf..733045be3 100644 --- a/pkg/rtc/participant.go +++ b/pkg/rtc/participant.go @@ -552,7 +552,7 @@ func (p *ParticipantImpl) SendSpeakerUpdate(speakers []*livekit.SpeakerInfo) err var scopedSpeakers []*livekit.SpeakerInfo for _, s := range speakers { participantID := livekit.ParticipantID(s.Sid) - if p.IsSubscribedTo(participantID) || participantID == p.ID() { + if p.isSubscribedTo(participantID) || participantID == p.ID() { scopedSpeakers = append(scopedSpeakers, s) } } @@ -663,7 +663,7 @@ func (p *ParticipantImpl) GetConnectionQuality() *livekit.ConnectionQualityInfo } } -func (p *ParticipantImpl) IsSubscribedTo(participantID livekit.ParticipantID) bool { +func (p *ParticipantImpl) isSubscribedTo(participantID livekit.ParticipantID) bool { _, ok := p.subscribedTo.Load(participantID) return ok } @@ -830,7 +830,7 @@ func (p *ParticipantImpl) setupLocalParticipant() { } }) - p.LocalParticipant.OnTrackUpdated(func(track types.PublishedTrack, onlyIfReady bool) { + p.LocalParticipant.OnPublishedTrackUpdated(func(track types.PublishedTrack, onlyIfReady bool) { if onlyIfReady && !p.IsReady() { return } diff --git a/pkg/rtc/types/interfaces.go b/pkg/rtc/types/interfaces.go index 13c51ea2f..533a73969 100644 --- a/pkg/rtc/types/interfaces.go +++ b/pkg/rtc/types/interfaces.go @@ -32,85 +32,109 @@ const ( MigrateStateComplete ) -//counterfeiter:generate . Participant -type Participant interface { - ID() livekit.ParticipantID - Identity() livekit.ParticipantIdentity - State() livekit.ParticipantInfo_State +//counterfeiter:generate . LocalParticipant +type LocalParticipant interface { ProtocolVersion() ProtocolVersion - IsReady() bool + ConnectedAt() time.Time - ToProto() *livekit.ParticipantInfo - SetMetadata(metadata string) - SetPermission(permission *livekit.ParticipantPermission) + + State() livekit.ParticipantInfo_State + IsReady() bool + + IsRecorder() bool + + SubscriberAsPrimary() bool + GetResponseSink() routing.MessageSink SetResponseSink(sink routing.MessageSink) - SubscriberMediaEngine() *webrtc.MediaEngine - Negotiate() - ICERestart() error - SetPreviousAnswer(previous *webrtc.SessionDescription) - SetMigrateState(s MigrateState) - MigrateState() MigrateState + + // permissions + SetPermission(permission *livekit.ParticipantPermission) + CanPublish() bool + CanSubscribe() bool + CanPublishData() bool + + AddICECandidate(candidate webrtc.ICECandidateInit, target livekit.SignalTarget) error + + HandleOffer(sdp webrtc.SessionDescription) (answer webrtc.SessionDescription, err error) AddTrack(req *livekit.AddTrackRequest) - AddMigratedTrack(cid string, ti *livekit.TrackInfo) - GetPublishedTrack(sid livekit.TrackID) PublishedTrack - GetPublishedTracks() []PublishedTrack + SetTrackMuted(trackID livekit.TrackID, muted bool, fromAdmin bool) + + SubscriberMediaEngine() *webrtc.MediaEngine + SubscriberPC() *webrtc.PeerConnection + HandleAnswer(sdp webrtc.SessionDescription) error + Negotiate() + ICERestart() error + AddSubscribedTrack(st SubscribedTrack) + RemoveSubscribedTrack(st SubscribedTrack) GetSubscribedTrack(sid livekit.TrackID) SubscribedTrack GetSubscribedTracks() []SubscribedTrack - HandleOffer(sdp webrtc.SessionDescription) (answer webrtc.SessionDescription, err error) - HandleAnswer(sdp webrtc.SessionDescription) error - AddICECandidate(candidate webrtc.ICECandidateInit, target livekit.SignalTarget) error - AddSubscriber(op Participant, params AddSubscriberParams) (int, error) - RemoveSubscriber(op Participant, trackID livekit.TrackID) + + // returns list of participant identities that the current participant is subscribed to + GetSubscribedParticipants() []livekit.ParticipantID + + GetAudioLevel() (level uint8, active bool) + GetConnectionQuality() *livekit.ConnectionQualityInfo + + // server sent messages SendJoinResponse(info *livekit.Room, otherParticipants []*livekit.ParticipantInfo, iceServers []*livekit.ICEServer) error SendParticipantUpdate(participants []*livekit.ParticipantInfo, updatedAt time.Time) error SendSpeakerUpdate(speakers []*livekit.SpeakerInfo) error SendDataPacket(packet *livekit.DataPacket) error SendRoomUpdate(room *livekit.Room) error SendConnectionQualityUpdate(update *livekit.ConnectionQualityUpdate) error - SetTrackMuted(trackID livekit.TrackID, muted bool, fromAdmin bool) - GetAudioLevel() (level uint8, active bool) - GetConnectionQuality() *livekit.ConnectionQualityInfo - IsSubscribedTo(participantID livekit.ParticipantID) bool - // returns list of participant identities that the current participant is subscribed to - GetSubscribedParticipants() []livekit.ParticipantID + SubscriptionPermissionUpdate(publisherID livekit.ParticipantID, trackID livekit.TrackID, allowed bool) + + // callbacks + OnStateChange(func(p Participant, oldState livekit.ParticipantInfo_State)) + // OnTrackUpdated - one of its publishedTracks changed in status + OnTrackUpdated(callback func(Participant, PublishedTrack)) + OnMetadataUpdate(callback func(Participant)) + OnDataPacket(callback func(Participant, *livekit.DataPacket)) + OnClose(_callback func(Participant, map[livekit.TrackID]livekit.ParticipantID)) + + // updates from remotes + UpdateSubscribedQuality(nodeID string, trackID livekit.TrackID, maxQuality livekit.VideoQuality) error + UpdateMediaLoss(nodeID string, trackID livekit.TrackID, fractionalLoss uint32) error + + // session migration + SetMigrateState(s MigrateState) + MigrateState() MigrateState + AddMigratedTrack(cid string, ti *livekit.TrackInfo) + SetPreviousAnswer(previous *webrtc.SessionDescription) +} + +//counterfeiter:generate . Participant +type Participant interface { + LocalParticipant + + ID() livekit.ParticipantID + Identity() livekit.ParticipantIdentity + + ToProto() *livekit.ParticipantInfo + + SetMetadata(metadata string) + + GetPublishedTrack(sid livekit.TrackID) PublishedTrack + GetPublishedTracks() []PublishedTrack + + AddSubscriber(op Participant, params AddSubscriberParams) (int, error) + RemoveSubscriber(op Participant, trackID livekit.TrackID) // permissions - CanPublish() bool - CanSubscribe() bool - CanPublishData() bool Hidden() bool - IsRecorder() bool - SubscriberAsPrimary() bool Start() Close() error // callbacks - OnStateChange(func(p Participant, oldState livekit.ParticipantInfo_State)) // OnTrackPublished - remote added a remoteTrack OnTrackPublished(func(Participant, PublishedTrack)) - // OnTrackUpdated - one of its publishedTracks changed in status - OnTrackUpdated(callback func(Participant, PublishedTrack)) - OnMetadataUpdate(callback func(Participant)) - OnDataPacket(callback func(Participant, *livekit.DataPacket)) - OnClose(func(Participant, map[livekit.TrackID]livekit.ParticipantID)) - - // package methods - AddSubscribedTrack(st SubscribedTrack) - RemoveSubscribedTrack(st SubscribedTrack) - SubscriberPC() *webrtc.PeerConnection UpdateSubscriptionPermissions(permissions *livekit.UpdateSubscriptionPermissions, resolver func(participantID livekit.ParticipantID) Participant) error - SubscriptionPermissionUpdate(publisherID livekit.ParticipantID, trackID livekit.TrackID, allowed bool) - UpdateVideoLayers(updateVideoLayers *livekit.UpdateVideoLayers) error - UpdateSubscribedQuality(nodeID string, trackID livekit.TrackID, maxQuality livekit.VideoQuality) error - - UpdateMediaLoss(nodeID string, trackID livekit.TrackID, fractionalLoss uint32) error - DebugInfo() map[string]interface{} } @@ -125,9 +149,16 @@ type Room interface { UpdateVideoLayers(participant Participant, updateVideoLayers *livekit.UpdateVideoLayers) error } +//counterfeiter:generate . LocalMediaTrack +type LocalMediaTrack interface { + NotifySubscriberNodeMediaLoss(nodeID string, fractionalLoss uint8) +} + // MediaTrack represents a media track //counterfeiter:generate . MediaTrack type MediaTrack interface { + LocalMediaTrack + ID() livekit.TrackID Kind() livekit.TrackType Name() string @@ -155,8 +186,15 @@ type MediaTrack interface { NotifySubscriberMaxQuality(subscriberID livekit.ParticipantID, quality livekit.VideoQuality) NotifySubscriberNodeMaxQuality(nodeID string, quality livekit.VideoQuality) +} - NotifySubscriberNodeMediaLoss(nodeID string, fractionalLoss uint8) +//counterfeiter:generate . LocalPublishedTrack +type LocalPublishedTrack interface { + SignalCid() string + SdpCid() string + + GetAudioLevel() (level uint8, active bool) + GetConnectionScore() float64 } // PublishedTrack is the main interface representing a track published to the room @@ -165,14 +203,9 @@ type MediaTrack interface { type PublishedTrack interface { MediaTrack - SignalCid() string - SdpCid() string ToProto() *livekit.TrackInfo Receiver() sfu.TrackReceiver - GetConnectionScore() float64 - - GetAudioLevel() (level uint8, active bool) UpdateVideoLayers(layers []*livekit.VideoLayer) @@ -180,6 +213,8 @@ type PublishedTrack interface { // callbacks AddOnClose(func()) + + LocalPublishedTrack } //counterfeiter:generate . SubscribedTrack diff --git a/pkg/rtc/types/typesfakes/fake_local_media_track.go b/pkg/rtc/types/typesfakes/fake_local_media_track.go new file mode 100644 index 000000000..a10e01841 --- /dev/null +++ b/pkg/rtc/types/typesfakes/fake_local_media_track.go @@ -0,0 +1,78 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package typesfakes + +import ( + "sync" + + "github.com/livekit/livekit-server/pkg/rtc/types" +) + +type FakeLocalMediaTrack struct { + NotifySubscriberNodeMediaLossStub func(string, uint8) + notifySubscriberNodeMediaLossMutex sync.RWMutex + notifySubscriberNodeMediaLossArgsForCall []struct { + arg1 string + arg2 uint8 + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberNodeMediaLoss(arg1 string, arg2 uint8) { + fake.notifySubscriberNodeMediaLossMutex.Lock() + fake.notifySubscriberNodeMediaLossArgsForCall = append(fake.notifySubscriberNodeMediaLossArgsForCall, struct { + arg1 string + arg2 uint8 + }{arg1, arg2}) + stub := fake.NotifySubscriberNodeMediaLossStub + fake.recordInvocation("NotifySubscriberNodeMediaLoss", []interface{}{arg1, arg2}) + fake.notifySubscriberNodeMediaLossMutex.Unlock() + if stub != nil { + fake.NotifySubscriberNodeMediaLossStub(arg1, arg2) + } +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberNodeMediaLossCallCount() int { + fake.notifySubscriberNodeMediaLossMutex.RLock() + defer fake.notifySubscriberNodeMediaLossMutex.RUnlock() + return len(fake.notifySubscriberNodeMediaLossArgsForCall) +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberNodeMediaLossCalls(stub func(string, uint8)) { + fake.notifySubscriberNodeMediaLossMutex.Lock() + defer fake.notifySubscriberNodeMediaLossMutex.Unlock() + fake.NotifySubscriberNodeMediaLossStub = stub +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberNodeMediaLossArgsForCall(i int) (string, uint8) { + fake.notifySubscriberNodeMediaLossMutex.RLock() + defer fake.notifySubscriberNodeMediaLossMutex.RUnlock() + argsForCall := fake.notifySubscriberNodeMediaLossArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeLocalMediaTrack) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.notifySubscriberNodeMediaLossMutex.RLock() + defer fake.notifySubscriberNodeMediaLossMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeLocalMediaTrack) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ types.LocalMediaTrack = new(FakeLocalMediaTrack) diff --git a/pkg/rtc/types/typesfakes/fake_local_participant.go b/pkg/rtc/types/typesfakes/fake_local_participant.go new file mode 100644 index 000000000..7be300433 --- /dev/null +++ b/pkg/rtc/types/typesfakes/fake_local_participant.go @@ -0,0 +1,2770 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package typesfakes + +import ( + "sync" + "time" + + "github.com/livekit/livekit-server/pkg/routing" + "github.com/livekit/livekit-server/pkg/rtc/types" + "github.com/livekit/protocol/livekit" + webrtc "github.com/pion/webrtc/v3" +) + +type FakeLocalParticipant struct { + AddICECandidateStub func(webrtc.ICECandidateInit, livekit.SignalTarget) error + addICECandidateMutex sync.RWMutex + addICECandidateArgsForCall []struct { + arg1 webrtc.ICECandidateInit + arg2 livekit.SignalTarget + } + addICECandidateReturns struct { + result1 error + } + addICECandidateReturnsOnCall map[int]struct { + result1 error + } + AddMigratedTrackStub func(string, *livekit.TrackInfo) + addMigratedTrackMutex sync.RWMutex + addMigratedTrackArgsForCall []struct { + arg1 string + arg2 *livekit.TrackInfo + } + AddSubscribedTrackStub func(types.SubscribedTrack) + addSubscribedTrackMutex sync.RWMutex + addSubscribedTrackArgsForCall []struct { + arg1 types.SubscribedTrack + } + AddTrackStub func(*livekit.AddTrackRequest) + addTrackMutex sync.RWMutex + addTrackArgsForCall []struct { + arg1 *livekit.AddTrackRequest + } + CanPublishStub func() bool + canPublishMutex sync.RWMutex + canPublishArgsForCall []struct { + } + canPublishReturns struct { + result1 bool + } + canPublishReturnsOnCall map[int]struct { + result1 bool + } + CanPublishDataStub func() bool + canPublishDataMutex sync.RWMutex + canPublishDataArgsForCall []struct { + } + canPublishDataReturns struct { + result1 bool + } + canPublishDataReturnsOnCall map[int]struct { + result1 bool + } + CanSubscribeStub func() bool + canSubscribeMutex sync.RWMutex + canSubscribeArgsForCall []struct { + } + canSubscribeReturns struct { + result1 bool + } + canSubscribeReturnsOnCall map[int]struct { + result1 bool + } + ConnectedAtStub func() time.Time + connectedAtMutex sync.RWMutex + connectedAtArgsForCall []struct { + } + connectedAtReturns struct { + result1 time.Time + } + connectedAtReturnsOnCall map[int]struct { + result1 time.Time + } + GetAudioLevelStub func() (uint8, bool) + getAudioLevelMutex sync.RWMutex + getAudioLevelArgsForCall []struct { + } + getAudioLevelReturns struct { + result1 uint8 + result2 bool + } + getAudioLevelReturnsOnCall map[int]struct { + result1 uint8 + result2 bool + } + GetConnectionQualityStub func() *livekit.ConnectionQualityInfo + getConnectionQualityMutex sync.RWMutex + getConnectionQualityArgsForCall []struct { + } + getConnectionQualityReturns struct { + result1 *livekit.ConnectionQualityInfo + } + getConnectionQualityReturnsOnCall map[int]struct { + result1 *livekit.ConnectionQualityInfo + } + GetResponseSinkStub func() routing.MessageSink + getResponseSinkMutex sync.RWMutex + getResponseSinkArgsForCall []struct { + } + getResponseSinkReturns struct { + result1 routing.MessageSink + } + getResponseSinkReturnsOnCall map[int]struct { + result1 routing.MessageSink + } + GetSubscribedParticipantsStub func() []livekit.ParticipantID + getSubscribedParticipantsMutex sync.RWMutex + getSubscribedParticipantsArgsForCall []struct { + } + getSubscribedParticipantsReturns struct { + result1 []livekit.ParticipantID + } + getSubscribedParticipantsReturnsOnCall map[int]struct { + result1 []livekit.ParticipantID + } + GetSubscribedTrackStub func(livekit.TrackID) types.SubscribedTrack + getSubscribedTrackMutex sync.RWMutex + getSubscribedTrackArgsForCall []struct { + arg1 livekit.TrackID + } + getSubscribedTrackReturns struct { + result1 types.SubscribedTrack + } + getSubscribedTrackReturnsOnCall map[int]struct { + result1 types.SubscribedTrack + } + GetSubscribedTracksStub func() []types.SubscribedTrack + getSubscribedTracksMutex sync.RWMutex + getSubscribedTracksArgsForCall []struct { + } + getSubscribedTracksReturns struct { + result1 []types.SubscribedTrack + } + getSubscribedTracksReturnsOnCall map[int]struct { + result1 []types.SubscribedTrack + } + HandleAnswerStub func(webrtc.SessionDescription) error + handleAnswerMutex sync.RWMutex + handleAnswerArgsForCall []struct { + arg1 webrtc.SessionDescription + } + handleAnswerReturns struct { + result1 error + } + handleAnswerReturnsOnCall map[int]struct { + result1 error + } + HandleOfferStub func(webrtc.SessionDescription) (webrtc.SessionDescription, error) + handleOfferMutex sync.RWMutex + handleOfferArgsForCall []struct { + arg1 webrtc.SessionDescription + } + handleOfferReturns struct { + result1 webrtc.SessionDescription + result2 error + } + handleOfferReturnsOnCall map[int]struct { + result1 webrtc.SessionDescription + result2 error + } + ICERestartStub func() error + iCERestartMutex sync.RWMutex + iCERestartArgsForCall []struct { + } + iCERestartReturns struct { + result1 error + } + iCERestartReturnsOnCall map[int]struct { + result1 error + } + IsReadyStub func() bool + isReadyMutex sync.RWMutex + isReadyArgsForCall []struct { + } + isReadyReturns struct { + result1 bool + } + isReadyReturnsOnCall map[int]struct { + result1 bool + } + IsRecorderStub func() bool + isRecorderMutex sync.RWMutex + isRecorderArgsForCall []struct { + } + isRecorderReturns struct { + result1 bool + } + isRecorderReturnsOnCall map[int]struct { + result1 bool + } + MigrateStateStub func() types.MigrateState + migrateStateMutex sync.RWMutex + migrateStateArgsForCall []struct { + } + migrateStateReturns struct { + result1 types.MigrateState + } + migrateStateReturnsOnCall map[int]struct { + result1 types.MigrateState + } + NegotiateStub func() + negotiateMutex sync.RWMutex + negotiateArgsForCall []struct { + } + OnCloseStub func(func(types.Participant, map[livekit.TrackID]livekit.ParticipantID)) + onCloseMutex sync.RWMutex + onCloseArgsForCall []struct { + arg1 func(types.Participant, map[livekit.TrackID]livekit.ParticipantID) + } + OnDataPacketStub func(func(types.Participant, *livekit.DataPacket)) + onDataPacketMutex sync.RWMutex + onDataPacketArgsForCall []struct { + arg1 func(types.Participant, *livekit.DataPacket) + } + OnMetadataUpdateStub func(func(types.Participant)) + onMetadataUpdateMutex sync.RWMutex + onMetadataUpdateArgsForCall []struct { + arg1 func(types.Participant) + } + OnStateChangeStub func(func(p types.Participant, oldState livekit.ParticipantInfo_State)) + onStateChangeMutex sync.RWMutex + onStateChangeArgsForCall []struct { + arg1 func(p types.Participant, oldState livekit.ParticipantInfo_State) + } + OnTrackUpdatedStub func(func(types.Participant, types.PublishedTrack)) + onTrackUpdatedMutex sync.RWMutex + onTrackUpdatedArgsForCall []struct { + arg1 func(types.Participant, types.PublishedTrack) + } + ProtocolVersionStub func() types.ProtocolVersion + protocolVersionMutex sync.RWMutex + protocolVersionArgsForCall []struct { + } + protocolVersionReturns struct { + result1 types.ProtocolVersion + } + protocolVersionReturnsOnCall map[int]struct { + result1 types.ProtocolVersion + } + RemoveSubscribedTrackStub func(types.SubscribedTrack) + removeSubscribedTrackMutex sync.RWMutex + removeSubscribedTrackArgsForCall []struct { + arg1 types.SubscribedTrack + } + SendConnectionQualityUpdateStub func(*livekit.ConnectionQualityUpdate) error + sendConnectionQualityUpdateMutex sync.RWMutex + sendConnectionQualityUpdateArgsForCall []struct { + arg1 *livekit.ConnectionQualityUpdate + } + sendConnectionQualityUpdateReturns struct { + result1 error + } + sendConnectionQualityUpdateReturnsOnCall map[int]struct { + result1 error + } + SendDataPacketStub func(*livekit.DataPacket) error + sendDataPacketMutex sync.RWMutex + sendDataPacketArgsForCall []struct { + arg1 *livekit.DataPacket + } + sendDataPacketReturns struct { + result1 error + } + sendDataPacketReturnsOnCall map[int]struct { + result1 error + } + SendJoinResponseStub func(*livekit.Room, []*livekit.ParticipantInfo, []*livekit.ICEServer) error + sendJoinResponseMutex sync.RWMutex + sendJoinResponseArgsForCall []struct { + arg1 *livekit.Room + arg2 []*livekit.ParticipantInfo + arg3 []*livekit.ICEServer + } + sendJoinResponseReturns struct { + result1 error + } + sendJoinResponseReturnsOnCall map[int]struct { + result1 error + } + SendParticipantUpdateStub func([]*livekit.ParticipantInfo, time.Time) error + sendParticipantUpdateMutex sync.RWMutex + sendParticipantUpdateArgsForCall []struct { + arg1 []*livekit.ParticipantInfo + arg2 time.Time + } + sendParticipantUpdateReturns struct { + result1 error + } + sendParticipantUpdateReturnsOnCall map[int]struct { + result1 error + } + SendRoomUpdateStub func(*livekit.Room) error + sendRoomUpdateMutex sync.RWMutex + sendRoomUpdateArgsForCall []struct { + arg1 *livekit.Room + } + sendRoomUpdateReturns struct { + result1 error + } + sendRoomUpdateReturnsOnCall map[int]struct { + result1 error + } + SendSpeakerUpdateStub func([]*livekit.SpeakerInfo) error + sendSpeakerUpdateMutex sync.RWMutex + sendSpeakerUpdateArgsForCall []struct { + arg1 []*livekit.SpeakerInfo + } + sendSpeakerUpdateReturns struct { + result1 error + } + sendSpeakerUpdateReturnsOnCall map[int]struct { + result1 error + } + SetMigrateStateStub func(types.MigrateState) + setMigrateStateMutex sync.RWMutex + setMigrateStateArgsForCall []struct { + arg1 types.MigrateState + } + SetPermissionStub func(*livekit.ParticipantPermission) + setPermissionMutex sync.RWMutex + setPermissionArgsForCall []struct { + arg1 *livekit.ParticipantPermission + } + SetPreviousAnswerStub func(*webrtc.SessionDescription) + setPreviousAnswerMutex sync.RWMutex + setPreviousAnswerArgsForCall []struct { + arg1 *webrtc.SessionDescription + } + SetResponseSinkStub func(routing.MessageSink) + setResponseSinkMutex sync.RWMutex + setResponseSinkArgsForCall []struct { + arg1 routing.MessageSink + } + SetTrackMutedStub func(livekit.TrackID, bool, bool) + setTrackMutedMutex sync.RWMutex + setTrackMutedArgsForCall []struct { + arg1 livekit.TrackID + arg2 bool + arg3 bool + } + StateStub func() livekit.ParticipantInfo_State + stateMutex sync.RWMutex + stateArgsForCall []struct { + } + stateReturns struct { + result1 livekit.ParticipantInfo_State + } + stateReturnsOnCall map[int]struct { + result1 livekit.ParticipantInfo_State + } + SubscriberAsPrimaryStub func() bool + subscriberAsPrimaryMutex sync.RWMutex + subscriberAsPrimaryArgsForCall []struct { + } + subscriberAsPrimaryReturns struct { + result1 bool + } + subscriberAsPrimaryReturnsOnCall map[int]struct { + result1 bool + } + SubscriberMediaEngineStub func() *webrtc.MediaEngine + subscriberMediaEngineMutex sync.RWMutex + subscriberMediaEngineArgsForCall []struct { + } + subscriberMediaEngineReturns struct { + result1 *webrtc.MediaEngine + } + subscriberMediaEngineReturnsOnCall map[int]struct { + result1 *webrtc.MediaEngine + } + SubscriberPCStub func() *webrtc.PeerConnection + subscriberPCMutex sync.RWMutex + subscriberPCArgsForCall []struct { + } + subscriberPCReturns struct { + result1 *webrtc.PeerConnection + } + subscriberPCReturnsOnCall map[int]struct { + result1 *webrtc.PeerConnection + } + SubscriptionPermissionUpdateStub func(livekit.ParticipantID, livekit.TrackID, bool) + subscriptionPermissionUpdateMutex sync.RWMutex + subscriptionPermissionUpdateArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 livekit.TrackID + arg3 bool + } + UpdateMediaLossStub func(string, livekit.TrackID, uint32) error + updateMediaLossMutex sync.RWMutex + updateMediaLossArgsForCall []struct { + arg1 string + arg2 livekit.TrackID + arg3 uint32 + } + updateMediaLossReturns struct { + result1 error + } + updateMediaLossReturnsOnCall map[int]struct { + result1 error + } + UpdateSubscribedQualityStub func(string, livekit.TrackID, livekit.VideoQuality) error + updateSubscribedQualityMutex sync.RWMutex + updateSubscribedQualityArgsForCall []struct { + arg1 string + arg2 livekit.TrackID + arg3 livekit.VideoQuality + } + updateSubscribedQualityReturns struct { + result1 error + } + updateSubscribedQualityReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeLocalParticipant) AddICECandidate(arg1 webrtc.ICECandidateInit, arg2 livekit.SignalTarget) error { + fake.addICECandidateMutex.Lock() + ret, specificReturn := fake.addICECandidateReturnsOnCall[len(fake.addICECandidateArgsForCall)] + fake.addICECandidateArgsForCall = append(fake.addICECandidateArgsForCall, struct { + arg1 webrtc.ICECandidateInit + arg2 livekit.SignalTarget + }{arg1, arg2}) + stub := fake.AddICECandidateStub + fakeReturns := fake.addICECandidateReturns + fake.recordInvocation("AddICECandidate", []interface{}{arg1, arg2}) + fake.addICECandidateMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) AddICECandidateCallCount() int { + fake.addICECandidateMutex.RLock() + defer fake.addICECandidateMutex.RUnlock() + return len(fake.addICECandidateArgsForCall) +} + +func (fake *FakeLocalParticipant) AddICECandidateCalls(stub func(webrtc.ICECandidateInit, livekit.SignalTarget) error) { + fake.addICECandidateMutex.Lock() + defer fake.addICECandidateMutex.Unlock() + fake.AddICECandidateStub = stub +} + +func (fake *FakeLocalParticipant) AddICECandidateArgsForCall(i int) (webrtc.ICECandidateInit, livekit.SignalTarget) { + fake.addICECandidateMutex.RLock() + defer fake.addICECandidateMutex.RUnlock() + argsForCall := fake.addICECandidateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeLocalParticipant) AddICECandidateReturns(result1 error) { + fake.addICECandidateMutex.Lock() + defer fake.addICECandidateMutex.Unlock() + fake.AddICECandidateStub = nil + fake.addICECandidateReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) AddICECandidateReturnsOnCall(i int, result1 error) { + fake.addICECandidateMutex.Lock() + defer fake.addICECandidateMutex.Unlock() + fake.AddICECandidateStub = nil + if fake.addICECandidateReturnsOnCall == nil { + fake.addICECandidateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.addICECandidateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) AddMigratedTrack(arg1 string, arg2 *livekit.TrackInfo) { + fake.addMigratedTrackMutex.Lock() + fake.addMigratedTrackArgsForCall = append(fake.addMigratedTrackArgsForCall, struct { + arg1 string + arg2 *livekit.TrackInfo + }{arg1, arg2}) + stub := fake.AddMigratedTrackStub + fake.recordInvocation("AddMigratedTrack", []interface{}{arg1, arg2}) + fake.addMigratedTrackMutex.Unlock() + if stub != nil { + fake.AddMigratedTrackStub(arg1, arg2) + } +} + +func (fake *FakeLocalParticipant) AddMigratedTrackCallCount() int { + fake.addMigratedTrackMutex.RLock() + defer fake.addMigratedTrackMutex.RUnlock() + return len(fake.addMigratedTrackArgsForCall) +} + +func (fake *FakeLocalParticipant) AddMigratedTrackCalls(stub func(string, *livekit.TrackInfo)) { + fake.addMigratedTrackMutex.Lock() + defer fake.addMigratedTrackMutex.Unlock() + fake.AddMigratedTrackStub = stub +} + +func (fake *FakeLocalParticipant) AddMigratedTrackArgsForCall(i int) (string, *livekit.TrackInfo) { + fake.addMigratedTrackMutex.RLock() + defer fake.addMigratedTrackMutex.RUnlock() + argsForCall := fake.addMigratedTrackArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeLocalParticipant) AddSubscribedTrack(arg1 types.SubscribedTrack) { + fake.addSubscribedTrackMutex.Lock() + fake.addSubscribedTrackArgsForCall = append(fake.addSubscribedTrackArgsForCall, struct { + arg1 types.SubscribedTrack + }{arg1}) + stub := fake.AddSubscribedTrackStub + fake.recordInvocation("AddSubscribedTrack", []interface{}{arg1}) + fake.addSubscribedTrackMutex.Unlock() + if stub != nil { + fake.AddSubscribedTrackStub(arg1) + } +} + +func (fake *FakeLocalParticipant) AddSubscribedTrackCallCount() int { + fake.addSubscribedTrackMutex.RLock() + defer fake.addSubscribedTrackMutex.RUnlock() + return len(fake.addSubscribedTrackArgsForCall) +} + +func (fake *FakeLocalParticipant) AddSubscribedTrackCalls(stub func(types.SubscribedTrack)) { + fake.addSubscribedTrackMutex.Lock() + defer fake.addSubscribedTrackMutex.Unlock() + fake.AddSubscribedTrackStub = stub +} + +func (fake *FakeLocalParticipant) AddSubscribedTrackArgsForCall(i int) types.SubscribedTrack { + fake.addSubscribedTrackMutex.RLock() + defer fake.addSubscribedTrackMutex.RUnlock() + argsForCall := fake.addSubscribedTrackArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) AddTrack(arg1 *livekit.AddTrackRequest) { + fake.addTrackMutex.Lock() + fake.addTrackArgsForCall = append(fake.addTrackArgsForCall, struct { + arg1 *livekit.AddTrackRequest + }{arg1}) + stub := fake.AddTrackStub + fake.recordInvocation("AddTrack", []interface{}{arg1}) + fake.addTrackMutex.Unlock() + if stub != nil { + fake.AddTrackStub(arg1) + } +} + +func (fake *FakeLocalParticipant) AddTrackCallCount() int { + fake.addTrackMutex.RLock() + defer fake.addTrackMutex.RUnlock() + return len(fake.addTrackArgsForCall) +} + +func (fake *FakeLocalParticipant) AddTrackCalls(stub func(*livekit.AddTrackRequest)) { + fake.addTrackMutex.Lock() + defer fake.addTrackMutex.Unlock() + fake.AddTrackStub = stub +} + +func (fake *FakeLocalParticipant) AddTrackArgsForCall(i int) *livekit.AddTrackRequest { + fake.addTrackMutex.RLock() + defer fake.addTrackMutex.RUnlock() + argsForCall := fake.addTrackArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) CanPublish() bool { + fake.canPublishMutex.Lock() + ret, specificReturn := fake.canPublishReturnsOnCall[len(fake.canPublishArgsForCall)] + fake.canPublishArgsForCall = append(fake.canPublishArgsForCall, struct { + }{}) + stub := fake.CanPublishStub + fakeReturns := fake.canPublishReturns + fake.recordInvocation("CanPublish", []interface{}{}) + fake.canPublishMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) CanPublishCallCount() int { + fake.canPublishMutex.RLock() + defer fake.canPublishMutex.RUnlock() + return len(fake.canPublishArgsForCall) +} + +func (fake *FakeLocalParticipant) CanPublishCalls(stub func() bool) { + fake.canPublishMutex.Lock() + defer fake.canPublishMutex.Unlock() + fake.CanPublishStub = stub +} + +func (fake *FakeLocalParticipant) CanPublishReturns(result1 bool) { + fake.canPublishMutex.Lock() + defer fake.canPublishMutex.Unlock() + fake.CanPublishStub = nil + fake.canPublishReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) CanPublishReturnsOnCall(i int, result1 bool) { + fake.canPublishMutex.Lock() + defer fake.canPublishMutex.Unlock() + fake.CanPublishStub = nil + if fake.canPublishReturnsOnCall == nil { + fake.canPublishReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.canPublishReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) CanPublishData() bool { + fake.canPublishDataMutex.Lock() + ret, specificReturn := fake.canPublishDataReturnsOnCall[len(fake.canPublishDataArgsForCall)] + fake.canPublishDataArgsForCall = append(fake.canPublishDataArgsForCall, struct { + }{}) + stub := fake.CanPublishDataStub + fakeReturns := fake.canPublishDataReturns + fake.recordInvocation("CanPublishData", []interface{}{}) + fake.canPublishDataMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) CanPublishDataCallCount() int { + fake.canPublishDataMutex.RLock() + defer fake.canPublishDataMutex.RUnlock() + return len(fake.canPublishDataArgsForCall) +} + +func (fake *FakeLocalParticipant) CanPublishDataCalls(stub func() bool) { + fake.canPublishDataMutex.Lock() + defer fake.canPublishDataMutex.Unlock() + fake.CanPublishDataStub = stub +} + +func (fake *FakeLocalParticipant) CanPublishDataReturns(result1 bool) { + fake.canPublishDataMutex.Lock() + defer fake.canPublishDataMutex.Unlock() + fake.CanPublishDataStub = nil + fake.canPublishDataReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) CanPublishDataReturnsOnCall(i int, result1 bool) { + fake.canPublishDataMutex.Lock() + defer fake.canPublishDataMutex.Unlock() + fake.CanPublishDataStub = nil + if fake.canPublishDataReturnsOnCall == nil { + fake.canPublishDataReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.canPublishDataReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) CanSubscribe() bool { + fake.canSubscribeMutex.Lock() + ret, specificReturn := fake.canSubscribeReturnsOnCall[len(fake.canSubscribeArgsForCall)] + fake.canSubscribeArgsForCall = append(fake.canSubscribeArgsForCall, struct { + }{}) + stub := fake.CanSubscribeStub + fakeReturns := fake.canSubscribeReturns + fake.recordInvocation("CanSubscribe", []interface{}{}) + fake.canSubscribeMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) CanSubscribeCallCount() int { + fake.canSubscribeMutex.RLock() + defer fake.canSubscribeMutex.RUnlock() + return len(fake.canSubscribeArgsForCall) +} + +func (fake *FakeLocalParticipant) CanSubscribeCalls(stub func() bool) { + fake.canSubscribeMutex.Lock() + defer fake.canSubscribeMutex.Unlock() + fake.CanSubscribeStub = stub +} + +func (fake *FakeLocalParticipant) CanSubscribeReturns(result1 bool) { + fake.canSubscribeMutex.Lock() + defer fake.canSubscribeMutex.Unlock() + fake.CanSubscribeStub = nil + fake.canSubscribeReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) CanSubscribeReturnsOnCall(i int, result1 bool) { + fake.canSubscribeMutex.Lock() + defer fake.canSubscribeMutex.Unlock() + fake.CanSubscribeStub = nil + if fake.canSubscribeReturnsOnCall == nil { + fake.canSubscribeReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.canSubscribeReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) ConnectedAt() time.Time { + fake.connectedAtMutex.Lock() + ret, specificReturn := fake.connectedAtReturnsOnCall[len(fake.connectedAtArgsForCall)] + fake.connectedAtArgsForCall = append(fake.connectedAtArgsForCall, struct { + }{}) + stub := fake.ConnectedAtStub + fakeReturns := fake.connectedAtReturns + fake.recordInvocation("ConnectedAt", []interface{}{}) + fake.connectedAtMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) ConnectedAtCallCount() int { + fake.connectedAtMutex.RLock() + defer fake.connectedAtMutex.RUnlock() + return len(fake.connectedAtArgsForCall) +} + +func (fake *FakeLocalParticipant) ConnectedAtCalls(stub func() time.Time) { + fake.connectedAtMutex.Lock() + defer fake.connectedAtMutex.Unlock() + fake.ConnectedAtStub = stub +} + +func (fake *FakeLocalParticipant) ConnectedAtReturns(result1 time.Time) { + fake.connectedAtMutex.Lock() + defer fake.connectedAtMutex.Unlock() + fake.ConnectedAtStub = nil + fake.connectedAtReturns = struct { + result1 time.Time + }{result1} +} + +func (fake *FakeLocalParticipant) ConnectedAtReturnsOnCall(i int, result1 time.Time) { + fake.connectedAtMutex.Lock() + defer fake.connectedAtMutex.Unlock() + fake.ConnectedAtStub = nil + if fake.connectedAtReturnsOnCall == nil { + fake.connectedAtReturnsOnCall = make(map[int]struct { + result1 time.Time + }) + } + fake.connectedAtReturnsOnCall[i] = struct { + result1 time.Time + }{result1} +} + +func (fake *FakeLocalParticipant) GetAudioLevel() (uint8, bool) { + fake.getAudioLevelMutex.Lock() + ret, specificReturn := fake.getAudioLevelReturnsOnCall[len(fake.getAudioLevelArgsForCall)] + fake.getAudioLevelArgsForCall = append(fake.getAudioLevelArgsForCall, struct { + }{}) + stub := fake.GetAudioLevelStub + fakeReturns := fake.getAudioLevelReturns + fake.recordInvocation("GetAudioLevel", []interface{}{}) + fake.getAudioLevelMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeLocalParticipant) GetAudioLevelCallCount() int { + fake.getAudioLevelMutex.RLock() + defer fake.getAudioLevelMutex.RUnlock() + return len(fake.getAudioLevelArgsForCall) +} + +func (fake *FakeLocalParticipant) GetAudioLevelCalls(stub func() (uint8, bool)) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = stub +} + +func (fake *FakeLocalParticipant) GetAudioLevelReturns(result1 uint8, result2 bool) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = nil + fake.getAudioLevelReturns = struct { + result1 uint8 + result2 bool + }{result1, result2} +} + +func (fake *FakeLocalParticipant) GetAudioLevelReturnsOnCall(i int, result1 uint8, result2 bool) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = nil + if fake.getAudioLevelReturnsOnCall == nil { + fake.getAudioLevelReturnsOnCall = make(map[int]struct { + result1 uint8 + result2 bool + }) + } + fake.getAudioLevelReturnsOnCall[i] = struct { + result1 uint8 + result2 bool + }{result1, result2} +} + +func (fake *FakeLocalParticipant) GetConnectionQuality() *livekit.ConnectionQualityInfo { + fake.getConnectionQualityMutex.Lock() + ret, specificReturn := fake.getConnectionQualityReturnsOnCall[len(fake.getConnectionQualityArgsForCall)] + fake.getConnectionQualityArgsForCall = append(fake.getConnectionQualityArgsForCall, struct { + }{}) + stub := fake.GetConnectionQualityStub + fakeReturns := fake.getConnectionQualityReturns + fake.recordInvocation("GetConnectionQuality", []interface{}{}) + fake.getConnectionQualityMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) GetConnectionQualityCallCount() int { + fake.getConnectionQualityMutex.RLock() + defer fake.getConnectionQualityMutex.RUnlock() + return len(fake.getConnectionQualityArgsForCall) +} + +func (fake *FakeLocalParticipant) GetConnectionQualityCalls(stub func() *livekit.ConnectionQualityInfo) { + fake.getConnectionQualityMutex.Lock() + defer fake.getConnectionQualityMutex.Unlock() + fake.GetConnectionQualityStub = stub +} + +func (fake *FakeLocalParticipant) GetConnectionQualityReturns(result1 *livekit.ConnectionQualityInfo) { + fake.getConnectionQualityMutex.Lock() + defer fake.getConnectionQualityMutex.Unlock() + fake.GetConnectionQualityStub = nil + fake.getConnectionQualityReturns = struct { + result1 *livekit.ConnectionQualityInfo + }{result1} +} + +func (fake *FakeLocalParticipant) GetConnectionQualityReturnsOnCall(i int, result1 *livekit.ConnectionQualityInfo) { + fake.getConnectionQualityMutex.Lock() + defer fake.getConnectionQualityMutex.Unlock() + fake.GetConnectionQualityStub = nil + if fake.getConnectionQualityReturnsOnCall == nil { + fake.getConnectionQualityReturnsOnCall = make(map[int]struct { + result1 *livekit.ConnectionQualityInfo + }) + } + fake.getConnectionQualityReturnsOnCall[i] = struct { + result1 *livekit.ConnectionQualityInfo + }{result1} +} + +func (fake *FakeLocalParticipant) GetResponseSink() routing.MessageSink { + fake.getResponseSinkMutex.Lock() + ret, specificReturn := fake.getResponseSinkReturnsOnCall[len(fake.getResponseSinkArgsForCall)] + fake.getResponseSinkArgsForCall = append(fake.getResponseSinkArgsForCall, struct { + }{}) + stub := fake.GetResponseSinkStub + fakeReturns := fake.getResponseSinkReturns + fake.recordInvocation("GetResponseSink", []interface{}{}) + fake.getResponseSinkMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) GetResponseSinkCallCount() int { + fake.getResponseSinkMutex.RLock() + defer fake.getResponseSinkMutex.RUnlock() + return len(fake.getResponseSinkArgsForCall) +} + +func (fake *FakeLocalParticipant) GetResponseSinkCalls(stub func() routing.MessageSink) { + fake.getResponseSinkMutex.Lock() + defer fake.getResponseSinkMutex.Unlock() + fake.GetResponseSinkStub = stub +} + +func (fake *FakeLocalParticipant) GetResponseSinkReturns(result1 routing.MessageSink) { + fake.getResponseSinkMutex.Lock() + defer fake.getResponseSinkMutex.Unlock() + fake.GetResponseSinkStub = nil + fake.getResponseSinkReturns = struct { + result1 routing.MessageSink + }{result1} +} + +func (fake *FakeLocalParticipant) GetResponseSinkReturnsOnCall(i int, result1 routing.MessageSink) { + fake.getResponseSinkMutex.Lock() + defer fake.getResponseSinkMutex.Unlock() + fake.GetResponseSinkStub = nil + if fake.getResponseSinkReturnsOnCall == nil { + fake.getResponseSinkReturnsOnCall = make(map[int]struct { + result1 routing.MessageSink + }) + } + fake.getResponseSinkReturnsOnCall[i] = struct { + result1 routing.MessageSink + }{result1} +} + +func (fake *FakeLocalParticipant) GetSubscribedParticipants() []livekit.ParticipantID { + fake.getSubscribedParticipantsMutex.Lock() + ret, specificReturn := fake.getSubscribedParticipantsReturnsOnCall[len(fake.getSubscribedParticipantsArgsForCall)] + fake.getSubscribedParticipantsArgsForCall = append(fake.getSubscribedParticipantsArgsForCall, struct { + }{}) + stub := fake.GetSubscribedParticipantsStub + fakeReturns := fake.getSubscribedParticipantsReturns + fake.recordInvocation("GetSubscribedParticipants", []interface{}{}) + fake.getSubscribedParticipantsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) GetSubscribedParticipantsCallCount() int { + fake.getSubscribedParticipantsMutex.RLock() + defer fake.getSubscribedParticipantsMutex.RUnlock() + return len(fake.getSubscribedParticipantsArgsForCall) +} + +func (fake *FakeLocalParticipant) GetSubscribedParticipantsCalls(stub func() []livekit.ParticipantID) { + fake.getSubscribedParticipantsMutex.Lock() + defer fake.getSubscribedParticipantsMutex.Unlock() + fake.GetSubscribedParticipantsStub = stub +} + +func (fake *FakeLocalParticipant) GetSubscribedParticipantsReturns(result1 []livekit.ParticipantID) { + fake.getSubscribedParticipantsMutex.Lock() + defer fake.getSubscribedParticipantsMutex.Unlock() + fake.GetSubscribedParticipantsStub = nil + fake.getSubscribedParticipantsReturns = struct { + result1 []livekit.ParticipantID + }{result1} +} + +func (fake *FakeLocalParticipant) GetSubscribedParticipantsReturnsOnCall(i int, result1 []livekit.ParticipantID) { + fake.getSubscribedParticipantsMutex.Lock() + defer fake.getSubscribedParticipantsMutex.Unlock() + fake.GetSubscribedParticipantsStub = nil + if fake.getSubscribedParticipantsReturnsOnCall == nil { + fake.getSubscribedParticipantsReturnsOnCall = make(map[int]struct { + result1 []livekit.ParticipantID + }) + } + fake.getSubscribedParticipantsReturnsOnCall[i] = struct { + result1 []livekit.ParticipantID + }{result1} +} + +func (fake *FakeLocalParticipant) GetSubscribedTrack(arg1 livekit.TrackID) types.SubscribedTrack { + fake.getSubscribedTrackMutex.Lock() + ret, specificReturn := fake.getSubscribedTrackReturnsOnCall[len(fake.getSubscribedTrackArgsForCall)] + fake.getSubscribedTrackArgsForCall = append(fake.getSubscribedTrackArgsForCall, struct { + arg1 livekit.TrackID + }{arg1}) + stub := fake.GetSubscribedTrackStub + fakeReturns := fake.getSubscribedTrackReturns + fake.recordInvocation("GetSubscribedTrack", []interface{}{arg1}) + fake.getSubscribedTrackMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) GetSubscribedTrackCallCount() int { + fake.getSubscribedTrackMutex.RLock() + defer fake.getSubscribedTrackMutex.RUnlock() + return len(fake.getSubscribedTrackArgsForCall) +} + +func (fake *FakeLocalParticipant) GetSubscribedTrackCalls(stub func(livekit.TrackID) types.SubscribedTrack) { + fake.getSubscribedTrackMutex.Lock() + defer fake.getSubscribedTrackMutex.Unlock() + fake.GetSubscribedTrackStub = stub +} + +func (fake *FakeLocalParticipant) GetSubscribedTrackArgsForCall(i int) livekit.TrackID { + fake.getSubscribedTrackMutex.RLock() + defer fake.getSubscribedTrackMutex.RUnlock() + argsForCall := fake.getSubscribedTrackArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) GetSubscribedTrackReturns(result1 types.SubscribedTrack) { + fake.getSubscribedTrackMutex.Lock() + defer fake.getSubscribedTrackMutex.Unlock() + fake.GetSubscribedTrackStub = nil + fake.getSubscribedTrackReturns = struct { + result1 types.SubscribedTrack + }{result1} +} + +func (fake *FakeLocalParticipant) GetSubscribedTrackReturnsOnCall(i int, result1 types.SubscribedTrack) { + fake.getSubscribedTrackMutex.Lock() + defer fake.getSubscribedTrackMutex.Unlock() + fake.GetSubscribedTrackStub = nil + if fake.getSubscribedTrackReturnsOnCall == nil { + fake.getSubscribedTrackReturnsOnCall = make(map[int]struct { + result1 types.SubscribedTrack + }) + } + fake.getSubscribedTrackReturnsOnCall[i] = struct { + result1 types.SubscribedTrack + }{result1} +} + +func (fake *FakeLocalParticipant) GetSubscribedTracks() []types.SubscribedTrack { + fake.getSubscribedTracksMutex.Lock() + ret, specificReturn := fake.getSubscribedTracksReturnsOnCall[len(fake.getSubscribedTracksArgsForCall)] + fake.getSubscribedTracksArgsForCall = append(fake.getSubscribedTracksArgsForCall, struct { + }{}) + stub := fake.GetSubscribedTracksStub + fakeReturns := fake.getSubscribedTracksReturns + fake.recordInvocation("GetSubscribedTracks", []interface{}{}) + fake.getSubscribedTracksMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) GetSubscribedTracksCallCount() int { + fake.getSubscribedTracksMutex.RLock() + defer fake.getSubscribedTracksMutex.RUnlock() + return len(fake.getSubscribedTracksArgsForCall) +} + +func (fake *FakeLocalParticipant) GetSubscribedTracksCalls(stub func() []types.SubscribedTrack) { + fake.getSubscribedTracksMutex.Lock() + defer fake.getSubscribedTracksMutex.Unlock() + fake.GetSubscribedTracksStub = stub +} + +func (fake *FakeLocalParticipant) GetSubscribedTracksReturns(result1 []types.SubscribedTrack) { + fake.getSubscribedTracksMutex.Lock() + defer fake.getSubscribedTracksMutex.Unlock() + fake.GetSubscribedTracksStub = nil + fake.getSubscribedTracksReturns = struct { + result1 []types.SubscribedTrack + }{result1} +} + +func (fake *FakeLocalParticipant) GetSubscribedTracksReturnsOnCall(i int, result1 []types.SubscribedTrack) { + fake.getSubscribedTracksMutex.Lock() + defer fake.getSubscribedTracksMutex.Unlock() + fake.GetSubscribedTracksStub = nil + if fake.getSubscribedTracksReturnsOnCall == nil { + fake.getSubscribedTracksReturnsOnCall = make(map[int]struct { + result1 []types.SubscribedTrack + }) + } + fake.getSubscribedTracksReturnsOnCall[i] = struct { + result1 []types.SubscribedTrack + }{result1} +} + +func (fake *FakeLocalParticipant) HandleAnswer(arg1 webrtc.SessionDescription) error { + fake.handleAnswerMutex.Lock() + ret, specificReturn := fake.handleAnswerReturnsOnCall[len(fake.handleAnswerArgsForCall)] + fake.handleAnswerArgsForCall = append(fake.handleAnswerArgsForCall, struct { + arg1 webrtc.SessionDescription + }{arg1}) + stub := fake.HandleAnswerStub + fakeReturns := fake.handleAnswerReturns + fake.recordInvocation("HandleAnswer", []interface{}{arg1}) + fake.handleAnswerMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) HandleAnswerCallCount() int { + fake.handleAnswerMutex.RLock() + defer fake.handleAnswerMutex.RUnlock() + return len(fake.handleAnswerArgsForCall) +} + +func (fake *FakeLocalParticipant) HandleAnswerCalls(stub func(webrtc.SessionDescription) error) { + fake.handleAnswerMutex.Lock() + defer fake.handleAnswerMutex.Unlock() + fake.HandleAnswerStub = stub +} + +func (fake *FakeLocalParticipant) HandleAnswerArgsForCall(i int) webrtc.SessionDescription { + fake.handleAnswerMutex.RLock() + defer fake.handleAnswerMutex.RUnlock() + argsForCall := fake.handleAnswerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) HandleAnswerReturns(result1 error) { + fake.handleAnswerMutex.Lock() + defer fake.handleAnswerMutex.Unlock() + fake.HandleAnswerStub = nil + fake.handleAnswerReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) HandleAnswerReturnsOnCall(i int, result1 error) { + fake.handleAnswerMutex.Lock() + defer fake.handleAnswerMutex.Unlock() + fake.HandleAnswerStub = nil + if fake.handleAnswerReturnsOnCall == nil { + fake.handleAnswerReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.handleAnswerReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) HandleOffer(arg1 webrtc.SessionDescription) (webrtc.SessionDescription, error) { + fake.handleOfferMutex.Lock() + ret, specificReturn := fake.handleOfferReturnsOnCall[len(fake.handleOfferArgsForCall)] + fake.handleOfferArgsForCall = append(fake.handleOfferArgsForCall, struct { + arg1 webrtc.SessionDescription + }{arg1}) + stub := fake.HandleOfferStub + fakeReturns := fake.handleOfferReturns + fake.recordInvocation("HandleOffer", []interface{}{arg1}) + fake.handleOfferMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeLocalParticipant) HandleOfferCallCount() int { + fake.handleOfferMutex.RLock() + defer fake.handleOfferMutex.RUnlock() + return len(fake.handleOfferArgsForCall) +} + +func (fake *FakeLocalParticipant) HandleOfferCalls(stub func(webrtc.SessionDescription) (webrtc.SessionDescription, error)) { + fake.handleOfferMutex.Lock() + defer fake.handleOfferMutex.Unlock() + fake.HandleOfferStub = stub +} + +func (fake *FakeLocalParticipant) HandleOfferArgsForCall(i int) webrtc.SessionDescription { + fake.handleOfferMutex.RLock() + defer fake.handleOfferMutex.RUnlock() + argsForCall := fake.handleOfferArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) HandleOfferReturns(result1 webrtc.SessionDescription, result2 error) { + fake.handleOfferMutex.Lock() + defer fake.handleOfferMutex.Unlock() + fake.HandleOfferStub = nil + fake.handleOfferReturns = struct { + result1 webrtc.SessionDescription + result2 error + }{result1, result2} +} + +func (fake *FakeLocalParticipant) HandleOfferReturnsOnCall(i int, result1 webrtc.SessionDescription, result2 error) { + fake.handleOfferMutex.Lock() + defer fake.handleOfferMutex.Unlock() + fake.HandleOfferStub = nil + if fake.handleOfferReturnsOnCall == nil { + fake.handleOfferReturnsOnCall = make(map[int]struct { + result1 webrtc.SessionDescription + result2 error + }) + } + fake.handleOfferReturnsOnCall[i] = struct { + result1 webrtc.SessionDescription + result2 error + }{result1, result2} +} + +func (fake *FakeLocalParticipant) ICERestart() error { + fake.iCERestartMutex.Lock() + ret, specificReturn := fake.iCERestartReturnsOnCall[len(fake.iCERestartArgsForCall)] + fake.iCERestartArgsForCall = append(fake.iCERestartArgsForCall, struct { + }{}) + stub := fake.ICERestartStub + fakeReturns := fake.iCERestartReturns + fake.recordInvocation("ICERestart", []interface{}{}) + fake.iCERestartMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) ICERestartCallCount() int { + fake.iCERestartMutex.RLock() + defer fake.iCERestartMutex.RUnlock() + return len(fake.iCERestartArgsForCall) +} + +func (fake *FakeLocalParticipant) ICERestartCalls(stub func() error) { + fake.iCERestartMutex.Lock() + defer fake.iCERestartMutex.Unlock() + fake.ICERestartStub = stub +} + +func (fake *FakeLocalParticipant) ICERestartReturns(result1 error) { + fake.iCERestartMutex.Lock() + defer fake.iCERestartMutex.Unlock() + fake.ICERestartStub = nil + fake.iCERestartReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) ICERestartReturnsOnCall(i int, result1 error) { + fake.iCERestartMutex.Lock() + defer fake.iCERestartMutex.Unlock() + fake.ICERestartStub = nil + if fake.iCERestartReturnsOnCall == nil { + fake.iCERestartReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.iCERestartReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) IsReady() bool { + fake.isReadyMutex.Lock() + ret, specificReturn := fake.isReadyReturnsOnCall[len(fake.isReadyArgsForCall)] + fake.isReadyArgsForCall = append(fake.isReadyArgsForCall, struct { + }{}) + stub := fake.IsReadyStub + fakeReturns := fake.isReadyReturns + fake.recordInvocation("IsReady", []interface{}{}) + fake.isReadyMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) IsReadyCallCount() int { + fake.isReadyMutex.RLock() + defer fake.isReadyMutex.RUnlock() + return len(fake.isReadyArgsForCall) +} + +func (fake *FakeLocalParticipant) IsReadyCalls(stub func() bool) { + fake.isReadyMutex.Lock() + defer fake.isReadyMutex.Unlock() + fake.IsReadyStub = stub +} + +func (fake *FakeLocalParticipant) IsReadyReturns(result1 bool) { + fake.isReadyMutex.Lock() + defer fake.isReadyMutex.Unlock() + fake.IsReadyStub = nil + fake.isReadyReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) IsReadyReturnsOnCall(i int, result1 bool) { + fake.isReadyMutex.Lock() + defer fake.isReadyMutex.Unlock() + fake.IsReadyStub = nil + if fake.isReadyReturnsOnCall == nil { + fake.isReadyReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isReadyReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) IsRecorder() bool { + fake.isRecorderMutex.Lock() + ret, specificReturn := fake.isRecorderReturnsOnCall[len(fake.isRecorderArgsForCall)] + fake.isRecorderArgsForCall = append(fake.isRecorderArgsForCall, struct { + }{}) + stub := fake.IsRecorderStub + fakeReturns := fake.isRecorderReturns + fake.recordInvocation("IsRecorder", []interface{}{}) + fake.isRecorderMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) IsRecorderCallCount() int { + fake.isRecorderMutex.RLock() + defer fake.isRecorderMutex.RUnlock() + return len(fake.isRecorderArgsForCall) +} + +func (fake *FakeLocalParticipant) IsRecorderCalls(stub func() bool) { + fake.isRecorderMutex.Lock() + defer fake.isRecorderMutex.Unlock() + fake.IsRecorderStub = stub +} + +func (fake *FakeLocalParticipant) IsRecorderReturns(result1 bool) { + fake.isRecorderMutex.Lock() + defer fake.isRecorderMutex.Unlock() + fake.IsRecorderStub = nil + fake.isRecorderReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) IsRecorderReturnsOnCall(i int, result1 bool) { + fake.isRecorderMutex.Lock() + defer fake.isRecorderMutex.Unlock() + fake.IsRecorderStub = nil + if fake.isRecorderReturnsOnCall == nil { + fake.isRecorderReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isRecorderReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) MigrateState() types.MigrateState { + fake.migrateStateMutex.Lock() + ret, specificReturn := fake.migrateStateReturnsOnCall[len(fake.migrateStateArgsForCall)] + fake.migrateStateArgsForCall = append(fake.migrateStateArgsForCall, struct { + }{}) + stub := fake.MigrateStateStub + fakeReturns := fake.migrateStateReturns + fake.recordInvocation("MigrateState", []interface{}{}) + fake.migrateStateMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) MigrateStateCallCount() int { + fake.migrateStateMutex.RLock() + defer fake.migrateStateMutex.RUnlock() + return len(fake.migrateStateArgsForCall) +} + +func (fake *FakeLocalParticipant) MigrateStateCalls(stub func() types.MigrateState) { + fake.migrateStateMutex.Lock() + defer fake.migrateStateMutex.Unlock() + fake.MigrateStateStub = stub +} + +func (fake *FakeLocalParticipant) MigrateStateReturns(result1 types.MigrateState) { + fake.migrateStateMutex.Lock() + defer fake.migrateStateMutex.Unlock() + fake.MigrateStateStub = nil + fake.migrateStateReturns = struct { + result1 types.MigrateState + }{result1} +} + +func (fake *FakeLocalParticipant) MigrateStateReturnsOnCall(i int, result1 types.MigrateState) { + fake.migrateStateMutex.Lock() + defer fake.migrateStateMutex.Unlock() + fake.MigrateStateStub = nil + if fake.migrateStateReturnsOnCall == nil { + fake.migrateStateReturnsOnCall = make(map[int]struct { + result1 types.MigrateState + }) + } + fake.migrateStateReturnsOnCall[i] = struct { + result1 types.MigrateState + }{result1} +} + +func (fake *FakeLocalParticipant) Negotiate() { + fake.negotiateMutex.Lock() + fake.negotiateArgsForCall = append(fake.negotiateArgsForCall, struct { + }{}) + stub := fake.NegotiateStub + fake.recordInvocation("Negotiate", []interface{}{}) + fake.negotiateMutex.Unlock() + if stub != nil { + fake.NegotiateStub() + } +} + +func (fake *FakeLocalParticipant) NegotiateCallCount() int { + fake.negotiateMutex.RLock() + defer fake.negotiateMutex.RUnlock() + return len(fake.negotiateArgsForCall) +} + +func (fake *FakeLocalParticipant) NegotiateCalls(stub func()) { + fake.negotiateMutex.Lock() + defer fake.negotiateMutex.Unlock() + fake.NegotiateStub = stub +} + +func (fake *FakeLocalParticipant) OnClose(arg1 func(types.Participant, map[livekit.TrackID]livekit.ParticipantID)) { + fake.onCloseMutex.Lock() + fake.onCloseArgsForCall = append(fake.onCloseArgsForCall, struct { + arg1 func(types.Participant, map[livekit.TrackID]livekit.ParticipantID) + }{arg1}) + stub := fake.OnCloseStub + fake.recordInvocation("OnClose", []interface{}{arg1}) + fake.onCloseMutex.Unlock() + if stub != nil { + fake.OnCloseStub(arg1) + } +} + +func (fake *FakeLocalParticipant) OnCloseCallCount() int { + fake.onCloseMutex.RLock() + defer fake.onCloseMutex.RUnlock() + return len(fake.onCloseArgsForCall) +} + +func (fake *FakeLocalParticipant) OnCloseCalls(stub func(func(types.Participant, map[livekit.TrackID]livekit.ParticipantID))) { + fake.onCloseMutex.Lock() + defer fake.onCloseMutex.Unlock() + fake.OnCloseStub = stub +} + +func (fake *FakeLocalParticipant) OnCloseArgsForCall(i int) func(types.Participant, map[livekit.TrackID]livekit.ParticipantID) { + fake.onCloseMutex.RLock() + defer fake.onCloseMutex.RUnlock() + argsForCall := fake.onCloseArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) OnDataPacket(arg1 func(types.Participant, *livekit.DataPacket)) { + fake.onDataPacketMutex.Lock() + fake.onDataPacketArgsForCall = append(fake.onDataPacketArgsForCall, struct { + arg1 func(types.Participant, *livekit.DataPacket) + }{arg1}) + stub := fake.OnDataPacketStub + fake.recordInvocation("OnDataPacket", []interface{}{arg1}) + fake.onDataPacketMutex.Unlock() + if stub != nil { + fake.OnDataPacketStub(arg1) + } +} + +func (fake *FakeLocalParticipant) OnDataPacketCallCount() int { + fake.onDataPacketMutex.RLock() + defer fake.onDataPacketMutex.RUnlock() + return len(fake.onDataPacketArgsForCall) +} + +func (fake *FakeLocalParticipant) OnDataPacketCalls(stub func(func(types.Participant, *livekit.DataPacket))) { + fake.onDataPacketMutex.Lock() + defer fake.onDataPacketMutex.Unlock() + fake.OnDataPacketStub = stub +} + +func (fake *FakeLocalParticipant) OnDataPacketArgsForCall(i int) func(types.Participant, *livekit.DataPacket) { + fake.onDataPacketMutex.RLock() + defer fake.onDataPacketMutex.RUnlock() + argsForCall := fake.onDataPacketArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) OnMetadataUpdate(arg1 func(types.Participant)) { + fake.onMetadataUpdateMutex.Lock() + fake.onMetadataUpdateArgsForCall = append(fake.onMetadataUpdateArgsForCall, struct { + arg1 func(types.Participant) + }{arg1}) + stub := fake.OnMetadataUpdateStub + fake.recordInvocation("OnMetadataUpdate", []interface{}{arg1}) + fake.onMetadataUpdateMutex.Unlock() + if stub != nil { + fake.OnMetadataUpdateStub(arg1) + } +} + +func (fake *FakeLocalParticipant) OnMetadataUpdateCallCount() int { + fake.onMetadataUpdateMutex.RLock() + defer fake.onMetadataUpdateMutex.RUnlock() + return len(fake.onMetadataUpdateArgsForCall) +} + +func (fake *FakeLocalParticipant) OnMetadataUpdateCalls(stub func(func(types.Participant))) { + fake.onMetadataUpdateMutex.Lock() + defer fake.onMetadataUpdateMutex.Unlock() + fake.OnMetadataUpdateStub = stub +} + +func (fake *FakeLocalParticipant) OnMetadataUpdateArgsForCall(i int) func(types.Participant) { + fake.onMetadataUpdateMutex.RLock() + defer fake.onMetadataUpdateMutex.RUnlock() + argsForCall := fake.onMetadataUpdateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) OnStateChange(arg1 func(p types.Participant, oldState livekit.ParticipantInfo_State)) { + fake.onStateChangeMutex.Lock() + fake.onStateChangeArgsForCall = append(fake.onStateChangeArgsForCall, struct { + arg1 func(p types.Participant, oldState livekit.ParticipantInfo_State) + }{arg1}) + stub := fake.OnStateChangeStub + fake.recordInvocation("OnStateChange", []interface{}{arg1}) + fake.onStateChangeMutex.Unlock() + if stub != nil { + fake.OnStateChangeStub(arg1) + } +} + +func (fake *FakeLocalParticipant) OnStateChangeCallCount() int { + fake.onStateChangeMutex.RLock() + defer fake.onStateChangeMutex.RUnlock() + return len(fake.onStateChangeArgsForCall) +} + +func (fake *FakeLocalParticipant) OnStateChangeCalls(stub func(func(p types.Participant, oldState livekit.ParticipantInfo_State))) { + fake.onStateChangeMutex.Lock() + defer fake.onStateChangeMutex.Unlock() + fake.OnStateChangeStub = stub +} + +func (fake *FakeLocalParticipant) OnStateChangeArgsForCall(i int) func(p types.Participant, oldState livekit.ParticipantInfo_State) { + fake.onStateChangeMutex.RLock() + defer fake.onStateChangeMutex.RUnlock() + argsForCall := fake.onStateChangeArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) OnTrackUpdated(arg1 func(types.Participant, types.PublishedTrack)) { + fake.onTrackUpdatedMutex.Lock() + fake.onTrackUpdatedArgsForCall = append(fake.onTrackUpdatedArgsForCall, struct { + arg1 func(types.Participant, types.PublishedTrack) + }{arg1}) + stub := fake.OnTrackUpdatedStub + fake.recordInvocation("OnTrackUpdated", []interface{}{arg1}) + fake.onTrackUpdatedMutex.Unlock() + if stub != nil { + fake.OnTrackUpdatedStub(arg1) + } +} + +func (fake *FakeLocalParticipant) OnTrackUpdatedCallCount() int { + fake.onTrackUpdatedMutex.RLock() + defer fake.onTrackUpdatedMutex.RUnlock() + return len(fake.onTrackUpdatedArgsForCall) +} + +func (fake *FakeLocalParticipant) OnTrackUpdatedCalls(stub func(func(types.Participant, types.PublishedTrack))) { + fake.onTrackUpdatedMutex.Lock() + defer fake.onTrackUpdatedMutex.Unlock() + fake.OnTrackUpdatedStub = stub +} + +func (fake *FakeLocalParticipant) OnTrackUpdatedArgsForCall(i int) func(types.Participant, types.PublishedTrack) { + fake.onTrackUpdatedMutex.RLock() + defer fake.onTrackUpdatedMutex.RUnlock() + argsForCall := fake.onTrackUpdatedArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) ProtocolVersion() types.ProtocolVersion { + fake.protocolVersionMutex.Lock() + ret, specificReturn := fake.protocolVersionReturnsOnCall[len(fake.protocolVersionArgsForCall)] + fake.protocolVersionArgsForCall = append(fake.protocolVersionArgsForCall, struct { + }{}) + stub := fake.ProtocolVersionStub + fakeReturns := fake.protocolVersionReturns + fake.recordInvocation("ProtocolVersion", []interface{}{}) + fake.protocolVersionMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) ProtocolVersionCallCount() int { + fake.protocolVersionMutex.RLock() + defer fake.protocolVersionMutex.RUnlock() + return len(fake.protocolVersionArgsForCall) +} + +func (fake *FakeLocalParticipant) ProtocolVersionCalls(stub func() types.ProtocolVersion) { + fake.protocolVersionMutex.Lock() + defer fake.protocolVersionMutex.Unlock() + fake.ProtocolVersionStub = stub +} + +func (fake *FakeLocalParticipant) ProtocolVersionReturns(result1 types.ProtocolVersion) { + fake.protocolVersionMutex.Lock() + defer fake.protocolVersionMutex.Unlock() + fake.ProtocolVersionStub = nil + fake.protocolVersionReturns = struct { + result1 types.ProtocolVersion + }{result1} +} + +func (fake *FakeLocalParticipant) ProtocolVersionReturnsOnCall(i int, result1 types.ProtocolVersion) { + fake.protocolVersionMutex.Lock() + defer fake.protocolVersionMutex.Unlock() + fake.ProtocolVersionStub = nil + if fake.protocolVersionReturnsOnCall == nil { + fake.protocolVersionReturnsOnCall = make(map[int]struct { + result1 types.ProtocolVersion + }) + } + fake.protocolVersionReturnsOnCall[i] = struct { + result1 types.ProtocolVersion + }{result1} +} + +func (fake *FakeLocalParticipant) RemoveSubscribedTrack(arg1 types.SubscribedTrack) { + fake.removeSubscribedTrackMutex.Lock() + fake.removeSubscribedTrackArgsForCall = append(fake.removeSubscribedTrackArgsForCall, struct { + arg1 types.SubscribedTrack + }{arg1}) + stub := fake.RemoveSubscribedTrackStub + fake.recordInvocation("RemoveSubscribedTrack", []interface{}{arg1}) + fake.removeSubscribedTrackMutex.Unlock() + if stub != nil { + fake.RemoveSubscribedTrackStub(arg1) + } +} + +func (fake *FakeLocalParticipant) RemoveSubscribedTrackCallCount() int { + fake.removeSubscribedTrackMutex.RLock() + defer fake.removeSubscribedTrackMutex.RUnlock() + return len(fake.removeSubscribedTrackArgsForCall) +} + +func (fake *FakeLocalParticipant) RemoveSubscribedTrackCalls(stub func(types.SubscribedTrack)) { + fake.removeSubscribedTrackMutex.Lock() + defer fake.removeSubscribedTrackMutex.Unlock() + fake.RemoveSubscribedTrackStub = stub +} + +func (fake *FakeLocalParticipant) RemoveSubscribedTrackArgsForCall(i int) types.SubscribedTrack { + fake.removeSubscribedTrackMutex.RLock() + defer fake.removeSubscribedTrackMutex.RUnlock() + argsForCall := fake.removeSubscribedTrackArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) SendConnectionQualityUpdate(arg1 *livekit.ConnectionQualityUpdate) error { + fake.sendConnectionQualityUpdateMutex.Lock() + ret, specificReturn := fake.sendConnectionQualityUpdateReturnsOnCall[len(fake.sendConnectionQualityUpdateArgsForCall)] + fake.sendConnectionQualityUpdateArgsForCall = append(fake.sendConnectionQualityUpdateArgsForCall, struct { + arg1 *livekit.ConnectionQualityUpdate + }{arg1}) + stub := fake.SendConnectionQualityUpdateStub + fakeReturns := fake.sendConnectionQualityUpdateReturns + fake.recordInvocation("SendConnectionQualityUpdate", []interface{}{arg1}) + fake.sendConnectionQualityUpdateMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) SendConnectionQualityUpdateCallCount() int { + fake.sendConnectionQualityUpdateMutex.RLock() + defer fake.sendConnectionQualityUpdateMutex.RUnlock() + return len(fake.sendConnectionQualityUpdateArgsForCall) +} + +func (fake *FakeLocalParticipant) SendConnectionQualityUpdateCalls(stub func(*livekit.ConnectionQualityUpdate) error) { + fake.sendConnectionQualityUpdateMutex.Lock() + defer fake.sendConnectionQualityUpdateMutex.Unlock() + fake.SendConnectionQualityUpdateStub = stub +} + +func (fake *FakeLocalParticipant) SendConnectionQualityUpdateArgsForCall(i int) *livekit.ConnectionQualityUpdate { + fake.sendConnectionQualityUpdateMutex.RLock() + defer fake.sendConnectionQualityUpdateMutex.RUnlock() + argsForCall := fake.sendConnectionQualityUpdateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) SendConnectionQualityUpdateReturns(result1 error) { + fake.sendConnectionQualityUpdateMutex.Lock() + defer fake.sendConnectionQualityUpdateMutex.Unlock() + fake.SendConnectionQualityUpdateStub = nil + fake.sendConnectionQualityUpdateReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendConnectionQualityUpdateReturnsOnCall(i int, result1 error) { + fake.sendConnectionQualityUpdateMutex.Lock() + defer fake.sendConnectionQualityUpdateMutex.Unlock() + fake.SendConnectionQualityUpdateStub = nil + if fake.sendConnectionQualityUpdateReturnsOnCall == nil { + fake.sendConnectionQualityUpdateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendConnectionQualityUpdateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendDataPacket(arg1 *livekit.DataPacket) error { + fake.sendDataPacketMutex.Lock() + ret, specificReturn := fake.sendDataPacketReturnsOnCall[len(fake.sendDataPacketArgsForCall)] + fake.sendDataPacketArgsForCall = append(fake.sendDataPacketArgsForCall, struct { + arg1 *livekit.DataPacket + }{arg1}) + stub := fake.SendDataPacketStub + fakeReturns := fake.sendDataPacketReturns + fake.recordInvocation("SendDataPacket", []interface{}{arg1}) + fake.sendDataPacketMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) SendDataPacketCallCount() int { + fake.sendDataPacketMutex.RLock() + defer fake.sendDataPacketMutex.RUnlock() + return len(fake.sendDataPacketArgsForCall) +} + +func (fake *FakeLocalParticipant) SendDataPacketCalls(stub func(*livekit.DataPacket) error) { + fake.sendDataPacketMutex.Lock() + defer fake.sendDataPacketMutex.Unlock() + fake.SendDataPacketStub = stub +} + +func (fake *FakeLocalParticipant) SendDataPacketArgsForCall(i int) *livekit.DataPacket { + fake.sendDataPacketMutex.RLock() + defer fake.sendDataPacketMutex.RUnlock() + argsForCall := fake.sendDataPacketArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) SendDataPacketReturns(result1 error) { + fake.sendDataPacketMutex.Lock() + defer fake.sendDataPacketMutex.Unlock() + fake.SendDataPacketStub = nil + fake.sendDataPacketReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendDataPacketReturnsOnCall(i int, result1 error) { + fake.sendDataPacketMutex.Lock() + defer fake.sendDataPacketMutex.Unlock() + fake.SendDataPacketStub = nil + if fake.sendDataPacketReturnsOnCall == nil { + fake.sendDataPacketReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendDataPacketReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendJoinResponse(arg1 *livekit.Room, arg2 []*livekit.ParticipantInfo, arg3 []*livekit.ICEServer) error { + var arg2Copy []*livekit.ParticipantInfo + if arg2 != nil { + arg2Copy = make([]*livekit.ParticipantInfo, len(arg2)) + copy(arg2Copy, arg2) + } + var arg3Copy []*livekit.ICEServer + if arg3 != nil { + arg3Copy = make([]*livekit.ICEServer, len(arg3)) + copy(arg3Copy, arg3) + } + fake.sendJoinResponseMutex.Lock() + ret, specificReturn := fake.sendJoinResponseReturnsOnCall[len(fake.sendJoinResponseArgsForCall)] + fake.sendJoinResponseArgsForCall = append(fake.sendJoinResponseArgsForCall, struct { + arg1 *livekit.Room + arg2 []*livekit.ParticipantInfo + arg3 []*livekit.ICEServer + }{arg1, arg2Copy, arg3Copy}) + stub := fake.SendJoinResponseStub + fakeReturns := fake.sendJoinResponseReturns + fake.recordInvocation("SendJoinResponse", []interface{}{arg1, arg2Copy, arg3Copy}) + fake.sendJoinResponseMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) SendJoinResponseCallCount() int { + fake.sendJoinResponseMutex.RLock() + defer fake.sendJoinResponseMutex.RUnlock() + return len(fake.sendJoinResponseArgsForCall) +} + +func (fake *FakeLocalParticipant) SendJoinResponseCalls(stub func(*livekit.Room, []*livekit.ParticipantInfo, []*livekit.ICEServer) error) { + fake.sendJoinResponseMutex.Lock() + defer fake.sendJoinResponseMutex.Unlock() + fake.SendJoinResponseStub = stub +} + +func (fake *FakeLocalParticipant) SendJoinResponseArgsForCall(i int) (*livekit.Room, []*livekit.ParticipantInfo, []*livekit.ICEServer) { + fake.sendJoinResponseMutex.RLock() + defer fake.sendJoinResponseMutex.RUnlock() + argsForCall := fake.sendJoinResponseArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeLocalParticipant) SendJoinResponseReturns(result1 error) { + fake.sendJoinResponseMutex.Lock() + defer fake.sendJoinResponseMutex.Unlock() + fake.SendJoinResponseStub = nil + fake.sendJoinResponseReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendJoinResponseReturnsOnCall(i int, result1 error) { + fake.sendJoinResponseMutex.Lock() + defer fake.sendJoinResponseMutex.Unlock() + fake.SendJoinResponseStub = nil + if fake.sendJoinResponseReturnsOnCall == nil { + fake.sendJoinResponseReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendJoinResponseReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendParticipantUpdate(arg1 []*livekit.ParticipantInfo, arg2 time.Time) error { + var arg1Copy []*livekit.ParticipantInfo + if arg1 != nil { + arg1Copy = make([]*livekit.ParticipantInfo, len(arg1)) + copy(arg1Copy, arg1) + } + fake.sendParticipantUpdateMutex.Lock() + ret, specificReturn := fake.sendParticipantUpdateReturnsOnCall[len(fake.sendParticipantUpdateArgsForCall)] + fake.sendParticipantUpdateArgsForCall = append(fake.sendParticipantUpdateArgsForCall, struct { + arg1 []*livekit.ParticipantInfo + arg2 time.Time + }{arg1Copy, arg2}) + stub := fake.SendParticipantUpdateStub + fakeReturns := fake.sendParticipantUpdateReturns + fake.recordInvocation("SendParticipantUpdate", []interface{}{arg1Copy, arg2}) + fake.sendParticipantUpdateMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) SendParticipantUpdateCallCount() int { + fake.sendParticipantUpdateMutex.RLock() + defer fake.sendParticipantUpdateMutex.RUnlock() + return len(fake.sendParticipantUpdateArgsForCall) +} + +func (fake *FakeLocalParticipant) SendParticipantUpdateCalls(stub func([]*livekit.ParticipantInfo, time.Time) error) { + fake.sendParticipantUpdateMutex.Lock() + defer fake.sendParticipantUpdateMutex.Unlock() + fake.SendParticipantUpdateStub = stub +} + +func (fake *FakeLocalParticipant) SendParticipantUpdateArgsForCall(i int) ([]*livekit.ParticipantInfo, time.Time) { + fake.sendParticipantUpdateMutex.RLock() + defer fake.sendParticipantUpdateMutex.RUnlock() + argsForCall := fake.sendParticipantUpdateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeLocalParticipant) SendParticipantUpdateReturns(result1 error) { + fake.sendParticipantUpdateMutex.Lock() + defer fake.sendParticipantUpdateMutex.Unlock() + fake.SendParticipantUpdateStub = nil + fake.sendParticipantUpdateReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendParticipantUpdateReturnsOnCall(i int, result1 error) { + fake.sendParticipantUpdateMutex.Lock() + defer fake.sendParticipantUpdateMutex.Unlock() + fake.SendParticipantUpdateStub = nil + if fake.sendParticipantUpdateReturnsOnCall == nil { + fake.sendParticipantUpdateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendParticipantUpdateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendRoomUpdate(arg1 *livekit.Room) error { + fake.sendRoomUpdateMutex.Lock() + ret, specificReturn := fake.sendRoomUpdateReturnsOnCall[len(fake.sendRoomUpdateArgsForCall)] + fake.sendRoomUpdateArgsForCall = append(fake.sendRoomUpdateArgsForCall, struct { + arg1 *livekit.Room + }{arg1}) + stub := fake.SendRoomUpdateStub + fakeReturns := fake.sendRoomUpdateReturns + fake.recordInvocation("SendRoomUpdate", []interface{}{arg1}) + fake.sendRoomUpdateMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) SendRoomUpdateCallCount() int { + fake.sendRoomUpdateMutex.RLock() + defer fake.sendRoomUpdateMutex.RUnlock() + return len(fake.sendRoomUpdateArgsForCall) +} + +func (fake *FakeLocalParticipant) SendRoomUpdateCalls(stub func(*livekit.Room) error) { + fake.sendRoomUpdateMutex.Lock() + defer fake.sendRoomUpdateMutex.Unlock() + fake.SendRoomUpdateStub = stub +} + +func (fake *FakeLocalParticipant) SendRoomUpdateArgsForCall(i int) *livekit.Room { + fake.sendRoomUpdateMutex.RLock() + defer fake.sendRoomUpdateMutex.RUnlock() + argsForCall := fake.sendRoomUpdateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) SendRoomUpdateReturns(result1 error) { + fake.sendRoomUpdateMutex.Lock() + defer fake.sendRoomUpdateMutex.Unlock() + fake.SendRoomUpdateStub = nil + fake.sendRoomUpdateReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendRoomUpdateReturnsOnCall(i int, result1 error) { + fake.sendRoomUpdateMutex.Lock() + defer fake.sendRoomUpdateMutex.Unlock() + fake.SendRoomUpdateStub = nil + if fake.sendRoomUpdateReturnsOnCall == nil { + fake.sendRoomUpdateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendRoomUpdateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendSpeakerUpdate(arg1 []*livekit.SpeakerInfo) error { + var arg1Copy []*livekit.SpeakerInfo + if arg1 != nil { + arg1Copy = make([]*livekit.SpeakerInfo, len(arg1)) + copy(arg1Copy, arg1) + } + fake.sendSpeakerUpdateMutex.Lock() + ret, specificReturn := fake.sendSpeakerUpdateReturnsOnCall[len(fake.sendSpeakerUpdateArgsForCall)] + fake.sendSpeakerUpdateArgsForCall = append(fake.sendSpeakerUpdateArgsForCall, struct { + arg1 []*livekit.SpeakerInfo + }{arg1Copy}) + stub := fake.SendSpeakerUpdateStub + fakeReturns := fake.sendSpeakerUpdateReturns + fake.recordInvocation("SendSpeakerUpdate", []interface{}{arg1Copy}) + fake.sendSpeakerUpdateMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) SendSpeakerUpdateCallCount() int { + fake.sendSpeakerUpdateMutex.RLock() + defer fake.sendSpeakerUpdateMutex.RUnlock() + return len(fake.sendSpeakerUpdateArgsForCall) +} + +func (fake *FakeLocalParticipant) SendSpeakerUpdateCalls(stub func([]*livekit.SpeakerInfo) error) { + fake.sendSpeakerUpdateMutex.Lock() + defer fake.sendSpeakerUpdateMutex.Unlock() + fake.SendSpeakerUpdateStub = stub +} + +func (fake *FakeLocalParticipant) SendSpeakerUpdateArgsForCall(i int) []*livekit.SpeakerInfo { + fake.sendSpeakerUpdateMutex.RLock() + defer fake.sendSpeakerUpdateMutex.RUnlock() + argsForCall := fake.sendSpeakerUpdateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) SendSpeakerUpdateReturns(result1 error) { + fake.sendSpeakerUpdateMutex.Lock() + defer fake.sendSpeakerUpdateMutex.Unlock() + fake.SendSpeakerUpdateStub = nil + fake.sendSpeakerUpdateReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SendSpeakerUpdateReturnsOnCall(i int, result1 error) { + fake.sendSpeakerUpdateMutex.Lock() + defer fake.sendSpeakerUpdateMutex.Unlock() + fake.SendSpeakerUpdateStub = nil + if fake.sendSpeakerUpdateReturnsOnCall == nil { + fake.sendSpeakerUpdateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.sendSpeakerUpdateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) SetMigrateState(arg1 types.MigrateState) { + fake.setMigrateStateMutex.Lock() + fake.setMigrateStateArgsForCall = append(fake.setMigrateStateArgsForCall, struct { + arg1 types.MigrateState + }{arg1}) + stub := fake.SetMigrateStateStub + fake.recordInvocation("SetMigrateState", []interface{}{arg1}) + fake.setMigrateStateMutex.Unlock() + if stub != nil { + fake.SetMigrateStateStub(arg1) + } +} + +func (fake *FakeLocalParticipant) SetMigrateStateCallCount() int { + fake.setMigrateStateMutex.RLock() + defer fake.setMigrateStateMutex.RUnlock() + return len(fake.setMigrateStateArgsForCall) +} + +func (fake *FakeLocalParticipant) SetMigrateStateCalls(stub func(types.MigrateState)) { + fake.setMigrateStateMutex.Lock() + defer fake.setMigrateStateMutex.Unlock() + fake.SetMigrateStateStub = stub +} + +func (fake *FakeLocalParticipant) SetMigrateStateArgsForCall(i int) types.MigrateState { + fake.setMigrateStateMutex.RLock() + defer fake.setMigrateStateMutex.RUnlock() + argsForCall := fake.setMigrateStateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) SetPermission(arg1 *livekit.ParticipantPermission) { + fake.setPermissionMutex.Lock() + fake.setPermissionArgsForCall = append(fake.setPermissionArgsForCall, struct { + arg1 *livekit.ParticipantPermission + }{arg1}) + stub := fake.SetPermissionStub + fake.recordInvocation("SetPermission", []interface{}{arg1}) + fake.setPermissionMutex.Unlock() + if stub != nil { + fake.SetPermissionStub(arg1) + } +} + +func (fake *FakeLocalParticipant) SetPermissionCallCount() int { + fake.setPermissionMutex.RLock() + defer fake.setPermissionMutex.RUnlock() + return len(fake.setPermissionArgsForCall) +} + +func (fake *FakeLocalParticipant) SetPermissionCalls(stub func(*livekit.ParticipantPermission)) { + fake.setPermissionMutex.Lock() + defer fake.setPermissionMutex.Unlock() + fake.SetPermissionStub = stub +} + +func (fake *FakeLocalParticipant) SetPermissionArgsForCall(i int) *livekit.ParticipantPermission { + fake.setPermissionMutex.RLock() + defer fake.setPermissionMutex.RUnlock() + argsForCall := fake.setPermissionArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) SetPreviousAnswer(arg1 *webrtc.SessionDescription) { + fake.setPreviousAnswerMutex.Lock() + fake.setPreviousAnswerArgsForCall = append(fake.setPreviousAnswerArgsForCall, struct { + arg1 *webrtc.SessionDescription + }{arg1}) + stub := fake.SetPreviousAnswerStub + fake.recordInvocation("SetPreviousAnswer", []interface{}{arg1}) + fake.setPreviousAnswerMutex.Unlock() + if stub != nil { + fake.SetPreviousAnswerStub(arg1) + } +} + +func (fake *FakeLocalParticipant) SetPreviousAnswerCallCount() int { + fake.setPreviousAnswerMutex.RLock() + defer fake.setPreviousAnswerMutex.RUnlock() + return len(fake.setPreviousAnswerArgsForCall) +} + +func (fake *FakeLocalParticipant) SetPreviousAnswerCalls(stub func(*webrtc.SessionDescription)) { + fake.setPreviousAnswerMutex.Lock() + defer fake.setPreviousAnswerMutex.Unlock() + fake.SetPreviousAnswerStub = stub +} + +func (fake *FakeLocalParticipant) SetPreviousAnswerArgsForCall(i int) *webrtc.SessionDescription { + fake.setPreviousAnswerMutex.RLock() + defer fake.setPreviousAnswerMutex.RUnlock() + argsForCall := fake.setPreviousAnswerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) SetResponseSink(arg1 routing.MessageSink) { + fake.setResponseSinkMutex.Lock() + fake.setResponseSinkArgsForCall = append(fake.setResponseSinkArgsForCall, struct { + arg1 routing.MessageSink + }{arg1}) + stub := fake.SetResponseSinkStub + fake.recordInvocation("SetResponseSink", []interface{}{arg1}) + fake.setResponseSinkMutex.Unlock() + if stub != nil { + fake.SetResponseSinkStub(arg1) + } +} + +func (fake *FakeLocalParticipant) SetResponseSinkCallCount() int { + fake.setResponseSinkMutex.RLock() + defer fake.setResponseSinkMutex.RUnlock() + return len(fake.setResponseSinkArgsForCall) +} + +func (fake *FakeLocalParticipant) SetResponseSinkCalls(stub func(routing.MessageSink)) { + fake.setResponseSinkMutex.Lock() + defer fake.setResponseSinkMutex.Unlock() + fake.SetResponseSinkStub = stub +} + +func (fake *FakeLocalParticipant) SetResponseSinkArgsForCall(i int) routing.MessageSink { + fake.setResponseSinkMutex.RLock() + defer fake.setResponseSinkMutex.RUnlock() + argsForCall := fake.setResponseSinkArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) SetTrackMuted(arg1 livekit.TrackID, arg2 bool, arg3 bool) { + fake.setTrackMutedMutex.Lock() + fake.setTrackMutedArgsForCall = append(fake.setTrackMutedArgsForCall, struct { + arg1 livekit.TrackID + arg2 bool + arg3 bool + }{arg1, arg2, arg3}) + stub := fake.SetTrackMutedStub + fake.recordInvocation("SetTrackMuted", []interface{}{arg1, arg2, arg3}) + fake.setTrackMutedMutex.Unlock() + if stub != nil { + fake.SetTrackMutedStub(arg1, arg2, arg3) + } +} + +func (fake *FakeLocalParticipant) SetTrackMutedCallCount() int { + fake.setTrackMutedMutex.RLock() + defer fake.setTrackMutedMutex.RUnlock() + return len(fake.setTrackMutedArgsForCall) +} + +func (fake *FakeLocalParticipant) SetTrackMutedCalls(stub func(livekit.TrackID, bool, bool)) { + fake.setTrackMutedMutex.Lock() + defer fake.setTrackMutedMutex.Unlock() + fake.SetTrackMutedStub = stub +} + +func (fake *FakeLocalParticipant) SetTrackMutedArgsForCall(i int) (livekit.TrackID, bool, bool) { + fake.setTrackMutedMutex.RLock() + defer fake.setTrackMutedMutex.RUnlock() + argsForCall := fake.setTrackMutedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeLocalParticipant) State() livekit.ParticipantInfo_State { + fake.stateMutex.Lock() + ret, specificReturn := fake.stateReturnsOnCall[len(fake.stateArgsForCall)] + fake.stateArgsForCall = append(fake.stateArgsForCall, struct { + }{}) + stub := fake.StateStub + fakeReturns := fake.stateReturns + fake.recordInvocation("State", []interface{}{}) + fake.stateMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) StateCallCount() int { + fake.stateMutex.RLock() + defer fake.stateMutex.RUnlock() + return len(fake.stateArgsForCall) +} + +func (fake *FakeLocalParticipant) StateCalls(stub func() livekit.ParticipantInfo_State) { + fake.stateMutex.Lock() + defer fake.stateMutex.Unlock() + fake.StateStub = stub +} + +func (fake *FakeLocalParticipant) StateReturns(result1 livekit.ParticipantInfo_State) { + fake.stateMutex.Lock() + defer fake.stateMutex.Unlock() + fake.StateStub = nil + fake.stateReturns = struct { + result1 livekit.ParticipantInfo_State + }{result1} +} + +func (fake *FakeLocalParticipant) StateReturnsOnCall(i int, result1 livekit.ParticipantInfo_State) { + fake.stateMutex.Lock() + defer fake.stateMutex.Unlock() + fake.StateStub = nil + if fake.stateReturnsOnCall == nil { + fake.stateReturnsOnCall = make(map[int]struct { + result1 livekit.ParticipantInfo_State + }) + } + fake.stateReturnsOnCall[i] = struct { + result1 livekit.ParticipantInfo_State + }{result1} +} + +func (fake *FakeLocalParticipant) SubscriberAsPrimary() bool { + fake.subscriberAsPrimaryMutex.Lock() + ret, specificReturn := fake.subscriberAsPrimaryReturnsOnCall[len(fake.subscriberAsPrimaryArgsForCall)] + fake.subscriberAsPrimaryArgsForCall = append(fake.subscriberAsPrimaryArgsForCall, struct { + }{}) + stub := fake.SubscriberAsPrimaryStub + fakeReturns := fake.subscriberAsPrimaryReturns + fake.recordInvocation("SubscriberAsPrimary", []interface{}{}) + fake.subscriberAsPrimaryMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) SubscriberAsPrimaryCallCount() int { + fake.subscriberAsPrimaryMutex.RLock() + defer fake.subscriberAsPrimaryMutex.RUnlock() + return len(fake.subscriberAsPrimaryArgsForCall) +} + +func (fake *FakeLocalParticipant) SubscriberAsPrimaryCalls(stub func() bool) { + fake.subscriberAsPrimaryMutex.Lock() + defer fake.subscriberAsPrimaryMutex.Unlock() + fake.SubscriberAsPrimaryStub = stub +} + +func (fake *FakeLocalParticipant) SubscriberAsPrimaryReturns(result1 bool) { + fake.subscriberAsPrimaryMutex.Lock() + defer fake.subscriberAsPrimaryMutex.Unlock() + fake.SubscriberAsPrimaryStub = nil + fake.subscriberAsPrimaryReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) SubscriberAsPrimaryReturnsOnCall(i int, result1 bool) { + fake.subscriberAsPrimaryMutex.Lock() + defer fake.subscriberAsPrimaryMutex.Unlock() + fake.SubscriberAsPrimaryStub = nil + if fake.subscriberAsPrimaryReturnsOnCall == nil { + fake.subscriberAsPrimaryReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.subscriberAsPrimaryReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) SubscriberMediaEngine() *webrtc.MediaEngine { + fake.subscriberMediaEngineMutex.Lock() + ret, specificReturn := fake.subscriberMediaEngineReturnsOnCall[len(fake.subscriberMediaEngineArgsForCall)] + fake.subscriberMediaEngineArgsForCall = append(fake.subscriberMediaEngineArgsForCall, struct { + }{}) + stub := fake.SubscriberMediaEngineStub + fakeReturns := fake.subscriberMediaEngineReturns + fake.recordInvocation("SubscriberMediaEngine", []interface{}{}) + fake.subscriberMediaEngineMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) SubscriberMediaEngineCallCount() int { + fake.subscriberMediaEngineMutex.RLock() + defer fake.subscriberMediaEngineMutex.RUnlock() + return len(fake.subscriberMediaEngineArgsForCall) +} + +func (fake *FakeLocalParticipant) SubscriberMediaEngineCalls(stub func() *webrtc.MediaEngine) { + fake.subscriberMediaEngineMutex.Lock() + defer fake.subscriberMediaEngineMutex.Unlock() + fake.SubscriberMediaEngineStub = stub +} + +func (fake *FakeLocalParticipant) SubscriberMediaEngineReturns(result1 *webrtc.MediaEngine) { + fake.subscriberMediaEngineMutex.Lock() + defer fake.subscriberMediaEngineMutex.Unlock() + fake.SubscriberMediaEngineStub = nil + fake.subscriberMediaEngineReturns = struct { + result1 *webrtc.MediaEngine + }{result1} +} + +func (fake *FakeLocalParticipant) SubscriberMediaEngineReturnsOnCall(i int, result1 *webrtc.MediaEngine) { + fake.subscriberMediaEngineMutex.Lock() + defer fake.subscriberMediaEngineMutex.Unlock() + fake.SubscriberMediaEngineStub = nil + if fake.subscriberMediaEngineReturnsOnCall == nil { + fake.subscriberMediaEngineReturnsOnCall = make(map[int]struct { + result1 *webrtc.MediaEngine + }) + } + fake.subscriberMediaEngineReturnsOnCall[i] = struct { + result1 *webrtc.MediaEngine + }{result1} +} + +func (fake *FakeLocalParticipant) SubscriberPC() *webrtc.PeerConnection { + fake.subscriberPCMutex.Lock() + ret, specificReturn := fake.subscriberPCReturnsOnCall[len(fake.subscriberPCArgsForCall)] + fake.subscriberPCArgsForCall = append(fake.subscriberPCArgsForCall, struct { + }{}) + stub := fake.SubscriberPCStub + fakeReturns := fake.subscriberPCReturns + fake.recordInvocation("SubscriberPC", []interface{}{}) + fake.subscriberPCMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) SubscriberPCCallCount() int { + fake.subscriberPCMutex.RLock() + defer fake.subscriberPCMutex.RUnlock() + return len(fake.subscriberPCArgsForCall) +} + +func (fake *FakeLocalParticipant) SubscriberPCCalls(stub func() *webrtc.PeerConnection) { + fake.subscriberPCMutex.Lock() + defer fake.subscriberPCMutex.Unlock() + fake.SubscriberPCStub = stub +} + +func (fake *FakeLocalParticipant) SubscriberPCReturns(result1 *webrtc.PeerConnection) { + fake.subscriberPCMutex.Lock() + defer fake.subscriberPCMutex.Unlock() + fake.SubscriberPCStub = nil + fake.subscriberPCReturns = struct { + result1 *webrtc.PeerConnection + }{result1} +} + +func (fake *FakeLocalParticipant) SubscriberPCReturnsOnCall(i int, result1 *webrtc.PeerConnection) { + fake.subscriberPCMutex.Lock() + defer fake.subscriberPCMutex.Unlock() + fake.SubscriberPCStub = nil + if fake.subscriberPCReturnsOnCall == nil { + fake.subscriberPCReturnsOnCall = make(map[int]struct { + result1 *webrtc.PeerConnection + }) + } + fake.subscriberPCReturnsOnCall[i] = struct { + result1 *webrtc.PeerConnection + }{result1} +} + +func (fake *FakeLocalParticipant) SubscriptionPermissionUpdate(arg1 livekit.ParticipantID, arg2 livekit.TrackID, arg3 bool) { + fake.subscriptionPermissionUpdateMutex.Lock() + fake.subscriptionPermissionUpdateArgsForCall = append(fake.subscriptionPermissionUpdateArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 livekit.TrackID + arg3 bool + }{arg1, arg2, arg3}) + stub := fake.SubscriptionPermissionUpdateStub + fake.recordInvocation("SubscriptionPermissionUpdate", []interface{}{arg1, arg2, arg3}) + fake.subscriptionPermissionUpdateMutex.Unlock() + if stub != nil { + fake.SubscriptionPermissionUpdateStub(arg1, arg2, arg3) + } +} + +func (fake *FakeLocalParticipant) SubscriptionPermissionUpdateCallCount() int { + fake.subscriptionPermissionUpdateMutex.RLock() + defer fake.subscriptionPermissionUpdateMutex.RUnlock() + return len(fake.subscriptionPermissionUpdateArgsForCall) +} + +func (fake *FakeLocalParticipant) SubscriptionPermissionUpdateCalls(stub func(livekit.ParticipantID, livekit.TrackID, bool)) { + fake.subscriptionPermissionUpdateMutex.Lock() + defer fake.subscriptionPermissionUpdateMutex.Unlock() + fake.SubscriptionPermissionUpdateStub = stub +} + +func (fake *FakeLocalParticipant) SubscriptionPermissionUpdateArgsForCall(i int) (livekit.ParticipantID, livekit.TrackID, bool) { + fake.subscriptionPermissionUpdateMutex.RLock() + defer fake.subscriptionPermissionUpdateMutex.RUnlock() + argsForCall := fake.subscriptionPermissionUpdateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeLocalParticipant) UpdateMediaLoss(arg1 string, arg2 livekit.TrackID, arg3 uint32) error { + fake.updateMediaLossMutex.Lock() + ret, specificReturn := fake.updateMediaLossReturnsOnCall[len(fake.updateMediaLossArgsForCall)] + fake.updateMediaLossArgsForCall = append(fake.updateMediaLossArgsForCall, struct { + arg1 string + arg2 livekit.TrackID + arg3 uint32 + }{arg1, arg2, arg3}) + stub := fake.UpdateMediaLossStub + fakeReturns := fake.updateMediaLossReturns + fake.recordInvocation("UpdateMediaLoss", []interface{}{arg1, arg2, arg3}) + fake.updateMediaLossMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) UpdateMediaLossCallCount() int { + fake.updateMediaLossMutex.RLock() + defer fake.updateMediaLossMutex.RUnlock() + return len(fake.updateMediaLossArgsForCall) +} + +func (fake *FakeLocalParticipant) UpdateMediaLossCalls(stub func(string, livekit.TrackID, uint32) error) { + fake.updateMediaLossMutex.Lock() + defer fake.updateMediaLossMutex.Unlock() + fake.UpdateMediaLossStub = stub +} + +func (fake *FakeLocalParticipant) UpdateMediaLossArgsForCall(i int) (string, livekit.TrackID, uint32) { + fake.updateMediaLossMutex.RLock() + defer fake.updateMediaLossMutex.RUnlock() + argsForCall := fake.updateMediaLossArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeLocalParticipant) UpdateMediaLossReturns(result1 error) { + fake.updateMediaLossMutex.Lock() + defer fake.updateMediaLossMutex.Unlock() + fake.UpdateMediaLossStub = nil + fake.updateMediaLossReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) UpdateMediaLossReturnsOnCall(i int, result1 error) { + fake.updateMediaLossMutex.Lock() + defer fake.updateMediaLossMutex.Unlock() + fake.UpdateMediaLossStub = nil + if fake.updateMediaLossReturnsOnCall == nil { + fake.updateMediaLossReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateMediaLossReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) UpdateSubscribedQuality(arg1 string, arg2 livekit.TrackID, arg3 livekit.VideoQuality) error { + fake.updateSubscribedQualityMutex.Lock() + ret, specificReturn := fake.updateSubscribedQualityReturnsOnCall[len(fake.updateSubscribedQualityArgsForCall)] + fake.updateSubscribedQualityArgsForCall = append(fake.updateSubscribedQualityArgsForCall, struct { + arg1 string + arg2 livekit.TrackID + arg3 livekit.VideoQuality + }{arg1, arg2, arg3}) + stub := fake.UpdateSubscribedQualityStub + fakeReturns := fake.updateSubscribedQualityReturns + fake.recordInvocation("UpdateSubscribedQuality", []interface{}{arg1, arg2, arg3}) + fake.updateSubscribedQualityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) UpdateSubscribedQualityCallCount() int { + fake.updateSubscribedQualityMutex.RLock() + defer fake.updateSubscribedQualityMutex.RUnlock() + return len(fake.updateSubscribedQualityArgsForCall) +} + +func (fake *FakeLocalParticipant) UpdateSubscribedQualityCalls(stub func(string, livekit.TrackID, livekit.VideoQuality) error) { + fake.updateSubscribedQualityMutex.Lock() + defer fake.updateSubscribedQualityMutex.Unlock() + fake.UpdateSubscribedQualityStub = stub +} + +func (fake *FakeLocalParticipant) UpdateSubscribedQualityArgsForCall(i int) (string, livekit.TrackID, livekit.VideoQuality) { + fake.updateSubscribedQualityMutex.RLock() + defer fake.updateSubscribedQualityMutex.RUnlock() + argsForCall := fake.updateSubscribedQualityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeLocalParticipant) UpdateSubscribedQualityReturns(result1 error) { + fake.updateSubscribedQualityMutex.Lock() + defer fake.updateSubscribedQualityMutex.Unlock() + fake.UpdateSubscribedQualityStub = nil + fake.updateSubscribedQualityReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) UpdateSubscribedQualityReturnsOnCall(i int, result1 error) { + fake.updateSubscribedQualityMutex.Lock() + defer fake.updateSubscribedQualityMutex.Unlock() + fake.UpdateSubscribedQualityStub = nil + if fake.updateSubscribedQualityReturnsOnCall == nil { + fake.updateSubscribedQualityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateSubscribedQualityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.addICECandidateMutex.RLock() + defer fake.addICECandidateMutex.RUnlock() + fake.addMigratedTrackMutex.RLock() + defer fake.addMigratedTrackMutex.RUnlock() + fake.addSubscribedTrackMutex.RLock() + defer fake.addSubscribedTrackMutex.RUnlock() + fake.addTrackMutex.RLock() + defer fake.addTrackMutex.RUnlock() + fake.canPublishMutex.RLock() + defer fake.canPublishMutex.RUnlock() + fake.canPublishDataMutex.RLock() + defer fake.canPublishDataMutex.RUnlock() + fake.canSubscribeMutex.RLock() + defer fake.canSubscribeMutex.RUnlock() + fake.connectedAtMutex.RLock() + defer fake.connectedAtMutex.RUnlock() + fake.getAudioLevelMutex.RLock() + defer fake.getAudioLevelMutex.RUnlock() + fake.getConnectionQualityMutex.RLock() + defer fake.getConnectionQualityMutex.RUnlock() + fake.getResponseSinkMutex.RLock() + defer fake.getResponseSinkMutex.RUnlock() + fake.getSubscribedParticipantsMutex.RLock() + defer fake.getSubscribedParticipantsMutex.RUnlock() + fake.getSubscribedTrackMutex.RLock() + defer fake.getSubscribedTrackMutex.RUnlock() + fake.getSubscribedTracksMutex.RLock() + defer fake.getSubscribedTracksMutex.RUnlock() + fake.handleAnswerMutex.RLock() + defer fake.handleAnswerMutex.RUnlock() + fake.handleOfferMutex.RLock() + defer fake.handleOfferMutex.RUnlock() + fake.iCERestartMutex.RLock() + defer fake.iCERestartMutex.RUnlock() + fake.isReadyMutex.RLock() + defer fake.isReadyMutex.RUnlock() + fake.isRecorderMutex.RLock() + defer fake.isRecorderMutex.RUnlock() + fake.migrateStateMutex.RLock() + defer fake.migrateStateMutex.RUnlock() + fake.negotiateMutex.RLock() + defer fake.negotiateMutex.RUnlock() + fake.onCloseMutex.RLock() + defer fake.onCloseMutex.RUnlock() + fake.onDataPacketMutex.RLock() + defer fake.onDataPacketMutex.RUnlock() + fake.onMetadataUpdateMutex.RLock() + defer fake.onMetadataUpdateMutex.RUnlock() + fake.onStateChangeMutex.RLock() + defer fake.onStateChangeMutex.RUnlock() + fake.onTrackUpdatedMutex.RLock() + defer fake.onTrackUpdatedMutex.RUnlock() + fake.protocolVersionMutex.RLock() + defer fake.protocolVersionMutex.RUnlock() + fake.removeSubscribedTrackMutex.RLock() + defer fake.removeSubscribedTrackMutex.RUnlock() + fake.sendConnectionQualityUpdateMutex.RLock() + defer fake.sendConnectionQualityUpdateMutex.RUnlock() + fake.sendDataPacketMutex.RLock() + defer fake.sendDataPacketMutex.RUnlock() + fake.sendJoinResponseMutex.RLock() + defer fake.sendJoinResponseMutex.RUnlock() + fake.sendParticipantUpdateMutex.RLock() + defer fake.sendParticipantUpdateMutex.RUnlock() + fake.sendRoomUpdateMutex.RLock() + defer fake.sendRoomUpdateMutex.RUnlock() + fake.sendSpeakerUpdateMutex.RLock() + defer fake.sendSpeakerUpdateMutex.RUnlock() + fake.setMigrateStateMutex.RLock() + defer fake.setMigrateStateMutex.RUnlock() + fake.setPermissionMutex.RLock() + defer fake.setPermissionMutex.RUnlock() + fake.setPreviousAnswerMutex.RLock() + defer fake.setPreviousAnswerMutex.RUnlock() + fake.setResponseSinkMutex.RLock() + defer fake.setResponseSinkMutex.RUnlock() + fake.setTrackMutedMutex.RLock() + defer fake.setTrackMutedMutex.RUnlock() + fake.stateMutex.RLock() + defer fake.stateMutex.RUnlock() + fake.subscriberAsPrimaryMutex.RLock() + defer fake.subscriberAsPrimaryMutex.RUnlock() + fake.subscriberMediaEngineMutex.RLock() + defer fake.subscriberMediaEngineMutex.RUnlock() + fake.subscriberPCMutex.RLock() + defer fake.subscriberPCMutex.RUnlock() + fake.subscriptionPermissionUpdateMutex.RLock() + defer fake.subscriptionPermissionUpdateMutex.RUnlock() + fake.updateMediaLossMutex.RLock() + defer fake.updateMediaLossMutex.RUnlock() + fake.updateSubscribedQualityMutex.RLock() + defer fake.updateSubscribedQualityMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeLocalParticipant) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ types.LocalParticipant = new(FakeLocalParticipant) diff --git a/pkg/rtc/types/typesfakes/fake_local_published_track.go b/pkg/rtc/types/typesfakes/fake_local_published_track.go new file mode 100644 index 000000000..97675484b --- /dev/null +++ b/pkg/rtc/types/typesfakes/fake_local_published_track.go @@ -0,0 +1,302 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package typesfakes + +import ( + "sync" + + "github.com/livekit/livekit-server/pkg/rtc/types" +) + +type FakeLocalPublishedTrack struct { + GetAudioLevelStub func() (uint8, bool) + getAudioLevelMutex sync.RWMutex + getAudioLevelArgsForCall []struct { + } + getAudioLevelReturns struct { + result1 uint8 + result2 bool + } + getAudioLevelReturnsOnCall map[int]struct { + result1 uint8 + result2 bool + } + GetConnectionScoreStub func() float64 + getConnectionScoreMutex sync.RWMutex + getConnectionScoreArgsForCall []struct { + } + getConnectionScoreReturns struct { + result1 float64 + } + getConnectionScoreReturnsOnCall map[int]struct { + result1 float64 + } + SdpCidStub func() string + sdpCidMutex sync.RWMutex + sdpCidArgsForCall []struct { + } + sdpCidReturns struct { + result1 string + } + sdpCidReturnsOnCall map[int]struct { + result1 string + } + SignalCidStub func() string + signalCidMutex sync.RWMutex + signalCidArgsForCall []struct { + } + signalCidReturns struct { + result1 string + } + signalCidReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeLocalPublishedTrack) GetAudioLevel() (uint8, bool) { + fake.getAudioLevelMutex.Lock() + ret, specificReturn := fake.getAudioLevelReturnsOnCall[len(fake.getAudioLevelArgsForCall)] + fake.getAudioLevelArgsForCall = append(fake.getAudioLevelArgsForCall, struct { + }{}) + stub := fake.GetAudioLevelStub + fakeReturns := fake.getAudioLevelReturns + fake.recordInvocation("GetAudioLevel", []interface{}{}) + fake.getAudioLevelMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeLocalPublishedTrack) GetAudioLevelCallCount() int { + fake.getAudioLevelMutex.RLock() + defer fake.getAudioLevelMutex.RUnlock() + return len(fake.getAudioLevelArgsForCall) +} + +func (fake *FakeLocalPublishedTrack) GetAudioLevelCalls(stub func() (uint8, bool)) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = stub +} + +func (fake *FakeLocalPublishedTrack) GetAudioLevelReturns(result1 uint8, result2 bool) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = nil + fake.getAudioLevelReturns = struct { + result1 uint8 + result2 bool + }{result1, result2} +} + +func (fake *FakeLocalPublishedTrack) GetAudioLevelReturnsOnCall(i int, result1 uint8, result2 bool) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = nil + if fake.getAudioLevelReturnsOnCall == nil { + fake.getAudioLevelReturnsOnCall = make(map[int]struct { + result1 uint8 + result2 bool + }) + } + fake.getAudioLevelReturnsOnCall[i] = struct { + result1 uint8 + result2 bool + }{result1, result2} +} + +func (fake *FakeLocalPublishedTrack) GetConnectionScore() float64 { + fake.getConnectionScoreMutex.Lock() + ret, specificReturn := fake.getConnectionScoreReturnsOnCall[len(fake.getConnectionScoreArgsForCall)] + fake.getConnectionScoreArgsForCall = append(fake.getConnectionScoreArgsForCall, struct { + }{}) + stub := fake.GetConnectionScoreStub + fakeReturns := fake.getConnectionScoreReturns + fake.recordInvocation("GetConnectionScore", []interface{}{}) + fake.getConnectionScoreMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalPublishedTrack) GetConnectionScoreCallCount() int { + fake.getConnectionScoreMutex.RLock() + defer fake.getConnectionScoreMutex.RUnlock() + return len(fake.getConnectionScoreArgsForCall) +} + +func (fake *FakeLocalPublishedTrack) GetConnectionScoreCalls(stub func() float64) { + fake.getConnectionScoreMutex.Lock() + defer fake.getConnectionScoreMutex.Unlock() + fake.GetConnectionScoreStub = stub +} + +func (fake *FakeLocalPublishedTrack) GetConnectionScoreReturns(result1 float64) { + fake.getConnectionScoreMutex.Lock() + defer fake.getConnectionScoreMutex.Unlock() + fake.GetConnectionScoreStub = nil + fake.getConnectionScoreReturns = struct { + result1 float64 + }{result1} +} + +func (fake *FakeLocalPublishedTrack) GetConnectionScoreReturnsOnCall(i int, result1 float64) { + fake.getConnectionScoreMutex.Lock() + defer fake.getConnectionScoreMutex.Unlock() + fake.GetConnectionScoreStub = nil + if fake.getConnectionScoreReturnsOnCall == nil { + fake.getConnectionScoreReturnsOnCall = make(map[int]struct { + result1 float64 + }) + } + fake.getConnectionScoreReturnsOnCall[i] = struct { + result1 float64 + }{result1} +} + +func (fake *FakeLocalPublishedTrack) SdpCid() string { + fake.sdpCidMutex.Lock() + ret, specificReturn := fake.sdpCidReturnsOnCall[len(fake.sdpCidArgsForCall)] + fake.sdpCidArgsForCall = append(fake.sdpCidArgsForCall, struct { + }{}) + stub := fake.SdpCidStub + fakeReturns := fake.sdpCidReturns + fake.recordInvocation("SdpCid", []interface{}{}) + fake.sdpCidMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalPublishedTrack) SdpCidCallCount() int { + fake.sdpCidMutex.RLock() + defer fake.sdpCidMutex.RUnlock() + return len(fake.sdpCidArgsForCall) +} + +func (fake *FakeLocalPublishedTrack) SdpCidCalls(stub func() string) { + fake.sdpCidMutex.Lock() + defer fake.sdpCidMutex.Unlock() + fake.SdpCidStub = stub +} + +func (fake *FakeLocalPublishedTrack) SdpCidReturns(result1 string) { + fake.sdpCidMutex.Lock() + defer fake.sdpCidMutex.Unlock() + fake.SdpCidStub = nil + fake.sdpCidReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeLocalPublishedTrack) SdpCidReturnsOnCall(i int, result1 string) { + fake.sdpCidMutex.Lock() + defer fake.sdpCidMutex.Unlock() + fake.SdpCidStub = nil + if fake.sdpCidReturnsOnCall == nil { + fake.sdpCidReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.sdpCidReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeLocalPublishedTrack) SignalCid() string { + fake.signalCidMutex.Lock() + ret, specificReturn := fake.signalCidReturnsOnCall[len(fake.signalCidArgsForCall)] + fake.signalCidArgsForCall = append(fake.signalCidArgsForCall, struct { + }{}) + stub := fake.SignalCidStub + fakeReturns := fake.signalCidReturns + fake.recordInvocation("SignalCid", []interface{}{}) + fake.signalCidMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalPublishedTrack) SignalCidCallCount() int { + fake.signalCidMutex.RLock() + defer fake.signalCidMutex.RUnlock() + return len(fake.signalCidArgsForCall) +} + +func (fake *FakeLocalPublishedTrack) SignalCidCalls(stub func() string) { + fake.signalCidMutex.Lock() + defer fake.signalCidMutex.Unlock() + fake.SignalCidStub = stub +} + +func (fake *FakeLocalPublishedTrack) SignalCidReturns(result1 string) { + fake.signalCidMutex.Lock() + defer fake.signalCidMutex.Unlock() + fake.SignalCidStub = nil + fake.signalCidReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeLocalPublishedTrack) SignalCidReturnsOnCall(i int, result1 string) { + fake.signalCidMutex.Lock() + defer fake.signalCidMutex.Unlock() + fake.SignalCidStub = nil + if fake.signalCidReturnsOnCall == nil { + fake.signalCidReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.signalCidReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeLocalPublishedTrack) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.getAudioLevelMutex.RLock() + defer fake.getAudioLevelMutex.RUnlock() + fake.getConnectionScoreMutex.RLock() + defer fake.getConnectionScoreMutex.RUnlock() + fake.sdpCidMutex.RLock() + defer fake.sdpCidMutex.RUnlock() + fake.signalCidMutex.RLock() + defer fake.signalCidMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeLocalPublishedTrack) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ types.LocalPublishedTrack = new(FakeLocalPublishedTrack) diff --git a/pkg/rtc/types/typesfakes/fake_participant.go b/pkg/rtc/types/typesfakes/fake_participant.go index 1f1d621e4..964178d98 100644 --- a/pkg/rtc/types/typesfakes/fake_participant.go +++ b/pkg/rtc/types/typesfakes/fake_participant.go @@ -282,17 +282,6 @@ type FakeParticipant struct { isRecorderReturnsOnCall map[int]struct { result1 bool } - IsSubscribedToStub func(livekit.ParticipantID) bool - isSubscribedToMutex sync.RWMutex - isSubscribedToArgsForCall []struct { - arg1 livekit.ParticipantID - } - isSubscribedToReturns struct { - result1 bool - } - isSubscribedToReturnsOnCall map[int]struct { - result1 bool - } MigrateStateStub func() types.MigrateState migrateStateMutex sync.RWMutex migrateStateArgsForCall []struct { @@ -2001,67 +1990,6 @@ func (fake *FakeParticipant) IsRecorderReturnsOnCall(i int, result1 bool) { }{result1} } -func (fake *FakeParticipant) IsSubscribedTo(arg1 livekit.ParticipantID) bool { - fake.isSubscribedToMutex.Lock() - ret, specificReturn := fake.isSubscribedToReturnsOnCall[len(fake.isSubscribedToArgsForCall)] - fake.isSubscribedToArgsForCall = append(fake.isSubscribedToArgsForCall, struct { - arg1 livekit.ParticipantID - }{arg1}) - stub := fake.IsSubscribedToStub - fakeReturns := fake.isSubscribedToReturns - fake.recordInvocation("IsSubscribedTo", []interface{}{arg1}) - fake.isSubscribedToMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeParticipant) IsSubscribedToCallCount() int { - fake.isSubscribedToMutex.RLock() - defer fake.isSubscribedToMutex.RUnlock() - return len(fake.isSubscribedToArgsForCall) -} - -func (fake *FakeParticipant) IsSubscribedToCalls(stub func(livekit.ParticipantID) bool) { - fake.isSubscribedToMutex.Lock() - defer fake.isSubscribedToMutex.Unlock() - fake.IsSubscribedToStub = stub -} - -func (fake *FakeParticipant) IsSubscribedToArgsForCall(i int) livekit.ParticipantID { - fake.isSubscribedToMutex.RLock() - defer fake.isSubscribedToMutex.RUnlock() - argsForCall := fake.isSubscribedToArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) IsSubscribedToReturns(result1 bool) { - fake.isSubscribedToMutex.Lock() - defer fake.isSubscribedToMutex.Unlock() - fake.IsSubscribedToStub = nil - fake.isSubscribedToReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakeParticipant) IsSubscribedToReturnsOnCall(i int, result1 bool) { - fake.isSubscribedToMutex.Lock() - defer fake.isSubscribedToMutex.Unlock() - fake.IsSubscribedToStub = nil - if fake.isSubscribedToReturnsOnCall == nil { - fake.isSubscribedToReturnsOnCall = make(map[int]struct { - result1 bool - }) - } - fake.isSubscribedToReturnsOnCall[i] = struct { - result1 bool - }{result1} -} - func (fake *FakeParticipant) MigrateState() types.MigrateState { fake.migrateStateMutex.Lock() ret, specificReturn := fake.migrateStateReturnsOnCall[len(fake.migrateStateArgsForCall)] @@ -3661,8 +3589,6 @@ func (fake *FakeParticipant) Invocations() map[string][][]interface{} { defer fake.isReadyMutex.RUnlock() fake.isRecorderMutex.RLock() defer fake.isRecorderMutex.RUnlock() - fake.isSubscribedToMutex.RLock() - defer fake.isSubscribedToMutex.RUnlock() fake.migrateStateMutex.RLock() defer fake.migrateStateMutex.RUnlock() fake.negotiateMutex.RLock() diff --git a/pkg/rtc/uptrackmanager.go b/pkg/rtc/uptrackmanager.go index 3fb78301a..68a3c5735 100644 --- a/pkg/rtc/uptrackmanager.go +++ b/pkg/rtc/uptrackmanager.go @@ -63,7 +63,7 @@ func (u *UptrackManager) Close() { } } -func (u *UptrackManager) OnClose(f func()) { +func (u *UptrackManager) OnUptrackManagerClose(f func()) { u.onClose = f } @@ -79,7 +79,7 @@ func (u *UptrackManager) ToProto() []*livekit.TrackInfo { return trackInfos } -func (u *UptrackManager) OnTrackUpdated(f func(track types.PublishedTrack, onlyIfReady bool)) { +func (u *UptrackManager) OnPublishedTrackUpdated(f func(track types.PublishedTrack, onlyIfReady bool)) { u.onTrackUpdated = f } @@ -143,7 +143,7 @@ func (u *UptrackManager) RemoveSubscriber(sub types.Participant, trackID livekit u.lock.Unlock() } -func (u *UptrackManager) SetTrackMuted(trackID livekit.TrackID, muted bool) types.PublishedTrack { +func (u *UptrackManager) SetPublishedTrackMuted(trackID livekit.TrackID, muted bool) types.PublishedTrack { u.lock.RLock() track := u.publishedTracks[trackID] u.lock.RUnlock()