diff --git a/pkg/rtc/helper_test.go b/pkg/rtc/helper_test.go index 5d3e43147..78b2d761b 100644 --- a/pkg/rtc/helper_test.go +++ b/pkg/rtc/helper_test.go @@ -8,8 +8,8 @@ import ( "github.com/livekit/livekit-server/pkg/rtc/types/typesfakes" ) -func newMockParticipant(identity livekit.ParticipantIdentity, protocol types.ProtocolVersion, hidden bool) *typesfakes.FakeParticipant { - p := &typesfakes.FakeParticipant{} +func newMockParticipant(identity livekit.ParticipantIdentity, protocol types.ProtocolVersion, hidden bool) *typesfakes.FakeLocalParticipant { + p := &typesfakes.FakeLocalParticipant{} p.IDReturns(livekit.ParticipantID(utils.NewGuid(utils.ParticipantPrefix))) p.IdentityReturns(identity) p.StateReturns(livekit.ParticipantInfo_JOINED) @@ -20,7 +20,7 @@ func newMockParticipant(identity livekit.ParticipantIdentity, protocol types.Pro p.HiddenReturns(hidden) p.SetMetadataStub = func(m string) { - var f func(participant types.Participant) + var f func(participant types.LocalParticipant) if p.OnMetadataUpdateCallCount() > 0 { f = p.OnMetadataUpdateArgsForCall(p.OnMetadataUpdateCallCount() - 1) } @@ -29,7 +29,7 @@ func newMockParticipant(identity livekit.ParticipantIdentity, protocol types.Pro } } updateTrack := func() { - var f func(participant types.Participant, track types.PublishedTrack) + var f func(participant types.LocalParticipant, track types.MediaTrack) if p.OnTrackUpdatedCallCount() > 0 { f = p.OnTrackUpdatedArgsForCall(p.OnTrackUpdatedCallCount() - 1) } @@ -48,8 +48,8 @@ func newMockParticipant(identity livekit.ParticipantIdentity, protocol types.Pro return p } -func newMockTrack(kind livekit.TrackType, name string) *typesfakes.FakePublishedTrack { - t := &typesfakes.FakePublishedTrack{} +func newMockTrack(kind livekit.TrackType, name string) *typesfakes.FakeMediaTrack { + t := &typesfakes.FakeMediaTrack{} t.IDReturns(livekit.TrackID(utils.NewGuid(utils.TrackPrefix))) t.KindReturns(kind) t.NameReturns(name) diff --git a/pkg/rtc/localparticipant.go b/pkg/rtc/localparticipant.go deleted file mode 100644 index 1c7c7ecd9..000000000 --- a/pkg/rtc/localparticipant.go +++ /dev/null @@ -1,403 +0,0 @@ -package rtc - -import ( - "errors" - "sync" - - "github.com/livekit/protocol/livekit" - "github.com/livekit/protocol/logger" - "github.com/livekit/protocol/utils" - "github.com/pion/rtcp" - "github.com/pion/webrtc/v3" - - "github.com/livekit/livekit-server/pkg/config" - "github.com/livekit/livekit-server/pkg/rtc/types" - "github.com/livekit/livekit-server/pkg/sfu" - "github.com/livekit/livekit-server/pkg/sfu/twcc" - "github.com/livekit/livekit-server/pkg/telemetry" -) - -type pendingTrackInfo struct { - *livekit.TrackInfo - migrated bool -} - -type LocalParticipantParams struct { - Identity livekit.ParticipantIdentity - SID livekit.ParticipantID - Config *WebRTCConfig - AudioConfig config.AudioConfig - Telemetry telemetry.TelemetryService - ThrottleConfig config.PLIThrottleConfig - Logger logger.Logger - SimTracks map[uint32]SimulcastTrackInfo -} - -type LocalParticipant struct { - params LocalParticipantParams - rtcpCh chan []rtcp.Packet - pliThrottle *pliThrottle - - // hold reference for MediaTrack - twcc *twcc.Responder - - // client intended to publish, yet to be reconciled - pendingTracksLock sync.RWMutex - pendingTracks map[string]*pendingTrackInfo - - *UptrackManager - - // callbacks & handlers - onWriteRTCP func(pkts []rtcp.Packet) - onTrackPublished func(track types.PublishedTrack) -} - -func NewLocalParticipant(params LocalParticipantParams) *LocalParticipant { - l := &LocalParticipant{ - params: params, - rtcpCh: make(chan []rtcp.Packet, 50), - pliThrottle: newPLIThrottle(params.ThrottleConfig), - pendingTracks: make(map[string]*pendingTrackInfo), - } - - l.setupUptrackManager() - - return l -} - -func (l *LocalParticipant) Start() { - l.UptrackManager.Start() - go l.rtcpSendWorker() -} - -func (l *LocalParticipant) Close() { - l.UptrackManager.Close() - - l.pendingTracksLock.Lock() - l.pendingTracks = make(map[string]*pendingTrackInfo) - l.pendingTracksLock.Unlock() -} - -func (l *LocalParticipant) OnWriteRTCP(f func(pkts []rtcp.Packet)) { - l.onWriteRTCP = f -} - -func (l *LocalParticipant) OnTrackPublished(f func(track types.PublishedTrack)) { - l.onTrackPublished = f -} - -// AddTrack is called when client intends to publish track. -// records track details and lets client know it's ok to proceed -func (l *LocalParticipant) AddTrack(req *livekit.AddTrackRequest) *livekit.TrackInfo { - l.pendingTracksLock.Lock() - defer l.pendingTracksLock.Unlock() - - // if track is already published, reject - if l.pendingTracks[req.Cid] != nil { - return nil - } - - if l.UptrackManager.GetPublishedTrackBySignalCidOrSdpCid(req.Cid) != nil { - return nil - } - - ti := &livekit.TrackInfo{ - Type: req.Type, - Name: req.Name, - Sid: utils.NewGuid(utils.TrackPrefix), - Width: req.Width, - Height: req.Height, - Muted: req.Muted, - DisableDtx: req.DisableDtx, - Source: req.Source, - Layers: req.Layers, - } - l.pendingTracks[req.Cid] = &pendingTrackInfo{TrackInfo: ti} - - return ti -} - -func (l *LocalParticipant) AddMigratedTrack(cid string, ti *livekit.TrackInfo) { - l.pendingTracksLock.Lock() - defer l.pendingTracksLock.Unlock() - - l.pendingTracks[cid] = &pendingTrackInfo{ti, true} -} - -func (l *LocalParticipant) SetTrackMuted(trackID livekit.TrackID, muted bool) { - 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 - } - - isPending := false - l.pendingTracksLock.RLock() - for _, ti := range l.pendingTracks { - if livekit.TrackID(ti.Sid) == trackID { - ti.Muted = muted - isPending = true - break - } - } - l.pendingTracksLock.RUnlock() - - if !isPending { - l.params.Logger.Warnw("could not locate track", nil, "track", trackID) - } -} - -func (l *LocalParticipant) GetAudioLevel() (level uint8, active bool) { - level = SilentAudioLevel - for _, pt := range l.UptrackManager.GetPublishedTracks() { - tl, ta := pt.GetAudioLevel() - if ta { - active = true - if tl < level { - level = tl - } - } - } - return -} - -func (l *LocalParticipant) GetConnectionQuality() (scores float64, numTracks int) { - for _, pt := range l.UptrackManager.GetPublishedTracks() { - if pt.IsMuted() { - continue - } - scores += pt.GetConnectionScore() - numTracks++ - } - - return -} - -func (l *LocalParticipant) GetDTX() bool { - l.pendingTracksLock.RLock() - defer l.pendingTracksLock.RUnlock() - - // - // Although DTX is set per track, there are cases where - // pending track has to be looked up by kind. This happens - // when clients change track id between signalling and SDP. - // In that case, look at all pending tracks by kind and - // enable DTX even if one has it enabled. - // - // Most of the time in practice, there is going to be one - // audio kind track and hence this is fine. - // - for _, ti := range l.pendingTracks { - if ti.Type == livekit.TrackType_AUDIO { - if !ti.TrackInfo.DisableDtx { - return true - } - } - } - - return false -} - -func (l *LocalParticipant) MediaTrackReceived(track *webrtc.TrackRemote, rtpReceiver *webrtc.RTPReceiver, mid string) (types.PublishedTrack, bool) { - l.pendingTracksLock.Lock() - newTrack := false - - // use existing mediatrack to handle simulcast - mt, ok := l.UptrackManager.GetPublishedTrackBySdpCid(track.ID()).(*MediaTrack) - if !ok { - signalCid, ti := l.getPendingTrack(track.ID(), ToProtoTrackKind(track.Kind())) - if ti == nil { - l.pendingTracksLock.Unlock() - return nil, false - } - - ti.MimeType = track.Codec().MimeType - ti.Mid = mid - - mt = NewMediaTrack(track, MediaTrackParams{ - TrackInfo: ti, - SignalCid: signalCid, - SdpCid: track.ID(), - ParticipantID: l.params.SID, - ParticipantIdentity: l.params.Identity, - RTCPChan: l.rtcpCh, - BufferFactory: l.params.Config.BufferFactory, - ReceiverConfig: l.params.Config.Receiver, - AudioConfig: l.params.AudioConfig, - Telemetry: l.params.Telemetry, - Logger: l.params.Logger, - SubscriberConfig: l.params.Config.Subscriber, - }) - - for ssrc, info := range l.params.SimTracks { - if info.Mid == mid { - mt.TrySetSimulcastSSRC(uint8(sfu.RidToLayer(info.Rid)), ssrc) - } - } - - // add to published and clean up pending - l.UptrackManager.AddPublishedTrack(mt) - delete(l.pendingTracks, signalCid) - - newTrack = true - } - - ssrc := uint32(track.SSRC()) - l.pliThrottle.addTrack(ssrc, track.RID()) - if l.twcc == nil { - l.twcc = twcc.NewTransportWideCCResponder(ssrc) - l.twcc.OnFeedback(func(pkt rtcp.RawPacket) { - if l.onWriteRTCP != nil { - l.onWriteRTCP([]rtcp.Packet{&pkt}) - } - }) - } - l.pendingTracksLock.Unlock() - - mt.AddReceiver(rtpReceiver, track, l.twcc) - - if newTrack { - l.handleTrackPublished(mt) - } - - return mt, newTrack -} - -func (l *LocalParticipant) handleTrackPublished(track types.PublishedTrack) { - if l.onTrackPublished != nil { - l.onTrackPublished(track) - } -} - -func (l *LocalParticipant) UpdateSubscribedQuality(nodeID string, trackID livekit.TrackID, maxQuality livekit.VideoQuality) error { - track := l.UptrackManager.GetPublishedTrack(trackID) - if track == nil { - l.params.Logger.Warnw("could not find track", nil, "trackID", trackID) - return errors.New("could not find track") - } - - if mt, ok := track.(*MediaTrack); ok { - mt.NotifySubscriberNodeMaxQuality(nodeID, maxQuality) - } - - return nil -} - -func (l *LocalParticipant) UpdateMediaLoss(nodeID string, trackID livekit.TrackID, fractionalLoss uint32) error { - track := l.UptrackManager.GetPublishedTrack(trackID) - if track == nil { - l.params.Logger.Warnw("could not find track", nil, "trackID", trackID) - return errors.New("could not find track") - } - - if mt, ok := track.(*MediaTrack); ok { - mt.NotifySubscriberNodeMediaLoss(nodeID, uint8(fractionalLoss)) - } - - return nil -} - -func (l *LocalParticipant) HasPendingMigratedTrack() bool { - l.pendingTracksLock.RLock() - defer l.pendingTracksLock.RUnlock() - - for _, t := range l.pendingTracks { - if t.migrated { - return true - } - } - - return false -} - -func (l *LocalParticipant) DebugInfo() map[string]interface{} { - info := map[string]interface{}{} - pendingTrackInfo := make(map[string]interface{}) - - l.pendingTracksLock.RLock() - for clientID, ti := range l.pendingTracks { - pendingTrackInfo[clientID] = map[string]interface{}{ - "Sid": ti.Sid, - "Type": ti.Type.String(), - "Simulcast": ti.Simulcast, - } - } - l.pendingTracksLock.RUnlock() - - info["PendingTracks"] = pendingTrackInfo - info["UptrackManager"] = l.UptrackManager.DebugInfo() - - return info -} - -func (l *LocalParticipant) setupUptrackManager() { - l.UptrackManager = NewUptrackManager(UptrackManagerParams{ - SID: l.params.SID, - Logger: l.params.Logger, - }) - - l.UptrackManager.OnUptrackManagerClose(l.onUptrackManagerClose) -} - -func (l *LocalParticipant) onUptrackManagerClose() { - close(l.rtcpCh) -} - -func (l *LocalParticipant) getPendingTrack(clientId string, kind livekit.TrackType) (string, *livekit.TrackInfo) { - signalCid := clientId - trackInfo := l.pendingTracks[clientId] - - if trackInfo == nil { - // - // If no match on client id, find first one matching type - // as MediaStreamTrack can change client id when transceiver - // is added to peer connection. - // - for cid, ti := range l.pendingTracks { - if ti.Type == kind { - trackInfo = ti - signalCid = cid - break - } - } - } - - // if still not found, we are done - if trackInfo == nil { - l.params.Logger.Errorw("track info not published prior to track", nil, "clientId", clientId) - } - return signalCid, trackInfo.TrackInfo -} - -func (l *LocalParticipant) rtcpSendWorker() { - defer Recover() - - // read from rtcpChan - for pkts := range l.rtcpCh { - if pkts == nil { - return - } - - fwdPkts := make([]rtcp.Packet, 0, len(pkts)) - for _, pkt := range pkts { - switch pkt.(type) { - case *rtcp.PictureLossIndication: - mediaSSRC := pkt.(*rtcp.PictureLossIndication).MediaSSRC - if l.pliThrottle.canSend(mediaSSRC) { - fwdPkts = append(fwdPkts, pkt) - } - case *rtcp.FullIntraRequest: - mediaSSRC := pkt.(*rtcp.FullIntraRequest).MediaSSRC - if l.pliThrottle.canSend(mediaSSRC) { - fwdPkts = append(fwdPkts, pkt) - } - default: - fwdPkts = append(fwdPkts, pkt) - } - } - - if len(fwdPkts) > 0 && l.onWriteRTCP != nil { - l.onWriteRTCP(fwdPkts) - } - } -} diff --git a/pkg/rtc/mediatrackreceiver.go b/pkg/rtc/mediatrackreceiver.go index 20ab07033..0a75d6942 100644 --- a/pkg/rtc/mediatrackreceiver.go +++ b/pkg/rtc/mediatrackreceiver.go @@ -162,7 +162,7 @@ func (t *MediaTrackReceiver) AddOnClose(f func()) { } // AddSubscriber subscribes sub to current mediaTrack -func (t *MediaTrackReceiver) AddSubscriber(sub types.Participant) error { +func (t *MediaTrackReceiver) AddSubscriber(sub types.LocalParticipant) error { t.lock.Lock() defer t.lock.Unlock() diff --git a/pkg/rtc/mediatracksubscriptions.go b/pkg/rtc/mediatracksubscriptions.go index 4c8fef3c7..40e2cfacd 100644 --- a/pkg/rtc/mediatracksubscriptions.go +++ b/pkg/rtc/mediatracksubscriptions.go @@ -92,7 +92,7 @@ func (t *MediaTrackSubscriptions) IsSubscriber(subID livekit.ParticipantID) bool } // AddSubscriber subscribes sub to current mediaTrack -func (t *MediaTrackSubscriptions) AddSubscriber(sub types.Participant, codec webrtc.RTPCodecCapability, wr WrappedReceiver) (*sfu.DownTrack, error) { +func (t *MediaTrackSubscriptions) AddSubscriber(sub types.LocalParticipant, codec webrtc.RTPCodecCapability, wr WrappedReceiver) (*sfu.DownTrack, error) { subscriberID := sub.ID() t.subscribedTracksMu.Lock() @@ -324,7 +324,7 @@ func (t *MediaTrackSubscriptions) getSubscribedTrack(subscriberID livekit.Partic // TODO: send for all downtracks from the source participant // https://tools.ietf.org/html/rfc7941 -func (t *MediaTrackSubscriptions) sendDownTrackBindingReports(sub types.Participant) { +func (t *MediaTrackSubscriptions) sendDownTrackBindingReports(sub types.LocalParticipant) { var sd []rtcp.SourceDescriptionChunk subTrack := t.getSubscribedTrack(sub.ID()) diff --git a/pkg/rtc/nooplocalmediatrack.go b/pkg/rtc/nooplocalmediatrack.go deleted file mode 100644 index 64a3241be..000000000 --- a/pkg/rtc/nooplocalmediatrack.go +++ /dev/null @@ -1,7 +0,0 @@ -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 deleted file mode 100644 index 90bcef27c..000000000 --- a/pkg/rtc/nooplocalparticipant.go +++ /dev/null @@ -1,190 +0,0 @@ -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 deleted file mode 100644 index f5d82161e..000000000 --- a/pkg/rtc/nooplocalpublishedtrack.go +++ /dev/null @@ -1,20 +0,0 @@ -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 08e7631be..e3dde90aa 100644 --- a/pkg/rtc/participant.go +++ b/pkg/rtc/participant.go @@ -9,6 +9,7 @@ import ( "time" "github.com/livekit/livekit-server/pkg/sfu/connectionquality" + "github.com/livekit/livekit-server/pkg/sfu/twcc" lru "github.com/hashicorp/golang-lru" "github.com/livekit/protocol/livekit" @@ -34,6 +35,11 @@ const ( sdBatchSize = 20 ) +type pendingTrackInfo struct { + *livekit.TrackInfo + migrated bool +} + type ParticipantParams struct { Identity livekit.ParticipantIdentity Name livekit.ParticipantName @@ -73,7 +79,17 @@ type ParticipantImpl struct { // JSON encoded metadata to pass to clients metadata string - *LocalParticipant + rtcpCh chan []rtcp.Packet + pliThrottle *pliThrottle + + // hold reference for MediaTrack + twcc *twcc.Responder + + // client intended to publish, yet to be reconciled + pendingTracksLock sync.RWMutex + pendingTracks map[string]*pendingTrackInfo + + *UptrackManager // tracks the current participant is subscribed to, map of sid => DownTrack subscribedTracks map[livekit.TrackID]types.SubscribedTrack @@ -87,15 +103,15 @@ type ParticipantImpl struct { updateLock sync.Mutex // callbacks & handlers - onTrackPublished func(types.Participant, types.PublishedTrack) - onTrackUpdated func(types.Participant, types.PublishedTrack) - onStateChange func(p types.Participant, oldState livekit.ParticipantInfo_State) - onMetadataUpdate func(types.Participant) - onDataPacket func(types.Participant, *livekit.DataPacket) + onTrackPublished func(types.LocalParticipant, types.MediaTrack) + onTrackUpdated func(types.LocalParticipant, types.MediaTrack) + onStateChange func(p types.LocalParticipant, oldState livekit.ParticipantInfo_State) + onMetadataUpdate func(types.LocalParticipant) + onDataPacket func(types.LocalParticipant, *livekit.DataPacket) migrateState atomic.Value // types.MigrateState pendingOffer *webrtc.SessionDescription - onClose func(types.Participant, map[livekit.TrackID]livekit.ParticipantID) + onClose func(types.LocalParticipant, map[livekit.TrackID]livekit.ParticipantID) } func NewParticipant(params ParticipantParams) (*ParticipantImpl, error) { @@ -103,6 +119,9 @@ func NewParticipant(params ParticipantParams) (*ParticipantImpl, error) { p := &ParticipantImpl{ params: params, + rtcpCh: make(chan []rtcp.Packet, 50), + pliThrottle: newPLIThrottle(params.ThrottleConfig), + pendingTracks: make(map[string]*pendingTrackInfo), subscribedTracks: make(map[livekit.TrackID]types.SubscribedTrack), disallowedSubscriptions: make(map[livekit.TrackID]livekit.ParticipantID), connectedAt: time.Now(), @@ -185,7 +204,7 @@ func NewParticipant(params ParticipantParams) (*ParticipantImpl, error) { p.subscriber.OnStreamStateChange(p.onStreamStateChange) - p.setupLocalParticipant() + p.setupUptrackManager() return p, nil } @@ -239,7 +258,7 @@ func (p *ParticipantImpl) ToProto() *livekit.ParticipantInfo { Hidden: p.Hidden(), Recorder: p.IsRecorder(), } - info.Tracks = p.LocalParticipant.ToProto() + info.Tracks = p.UptrackManager.ToProto() return info } @@ -258,27 +277,27 @@ func (p *ParticipantImpl) SubscriberMediaEngine() *webrtc.MediaEngine { // callbacks for clients -func (p *ParticipantImpl) OnTrackPublished(callback func(types.Participant, types.PublishedTrack)) { +func (p *ParticipantImpl) OnTrackPublished(callback func(types.LocalParticipant, types.MediaTrack)) { p.onTrackPublished = callback } -func (p *ParticipantImpl) OnStateChange(callback func(p types.Participant, oldState livekit.ParticipantInfo_State)) { +func (p *ParticipantImpl) OnStateChange(callback func(p types.LocalParticipant, oldState livekit.ParticipantInfo_State)) { p.onStateChange = callback } -func (p *ParticipantImpl) OnTrackUpdated(callback func(types.Participant, types.PublishedTrack)) { +func (p *ParticipantImpl) OnTrackUpdated(callback func(types.LocalParticipant, types.MediaTrack)) { p.onTrackUpdated = callback } -func (p *ParticipantImpl) OnMetadataUpdate(callback func(types.Participant)) { +func (p *ParticipantImpl) OnMetadataUpdate(callback func(types.LocalParticipant)) { p.onMetadataUpdate = callback } -func (p *ParticipantImpl) OnDataPacket(callback func(types.Participant, *livekit.DataPacket)) { +func (p *ParticipantImpl) OnDataPacket(callback func(types.LocalParticipant, *livekit.DataPacket)) { p.onDataPacket = callback } -func (p *ParticipantImpl) OnClose(callback func(types.Participant, map[livekit.TrackID]livekit.ParticipantID)) { +func (p *ParticipantImpl) OnClose(callback func(types.LocalParticipant, map[livekit.TrackID]livekit.ParticipantID)) { p.onClose = callback } @@ -336,10 +355,6 @@ func (p *ParticipantImpl) HandleOffer(sdp webrtc.SessionDescription) (answer web return } -func (p *ParticipantImpl) AddMigratedTrack(cid string, ti *livekit.TrackInfo) { - p.LocalParticipant.AddMigratedTrack(cid, ti) -} - // AddTrack is called when client intends to publish track. // records track details and lets client know it's ok to proceed func (p *ParticipantImpl) AddTrack(req *livekit.AddTrackRequest) { @@ -351,7 +366,7 @@ func (p *ParticipantImpl) AddTrack(req *livekit.AddTrackRequest) { return } - ti := p.LocalParticipant.AddTrack(req) + ti := p.addPendingTrack(req) if ti == nil { return } @@ -366,6 +381,13 @@ func (p *ParticipantImpl) AddTrack(req *livekit.AddTrackRequest) { }) } +func (p *ParticipantImpl) AddMigratedTrack(cid string, ti *livekit.TrackInfo) { + p.pendingTracksLock.Lock() + defer p.pendingTracksLock.Unlock() + + p.pendingTracks[cid] = &pendingTrackInfo{ti, true} +} + // HandleAnswer handles a client answer response, with subscriber PC, server initiates the // offer and client answers func (p *ParticipantImpl) HandleAnswer(sdp webrtc.SessionDescription) error { @@ -394,7 +416,8 @@ func (p *ParticipantImpl) AddICECandidate(candidate webrtc.ICECandidateInit, tar func (p *ParticipantImpl) Start() { p.once.Do(func() { - p.LocalParticipant.Start() + p.UptrackManager.Start() + go p.rtcpSendWorker() go p.downTracksRTCPWorker() }) } @@ -414,7 +437,11 @@ func (p *ParticipantImpl) Close(sendLeave bool) error { }) } - p.LocalParticipant.Close() + p.UptrackManager.Close() + + p.pendingTracksLock.Lock() + p.pendingTracks = make(map[string]*pendingTrackInfo) + p.pendingTracksLock.Unlock() p.lock.Lock() disallowedSubscriptions := make(map[livekit.TrackID]livekit.ParticipantID) @@ -469,7 +496,7 @@ func (p *ParticipantImpl) SetMigrateState(s types.MigrateState) { var pendingOffer *webrtc.SessionDescription p.migrateState.Store(s) if s == types.MigrateStateSync { - if !p.LocalParticipant.HasPendingMigratedTrack() { + if !p.hasPendingMigratedTrack() { p.migrateState.Store(types.MigrateStateComplete) } pendingOffer = p.pendingOffer @@ -634,12 +661,26 @@ func (p *ParticipantImpl) SetTrackMuted(trackID livekit.TrackID, muted bool, fro }) } - p.LocalParticipant.SetTrackMuted(trackID, muted) + p.setTrackMuted(trackID, muted) +} + +func (p *ParticipantImpl) GetAudioLevel() (level uint8, active bool) { + level = SilentAudioLevel + for _, pt := range p.GetPublishedTracks() { + tl, ta := pt.(types.LocalMediaTrack).GetAudioLevel() + if ta { + active = true + if tl < level { + level = tl + } + } + } + return } func (p *ParticipantImpl) GetConnectionQuality() *livekit.ConnectionQualityInfo { // avg loss across all tracks, weigh published the same as subscribed - scores, numTracks := p.LocalParticipant.GetConnectionQuality() + scores, numTracks := p.getPublisherConnectionQuality() p.lock.RLock() for _, subTrack := range p.subscribedTracks { @@ -665,11 +706,6 @@ func (p *ParticipantImpl) GetConnectionQuality() *livekit.ConnectionQualityInfo } } -func (p *ParticipantImpl) isSubscribedTo(participantID livekit.ParticipantID) bool { - _, ok := p.subscribedTo.Load(participantID) - return ok -} - func (p *ParticipantImpl) GetSubscribedParticipants() []livekit.ParticipantID { var participantIDs []livekit.ParticipantID p.subscribedTo.Range(func(key, _ interface{}) bool { @@ -810,29 +846,41 @@ func (p *ParticipantImpl) SubscriptionPermissionUpdate(publisherID livekit.Parti } } -func (p *ParticipantImpl) setupLocalParticipant() { - p.LocalParticipant = NewLocalParticipant(LocalParticipantParams{ - Identity: p.params.Identity, - SID: p.params.SID, - Config: p.params.Config, - AudioConfig: p.params.AudioConfig, - Telemetry: p.params.Telemetry, - ThrottleConfig: p.params.ThrottleConfig, - Logger: p.params.Logger, - SimTracks: p.params.SimTracks, +func (p *ParticipantImpl) UpdateSubscribedQuality(nodeID string, trackID livekit.TrackID, maxQuality livekit.VideoQuality) error { + track := p.GetPublishedTrack(trackID) + if track == nil { + p.params.Logger.Warnw("could not find track", nil, "trackID", trackID) + return errors.New("could not find track") + } + + if mt, ok := track.(*MediaTrack); ok { + mt.NotifySubscriberNodeMaxQuality(nodeID, maxQuality) + } + + return nil +} + +func (p *ParticipantImpl) UpdateMediaLoss(nodeID string, trackID livekit.TrackID, fractionalLoss uint32) error { + track := p.GetPublishedTrack(trackID) + if track == nil { + p.params.Logger.Warnw("could not find track", nil, "trackID", trackID) + return errors.New("could not find track") + } + + if mt, ok := track.(*MediaTrack); ok { + mt.NotifySubscriberNodeMediaLoss(nodeID, uint8(fractionalLoss)) + } + + return nil +} + +func (p *ParticipantImpl) setupUptrackManager() { + p.UptrackManager = NewUptrackManager(UptrackManagerParams{ + SID: p.params.SID, + Logger: p.params.Logger, }) - p.LocalParticipant.OnTrackPublished(func(track types.PublishedTrack) { - if !p.LocalParticipant.HasPendingMigratedTrack() { - p.SetMigrateState(types.MigrateStateComplete) - } - - if p.onTrackPublished != nil { - p.onTrackPublished(p, track) - } - }) - - p.LocalParticipant.OnPublishedTrackUpdated(func(track types.PublishedTrack, onlyIfReady bool) { + p.UptrackManager.OnPublishedTrackUpdated(func(track types.MediaTrack, onlyIfReady bool) { if onlyIfReady && !p.IsReady() { return } @@ -842,13 +890,9 @@ func (p *ParticipantImpl) setupLocalParticipant() { } }) - p.LocalParticipant.OnWriteRTCP(func(pkts []rtcp.Packet) { - if err := p.publisher.pc.WriteRTCP(pkts); err != nil { - p.params.Logger.Errorw("could not write RTCP to participant", err) - } - }) + p.UptrackManager.OnSubscribedMaxQualityChange(p.onSubscribedMaxQualityChange) - p.LocalParticipant.OnSubscribedMaxQualityChange(p.onSubscribedMaxQualityChange) + p.UptrackManager.OnUptrackManagerClose(p.onUptrackManagerClose) } func (p *ParticipantImpl) sendIceCandidate(c *webrtc.ICECandidate, target livekit.SignalTarget) { @@ -939,15 +983,7 @@ func (p *ParticipantImpl) onMediaTrack(track *webrtc.TrackRemote, rtpReceiver *w return } - var mid string - for _, tr := range p.publisher.pc.GetTransceivers() { - if tr.Receiver() == rtpReceiver { - mid = tr.Mid() - break - } - } - - publishedTrack, isNewTrack := p.LocalParticipant.MediaTrackReceived(track, rtpReceiver, mid) + publishedTrack, isNewTrack := p.mediaTrackReceived(track, rtpReceiver) if !isNewTrack && publishedTrack != nil && p.IsReady() && p.onTrackUpdated != nil { p.onTrackUpdated(p, publishedTrack) } @@ -1108,7 +1144,7 @@ func (p *ParticipantImpl) configureReceiverDTX() { // multiple audio tracks. At that point, there might be a need to // rely on something like order of tracks. TODO // - enableDTX := p.LocalParticipant.GetDTX() + enableDTX := p.getDTX() transceivers := p.publisher.pc.GetTransceivers() for _, transceiver := range transceivers { if transceiver.Kind() != webrtc.RTPCodecTypeAudio { @@ -1156,6 +1192,11 @@ func (p *ParticipantImpl) configureReceiverDTX() { } } +func (p *ParticipantImpl) isSubscribedTo(participantID livekit.ParticipantID) bool { + _, ok := p.subscribedTo.Load(participantID) + return ok +} + func (p *ParticipantImpl) onStreamStateChange(update *sfu.StreamStateUpdate) error { if len(update.StreamStates) == 0 { return nil @@ -1198,13 +1239,295 @@ func (p *ParticipantImpl) onSubscribedMaxQualityChange(trackID livekit.TrackID, }) } +func (p *ParticipantImpl) addPendingTrack(req *livekit.AddTrackRequest) *livekit.TrackInfo { + if p.getPublishedTrackBySignalCid(req.Cid) != nil || p.getPublishedTrackBySdpCid(req.Cid) != nil { + return nil + } + + p.pendingTracksLock.Lock() + defer p.pendingTracksLock.Unlock() + + // if track is already published, reject + if p.pendingTracks[req.Cid] != nil { + return nil + } + + ti := &livekit.TrackInfo{ + Type: req.Type, + Name: req.Name, + Sid: utils.NewGuid(utils.TrackPrefix), + Width: req.Width, + Height: req.Height, + Muted: req.Muted, + DisableDtx: req.DisableDtx, + Source: req.Source, + Layers: req.Layers, + } + p.pendingTracks[req.Cid] = &pendingTrackInfo{TrackInfo: ti} + + return ti +} + +func (p *ParticipantImpl) setTrackMuted(trackID livekit.TrackID, muted bool) { + track := p.UptrackManager.SetPublishedTrackMuted(trackID, muted) + if track != nil { + // handled in UptrackManager for a published track, no need to update state of pending track + return + } + + isPending := false + p.pendingTracksLock.RLock() + for _, ti := range p.pendingTracks { + if livekit.TrackID(ti.Sid) == trackID { + ti.Muted = muted + isPending = true + break + } + } + p.pendingTracksLock.RUnlock() + + if !isPending { + p.params.Logger.Warnw("could not locate track", nil, "track", trackID) + } +} + +func (p *ParticipantImpl) getPublisherConnectionQuality() (scores float64, numTracks int) { + for _, pt := range p.GetPublishedTracks() { + if pt.IsMuted() { + continue + } + scores += pt.(types.LocalMediaTrack).GetConnectionScore() + numTracks++ + } + + return +} + +func (p *ParticipantImpl) getDTX() bool { + p.pendingTracksLock.RLock() + defer p.pendingTracksLock.RUnlock() + + // + // Although DTX is set per track, there are cases where + // pending track has to be looked up by kind. This happens + // when clients change track id between signalling and SDP. + // In that case, look at all pending tracks by kind and + // enable DTX even if one has it enabled. + // + // Most of the time in practice, there is going to be one + // audio kind track and hence this is fine. + // + for _, ti := range p.pendingTracks { + if ti.Type == livekit.TrackType_AUDIO { + if !ti.TrackInfo.DisableDtx { + return true + } + } + } + + return false +} + +func (p *ParticipantImpl) mediaTrackReceived(track *webrtc.TrackRemote, rtpReceiver *webrtc.RTPReceiver) (types.MediaTrack, bool) { + p.pendingTracksLock.Lock() + newTrack := false + + // use existing mediatrack to handle simulcast + mt, ok := p.getPublishedTrackBySdpCid(track.ID()).(*MediaTrack) + if !ok { + signalCid, ti := p.getPendingTrack(track.ID(), ToProtoTrackKind(track.Kind())) + if ti == nil { + p.pendingTracksLock.Unlock() + return nil, false + } + + ti.MimeType = track.Codec().MimeType + + var mid string + for _, tr := range p.publisher.pc.GetTransceivers() { + if tr.Receiver() == rtpReceiver { + mid = tr.Mid() + break + } + } + ti.Mid = mid + + mt = NewMediaTrack(track, MediaTrackParams{ + TrackInfo: ti, + SignalCid: signalCid, + SdpCid: track.ID(), + ParticipantID: p.params.SID, + ParticipantIdentity: p.params.Identity, + RTCPChan: p.rtcpCh, + BufferFactory: p.params.Config.BufferFactory, + ReceiverConfig: p.params.Config.Receiver, + AudioConfig: p.params.AudioConfig, + Telemetry: p.params.Telemetry, + Logger: p.params.Logger, + SubscriberConfig: p.params.Config.Subscriber, + }) + + for ssrc, info := range p.params.SimTracks { + if info.Mid == mid { + mt.TrySetSimulcastSSRC(uint8(sfu.RidToLayer(info.Rid)), ssrc) + } + } + + // add to published and clean up pending + p.UptrackManager.AddPublishedTrack(mt) + delete(p.pendingTracks, signalCid) + + newTrack = true + } + + ssrc := uint32(track.SSRC()) + p.pliThrottle.addTrack(ssrc, track.RID()) + if p.twcc == nil { + p.twcc = twcc.NewTransportWideCCResponder(ssrc) + p.twcc.OnFeedback(func(pkt rtcp.RawPacket) { + if err := p.publisher.pc.WriteRTCP([]rtcp.Packet{&pkt}); err != nil { + p.params.Logger.Errorw("could not write RTCP to participant", err) + } + }) + } + p.pendingTracksLock.Unlock() + + mt.AddReceiver(rtpReceiver, track, p.twcc) + + if newTrack { + p.handleTrackPublished(mt) + } + + return mt, newTrack +} + +func (p *ParticipantImpl) handleTrackPublished(track types.MediaTrack) { + if !p.hasPendingMigratedTrack() { + p.SetMigrateState(types.MigrateStateComplete) + } + + if p.onTrackPublished != nil { + p.onTrackPublished(p, track) + } +} + +func (p *ParticipantImpl) hasPendingMigratedTrack() bool { + p.pendingTracksLock.RLock() + defer p.pendingTracksLock.RUnlock() + + for _, t := range p.pendingTracks { + if t.migrated { + return true + } + } + + return false +} + +func (p *ParticipantImpl) onUptrackManagerClose() { + close(p.rtcpCh) +} + +func (p *ParticipantImpl) getPendingTrack(clientId string, kind livekit.TrackType) (string, *livekit.TrackInfo) { + signalCid := clientId + trackInfo := p.pendingTracks[clientId] + + if trackInfo == nil { + // + // If no match on client id, find first one matching type + // as MediaStreamTrack can change client id when transceiver + // is added to peer connection. + // + for cid, ti := range p.pendingTracks { + if ti.Type == kind { + trackInfo = ti + signalCid = cid + break + } + } + } + + // if still not found, we are done + if trackInfo == nil { + p.params.Logger.Errorw("track info not published prior to track", nil, "clientId", clientId) + } + return signalCid, trackInfo.TrackInfo +} + +func (p *ParticipantImpl) getPublishedTrackBySignalCid(clientId string) types.MediaTrack { + for _, publishedTrack := range p.GetPublishedTracks() { + if publishedTrack.(types.LocalMediaTrack).SignalCid() == clientId { + return publishedTrack + } + } + + return nil +} + +func (p *ParticipantImpl) getPublishedTrackBySdpCid(clientId string) types.MediaTrack { + for _, publishedTrack := range p.GetPublishedTracks() { + if publishedTrack.(types.LocalMediaTrack).SdpCid() == clientId { + return publishedTrack + } + } + + return nil +} + +func (p *ParticipantImpl) rtcpSendWorker() { + defer Recover() + + // read from rtcpChan + for pkts := range p.rtcpCh { + if pkts == nil { + return + } + + fwdPkts := make([]rtcp.Packet, 0, len(pkts)) + for _, pkt := range pkts { + switch pkt.(type) { + case *rtcp.PictureLossIndication: + mediaSSRC := pkt.(*rtcp.PictureLossIndication).MediaSSRC + if p.pliThrottle.canSend(mediaSSRC) { + fwdPkts = append(fwdPkts, pkt) + } + case *rtcp.FullIntraRequest: + mediaSSRC := pkt.(*rtcp.FullIntraRequest).MediaSSRC + if p.pliThrottle.canSend(mediaSSRC) { + fwdPkts = append(fwdPkts, pkt) + } + default: + fwdPkts = append(fwdPkts, pkt) + } + } + + if len(fwdPkts) > 0 { + if err := p.publisher.pc.WriteRTCP(fwdPkts); err != nil { + p.params.Logger.Errorw("could not write RTCP to participant", err) + } + } + } +} + func (p *ParticipantImpl) DebugInfo() map[string]interface{} { info := map[string]interface{}{ "ID": p.params.SID, "State": p.State().String(), } - localParticipantInfo := p.LocalParticipant.DebugInfo() + pendingTrackInfo := make(map[string]interface{}) + p.pendingTracksLock.RLock() + for clientID, ti := range p.pendingTracks { + pendingTrackInfo[clientID] = map[string]interface{}{ + "Sid": ti.Sid, + "Type": ti.Type.String(), + "Simulcast": ti.Simulcast, + } + } + p.pendingTracksLock.RUnlock() + info["PendingTracks"] = pendingTrackInfo + + info["UptrackManager"] = p.UptrackManager.DebugInfo() subscribedTrackInfo := make(map[livekit.TrackID]interface{}) p.lock.RLock() @@ -1214,8 +1537,6 @@ func (p *ParticipantImpl) DebugInfo() map[string]interface{} { subscribedTrackInfo[track.ID()] = dt } p.lock.RUnlock() - - info["LocalParticipant"] = localParticipantInfo info["SubscribedTracks"] = subscribedTrackInfo return info diff --git a/pkg/rtc/participant_internal_test.go b/pkg/rtc/participant_internal_test.go index 126213992..1fe5144bc 100644 --- a/pkg/rtc/participant_internal_test.go +++ b/pkg/rtc/participant_internal_test.go @@ -52,7 +52,7 @@ func TestICEStateChange(t *testing.T) { t.Run("onClose gets called when ICE disconnected", func(t *testing.T) { p := newParticipantForTest("test") closeChan := make(chan struct{}) - p.onClose = func(participant types.Participant, disallowedSubscriptions map[livekit.TrackID]livekit.ParticipantID) { + p.onClose = func(participant types.LocalParticipant, disallowedSubscriptions map[livekit.TrackID]livekit.ParticipantID) { close(closeChan) } p.handlePrimaryStateChange(webrtc.PeerConnectionStateFailed) @@ -70,18 +70,18 @@ func TestTrackPublishing(t *testing.T) { t.Run("should send the correct events", func(t *testing.T) { p := newParticipantForTest("test") p.state.Store(livekit.ParticipantInfo_ACTIVE) - track := &typesfakes.FakePublishedTrack{} + track := &typesfakes.FakeMediaTrack{} track.IDReturns("id") published := false updated := false - p.OnTrackUpdated(func(p types.Participant, track types.PublishedTrack) { + p.OnTrackUpdated(func(p types.LocalParticipant, track types.MediaTrack) { updated = true }) - p.OnTrackPublished(func(p types.Participant, track types.PublishedTrack) { + p.OnTrackPublished(func(p types.LocalParticipant, track types.MediaTrack) { published = true }) - p.LocalParticipant.AddPublishedTrack(track) - p.LocalParticipant.handleTrackPublished(track) + p.UptrackManager.AddPublishedTrack(track) + p.handleTrackPublished(track) require.True(t, published) require.False(t, updated) @@ -134,7 +134,7 @@ func TestTrackPublishing(t *testing.T) { p := newParticipantForTest("test") sink := p.params.Sink.(*routingfakes.FakeMessageSink) - track := &typesfakes.FakePublishedTrack{} + track := &typesfakes.FakeLocalMediaTrack{} track.SignalCidReturns("cid") // directly add to publishedTracks without lock - for testing purpose only p.UptrackManager.publishedTracks["cid"] = track @@ -151,7 +151,7 @@ func TestTrackPublishing(t *testing.T) { p := newParticipantForTest("test") sink := p.params.Sink.(*routingfakes.FakeMessageSink) - track := &typesfakes.FakePublishedTrack{} + track := &typesfakes.FakeLocalMediaTrack{} track.SdpCidReturns("cid") // directly add to publishedTracks without lock - for testing purpose only p.UptrackManager.publishedTracks["cid"] = track @@ -202,9 +202,9 @@ func TestDisconnectTiming(t *testing.T) { t.Log("received message from chan", msg) } }() - track := &typesfakes.FakePublishedTrack{} - p.LocalParticipant.AddPublishedTrack(track) - p.LocalParticipant.handleTrackPublished(track) + track := &typesfakes.FakeMediaTrack{} + p.UptrackManager.AddPublishedTrack(track) + p.handleTrackPublished(track) // close channel and then try to Negotiate msg.Close() @@ -222,7 +222,7 @@ func TestMuteSetting(t *testing.T) { t.Run("can set mute when track is pending", func(t *testing.T) { p := newParticipantForTest("test") ti := &livekit.TrackInfo{Sid: "testTrack"} - p.LocalParticipant.pendingTracks["cid"] = &pendingTrackInfo{TrackInfo: ti} + p.pendingTracks["cid"] = &pendingTrackInfo{TrackInfo: ti} p.SetTrackMuted(livekit.TrackID(ti.Sid), true, false) require.True(t, ti.Muted) @@ -236,7 +236,7 @@ func TestMuteSetting(t *testing.T) { Muted: true, }) - _, ti := p.LocalParticipant.getPendingTrack("cid", livekit.TrackType_AUDIO) + _, ti := p.getPendingTrack("cid", livekit.TrackType_AUDIO) require.NotNil(t, ti) require.True(t, ti.Muted) }) @@ -253,16 +253,16 @@ func TestConnectionQuality(t *testing.T) { return connectionquality.Loss2Score(loss, reducedQuality) } - testPublishedVideoTrack := func(loss, numPublishing, numRegistered uint32) *typesfakes.FakePublishedTrack { - tr := &typesfakes.FakePublishedTrack{} + testPublishedVideoTrack := func(loss, numPublishing, numRegistered uint32) *typesfakes.FakeLocalMediaTrack { + tr := &typesfakes.FakeLocalMediaTrack{} score := videoScore(loss, numPublishing, numRegistered) t.Log("video score: ", score) tr.GetConnectionScoreReturns(score) return tr } - testPublishedAudioTrack := func(totalPackets, packetsLost uint32) *typesfakes.FakePublishedTrack { - tr := &typesfakes.FakePublishedTrack{} + testPublishedAudioTrack := func(totalPackets, packetsLost uint32) *typesfakes.FakeLocalMediaTrack { + tr := &typesfakes.FakeLocalMediaTrack{} stat := &connectionquality.ConnectionStat{ PacketsLost: packetsLost, diff --git a/pkg/rtc/room.go b/pkg/rtc/room.go index 194755b78..6890d923a 100644 --- a/pkg/rtc/room.go +++ b/pkg/rtc/room.go @@ -37,7 +37,7 @@ type Room struct { telemetry telemetry.TelemetryService // map of identity -> Participant - participants map[livekit.ParticipantIdentity]types.Participant + participants map[livekit.ParticipantIdentity]types.LocalParticipant participantOpts map[livekit.ParticipantIdentity]*ParticipantOptions bufferFactory *buffer.Factory @@ -48,7 +48,7 @@ type Room struct { closed chan struct{} closeOnce sync.Once - onParticipantChanged func(p types.Participant) + onParticipantChanged func(p types.LocalParticipant) onMetadataUpdate func(metadata string) onClose func() } @@ -64,7 +64,7 @@ func NewRoom(room *livekit.Room, config WebRTCConfig, audioConfig *config.AudioC config: config, audioConfig: audioConfig, telemetry: telemetry, - participants: make(map[livekit.ParticipantIdentity]types.Participant), + participants: make(map[livekit.ParticipantIdentity]types.LocalParticipant), participantOpts: make(map[livekit.ParticipantIdentity]*ParticipantOptions), bufferFactory: buffer.NewBufferFactory(config.Receiver.PacketBufferSize, logr.Logger{}), closed: make(chan struct{}), @@ -86,13 +86,13 @@ func (r *Room) Name() livekit.RoomName { return livekit.RoomName(r.Room.Name) } -func (r *Room) GetParticipant(identity livekit.ParticipantIdentity) types.Participant { +func (r *Room) GetParticipant(identity livekit.ParticipantIdentity) types.LocalParticipant { r.lock.RLock() defer r.lock.RUnlock() return r.participants[identity] } -func (r *Room) GetParticipantBySid(participantID livekit.ParticipantID) types.Participant { +func (r *Room) GetParticipantBySid(participantID livekit.ParticipantID) types.LocalParticipant { r.lock.RLock() defer r.lock.RUnlock() @@ -105,10 +105,10 @@ func (r *Room) GetParticipantBySid(participantID livekit.ParticipantID) types.Pa return nil } -func (r *Room) GetParticipants() []types.Participant { +func (r *Room) GetParticipants() []types.LocalParticipant { r.lock.RLock() defer r.lock.RUnlock() - participants := make([]types.Participant, 0, len(r.participants)) + participants := make([]types.LocalParticipant, 0, len(r.participants)) for _, p := range r.participants { participants = append(participants, p) } @@ -156,7 +156,7 @@ func (r *Room) LastLeftAt() int64 { return 0 } -func (r *Room) Join(participant types.Participant, opts *ParticipantOptions, iceServers []*livekit.ICEServer) error { +func (r *Room) Join(participant types.LocalParticipant, opts *ParticipantOptions, iceServers []*livekit.ICEServer) error { if r.IsClosed() { prometheus.ServiceOperationCounter.WithLabelValues("participant_join", "error", "room_closed").Add(1) return ErrRoomClosed @@ -184,7 +184,7 @@ func (r *Room) Join(participant types.Participant, opts *ParticipantOptions, ice // it's important to set this before connection, we don't want to miss out on any publishedTracks participant.OnTrackPublished(r.onTrackPublished) - participant.OnStateChange(func(p types.Participant, oldState livekit.ParticipantInfo_State) { + participant.OnStateChange(func(p types.LocalParticipant, oldState livekit.ParticipantInfo_State) { r.Logger.Debugw("participant state changed", "state", p.State(), "participant", p.Identity(), @@ -262,7 +262,7 @@ func (r *Room) Join(participant types.Participant, opts *ParticipantOptions, ice return nil } -func (r *Room) ResumeParticipant(p types.Participant, responseSink routing.MessageSink) error { +func (r *Room) ResumeParticipant(p types.LocalParticipant, responseSink routing.MessageSink) error { // close previous sink, and link to new one if prevSink := p.GetResponseSink(); prevSink != nil { prevSink.Close() @@ -338,7 +338,7 @@ func (r *Room) RemoveParticipant(identity livekit.ParticipantIdentity) { } func (r *Room) UpdateSubscriptions( - participant types.Participant, + participant types.LocalParticipant, trackIDs []livekit.TrackID, participantTracks []*livekit.ParticipantTracks, subscribe bool, @@ -379,7 +379,7 @@ func (r *Room) UpdateSubscriptions( return nil } -func (r *Room) SyncState(participant types.Participant, state *livekit.SyncState) error { +func (r *Room) SyncState(participant types.LocalParticipant, state *livekit.SyncState) error { return nil } @@ -387,7 +387,7 @@ func (r *Room) UpdateSubscriptionPermissions(participant types.Participant, perm return participant.UpdateSubscriptionPermissions(permissions, r.GetParticipantBySid) } -func (r *Room) RemoveDisallowedSubscriptions(sub types.Participant, disallowedSubscriptions map[livekit.TrackID]livekit.ParticipantID) { +func (r *Room) RemoveDisallowedSubscriptions(sub types.LocalParticipant, disallowedSubscriptions map[livekit.TrackID]livekit.ParticipantID) { for trackID, publisherID := range disallowedSubscriptions { pub := r.GetParticipantBySid(publisherID) if pub == nil { @@ -461,7 +461,7 @@ func (r *Room) OnClose(f func()) { r.onClose = f } -func (r *Room) OnParticipantChanged(f func(participant types.Participant)) { +func (r *Room) OnParticipantChanged(f func(participant types.LocalParticipant)) { r.onParticipantChanged = f } @@ -505,7 +505,7 @@ func (r *Room) OnMetadataUpdate(f func(metadata string)) { r.onMetadataUpdate = f } -func (r *Room) SimulateScenario(participant types.Participant, simulateScenario *livekit.SimulateScenario) error { +func (r *Room) SimulateScenario(participant types.LocalParticipant, simulateScenario *livekit.SimulateScenario) error { switch scenario := simulateScenario.Scenario.(type) { case *livekit.SimulateScenario_SpeakerUpdate: r.Logger.Infow("simulating speaker update", "participant", participant.Identity()) @@ -534,7 +534,7 @@ func (r *Room) SimulateScenario(participant types.Participant, simulateScenario } // checks if participant should be autosubscribed to new tracks, assumes lock is already acquired -func (r *Room) autoSubscribe(participant types.Participant) bool { +func (r *Room) autoSubscribe(participant types.LocalParticipant) bool { if !participant.CanSubscribe() { return false } @@ -548,14 +548,14 @@ func (r *Room) autoSubscribe(participant types.Participant) bool { } // a ParticipantImpl in the room added a new remoteTrack, subscribe other participants to it -func (r *Room) onTrackPublished(participant types.Participant, track types.PublishedTrack) { +func (r *Room) onTrackPublished(participant types.LocalParticipant, track types.MediaTrack) { // publish participant update, since track state is changed r.broadcastParticipantState(participant, true) r.lock.RLock() defer r.lock.RUnlock() - // subscribe all existing participants to this PublishedTrack + // subscribe all existing participants to this MediaTrack for _, existingParticipant := range r.participants { if existingParticipant == participant { // skip publishing participant @@ -586,7 +586,7 @@ func (r *Room) onTrackPublished(participant types.Participant, track types.Publi } } -func (r *Room) onTrackUpdated(p types.Participant, _ types.PublishedTrack) { +func (r *Room) onTrackUpdated(p types.LocalParticipant, _ types.MediaTrack) { // send track updates to everyone, especially if track was updated by admin r.broadcastParticipantState(p, false) if r.onParticipantChanged != nil { @@ -594,14 +594,14 @@ func (r *Room) onTrackUpdated(p types.Participant, _ types.PublishedTrack) { } } -func (r *Room) onParticipantMetadataUpdate(p types.Participant) { +func (r *Room) onParticipantMetadataUpdate(p types.LocalParticipant) { r.broadcastParticipantState(p, false) if r.onParticipantChanged != nil { r.onParticipantChanged(p) } } -func (r *Room) onDataPacket(source types.Participant, dp *livekit.DataPacket) { +func (r *Room) onDataPacket(source types.LocalParticipant, dp *livekit.DataPacket) { // don't forward if source isn't allowed to publish data if source != nil && !source.CanPublishData() { return @@ -631,7 +631,7 @@ func (r *Room) onDataPacket(source types.Participant, dp *livekit.DataPacket) { } } -func (r *Room) subscribeToExistingTracks(p types.Participant) { +func (r *Room) subscribeToExistingTracks(p types.LocalParticipant) { r.lock.RLock() shouldSubscribe := r.autoSubscribe(p) r.lock.RUnlock() @@ -662,14 +662,14 @@ func (r *Room) subscribeToExistingTracks(p types.Participant) { } // broadcast an update about participant p -func (r *Room) broadcastParticipantState(p types.Participant, skipSource bool) { +func (r *Room) broadcastParticipantState(p types.LocalParticipant, skipSource bool) { // // This is a critical section to ensure that participant update time and // the corresponding data are paired properly. // r.lock.Lock() updatedAt := time.Now() - updates := ToProtoParticipants([]types.Participant{p}) + updates := ToProtoParticipants([]types.LocalParticipant{p}) r.lock.Unlock() if p.Hidden() { diff --git a/pkg/rtc/room_test.go b/pkg/rtc/room_test.go index 4c8525b7a..9786bf35e 100644 --- a/pkg/rtc/room_test.go +++ b/pkg/rtc/room_test.go @@ -92,7 +92,7 @@ func TestRoomJoin(t *testing.T) { if p == op { continue } - mockP := op.(*typesfakes.FakeParticipant) + mockP := op.(*typesfakes.FakeLocalParticipant) require.NotZero(t, mockP.AddSubscriberCallCount()) // last call should be to add the newest participant sub, params := mockP.AddSubscriberArgsForCall(mockP.AddSubscriberCallCount() - 1) @@ -104,12 +104,12 @@ func TestRoomJoin(t *testing.T) { t.Run("participant state change is broadcasted to others", func(t *testing.T) { rm := newRoomWithParticipants(t, testRoomOpts{num: numParticipants}) var changedParticipant types.Participant - rm.OnParticipantChanged(func(participant types.Participant) { + rm.OnParticipantChanged(func(participant types.LocalParticipant) { changedParticipant = participant }) participants := rm.GetParticipants() - p := participants[0].(*typesfakes.FakeParticipant) - disconnectedParticipant := participants[1].(*typesfakes.FakeParticipant) + p := participants[0].(*typesfakes.FakeLocalParticipant) + disconnectedParticipant := participants[1].(*typesfakes.FakeLocalParticipant) disconnectedParticipant.StateReturns(livekit.ParticipantInfo_DISCONNECTED) rm.RemoveParticipant(p.Identity()) @@ -123,7 +123,7 @@ func TestRoomJoin(t *testing.T) { require.Zero(t, p.SendParticipantUpdateCallCount()) continue } - fakeP := op.(*typesfakes.FakeParticipant) + fakeP := op.(*typesfakes.FakeLocalParticipant) require.Equal(t, 1, fakeP.SendParticipantUpdateCallCount()) numUpdates += 1 } @@ -145,26 +145,26 @@ func TestParticipantUpdate(t *testing.T) { tests := []struct { name string sendToSender bool // should sender receive it - action func(p types.Participant) + action func(p types.LocalParticipant) }{ { "track mutes are sent to everyone", true, - func(p types.Participant) { + func(p types.LocalParticipant) { p.SetTrackMuted("", true, false) }, }, { "track metadata updates are sent to everyone", true, - func(p types.Participant) { + func(p types.LocalParticipant) { p.SetMetadata("") }, }, { "track publishes are sent to existing participants", true, - func(p types.Participant) { + func(p types.LocalParticipant) { p.AddTrack(&livekit.AddTrackRequest{ Type: livekit.TrackType_VIDEO, }) @@ -178,7 +178,7 @@ func TestParticipantUpdate(t *testing.T) { // remember how many times send has been called for each callCounts := make(map[livekit.ParticipantID]int) for _, p := range rm.GetParticipants() { - fp := p.(*typesfakes.FakeParticipant) + fp := p.(*typesfakes.FakeLocalParticipant) callCounts[p.ID()] = fp.SendParticipantUpdateCallCount() } @@ -191,7 +191,7 @@ func TestParticipantUpdate(t *testing.T) { if p != sender || test.sendToSender { expected += 1 } - fp := p.(*typesfakes.FakeParticipant) + fp := p.(*typesfakes.FakeLocalParticipant) require.Equal(t, expected, fp.SendParticipantUpdateCallCount()) } }) @@ -248,12 +248,12 @@ func TestNewTrack(t *testing.T) { t.Run("new track should be added to ready participants", func(t *testing.T) { rm := newRoomWithParticipants(t, testRoomOpts{num: 3}) participants := rm.GetParticipants() - p0 := participants[0].(*typesfakes.FakeParticipant) + p0 := participants[0].(*typesfakes.FakeLocalParticipant) p0.StateReturns(livekit.ParticipantInfo_JOINED) - p1 := participants[1].(*typesfakes.FakeParticipant) + p1 := participants[1].(*typesfakes.FakeLocalParticipant) p1.StateReturns(livekit.ParticipantInfo_ACTIVE) - pub := participants[2].(*typesfakes.FakeParticipant) + pub := participants[2].(*typesfakes.FakeLocalParticipant) // pub adds track track := newMockTrack(livekit.TrackType_VIDEO, "webcam") @@ -270,7 +270,7 @@ func TestNewTrack(t *testing.T) { func TestActiveSpeakers(t *testing.T) { t.Parallel() - getActiveSpeakerUpdates := func(p *typesfakes.FakeParticipant) []*livekit.ActiveSpeakerUpdate { + getActiveSpeakerUpdates := func(p *typesfakes.FakeLocalParticipant) []*livekit.ActiveSpeakerUpdate { var updates []*livekit.ActiveSpeakerUpdate numCalls := p.SendDataPacketCallCount() for i := 0; i < numCalls; i++ { @@ -287,7 +287,7 @@ func TestActiveSpeakers(t *testing.T) { t.Run("participant should not be getting audio updates (protocol 2)", func(t *testing.T) { rm := newRoomWithParticipants(t, testRoomOpts{num: 1, protocol: types.DefaultProtocol}) defer rm.Close() - p := rm.GetParticipants()[0].(*typesfakes.FakeParticipant) + p := rm.GetParticipants()[0].(*typesfakes.FakeLocalParticipant) require.Empty(t, rm.GetActiveSpeakers()) time.Sleep(audioUpdateDuration) @@ -300,8 +300,8 @@ func TestActiveSpeakers(t *testing.T) { rm := newRoomWithParticipants(t, testRoomOpts{num: 2}) defer rm.Close() participants := rm.GetParticipants() - p := participants[0].(*typesfakes.FakeParticipant) - p2 := participants[1].(*typesfakes.FakeParticipant) + p := participants[0].(*typesfakes.FakeLocalParticipant) + p2 := participants[1].(*typesfakes.FakeLocalParticipant) p.GetAudioLevelReturns(10, true) p2.GetAudioLevelReturns(20, true) @@ -315,7 +315,7 @@ func TestActiveSpeakers(t *testing.T) { rm := newRoomWithParticipants(t, testRoomOpts{num: 2, protocol: types.DefaultProtocol}) defer rm.Close() participants := rm.GetParticipants() - p := participants[0].(*typesfakes.FakeParticipant) + p := participants[0].(*typesfakes.FakeLocalParticipant) time.Sleep(time.Millisecond) // let the first update cycle run p.GetAudioLevelReturns(30, true) @@ -325,7 +325,7 @@ func TestActiveSpeakers(t *testing.T) { testutils.WithTimeout(t, "ensure everyone has gotten an audio update", func() bool { for _, op := range participants { - op := op.(*typesfakes.FakeParticipant) + op := op.(*typesfakes.FakeLocalParticipant) updates := getActiveSpeakerUpdates(op) if len(updates) == 0 { return false @@ -348,8 +348,8 @@ func TestActiveSpeakers(t *testing.T) { rm := newRoomWithParticipants(t, testRoomOpts{num: 2, protocol: types.DefaultProtocol, audioSmoothIntervals: 3}) defer rm.Close() participants := rm.GetParticipants() - p := participants[0].(*typesfakes.FakeParticipant) - op := participants[1].(*typesfakes.FakeParticipant) + p := participants[0].(*typesfakes.FakeLocalParticipant) + op := participants[1].(*typesfakes.FakeLocalParticipant) p.GetAudioLevelReturns(30, true) convertedLevel := rtc.ConvertAudioLevel(30) @@ -406,7 +406,7 @@ func TestDataChannel(t *testing.T) { rm := newRoomWithParticipants(t, testRoomOpts{num: 3}) defer rm.Close() participants := rm.GetParticipants() - p := participants[0].(*typesfakes.FakeParticipant) + p := participants[0].(*typesfakes.FakeLocalParticipant) packet := livekit.DataPacket{ Kind: livekit.DataPacket_RELIABLE, @@ -421,7 +421,7 @@ func TestDataChannel(t *testing.T) { // ensure everyone has received the packet for _, op := range participants { - fp := op.(*typesfakes.FakeParticipant) + fp := op.(*typesfakes.FakeLocalParticipant) if fp == p { require.Zero(t, fp.SendDataPacketCallCount()) continue @@ -435,8 +435,8 @@ func TestDataChannel(t *testing.T) { rm := newRoomWithParticipants(t, testRoomOpts{num: 4}) defer rm.Close() participants := rm.GetParticipants() - p := participants[0].(*typesfakes.FakeParticipant) - p1 := participants[1].(*typesfakes.FakeParticipant) + p := participants[0].(*typesfakes.FakeLocalParticipant) + p1 := participants[1].(*typesfakes.FakeLocalParticipant) packet := livekit.DataPacket{ Kind: livekit.DataPacket_RELIABLE, @@ -452,7 +452,7 @@ func TestDataChannel(t *testing.T) { // only p1 should receive the data for _, op := range participants { - fp := op.(*typesfakes.FakeParticipant) + fp := op.(*typesfakes.FakeLocalParticipant) if fp != p1 { require.Zero(t, fp.SendDataPacketCallCount()) } @@ -465,7 +465,7 @@ func TestDataChannel(t *testing.T) { rm := newRoomWithParticipants(t, testRoomOpts{num: 2}) defer rm.Close() participants := rm.GetParticipants() - p := participants[0].(*typesfakes.FakeParticipant) + p := participants[0].(*typesfakes.FakeLocalParticipant) p.CanPublishDataReturns(false) packet := livekit.DataPacket{ @@ -480,7 +480,7 @@ func TestDataChannel(t *testing.T) { // no one should've been sent packet for _, op := range participants { - fp := op.(*typesfakes.FakeParticipant) + fp := op.(*typesfakes.FakeLocalParticipant) require.Zero(t, fp.SendDataPacketCallCount()) } }) @@ -519,7 +519,7 @@ func TestHiddenParticipants(t *testing.T) { if p == op { continue } - mockP := op.(*typesfakes.FakeParticipant) + mockP := op.(*typesfakes.FakeLocalParticipant) require.NotZero(t, mockP.AddSubscriberCallCount()) // last call should be to add the newest participant sub, params := mockP.AddSubscriberArgsForCall(mockP.AddSubscriberCallCount() - 1) @@ -537,7 +537,7 @@ func TestRoomUpdate(t *testing.T) { rm.SetMetadata("test metadata...") for _, op := range rm.GetParticipants() { - fp := op.(*typesfakes.FakeParticipant) + fp := op.(*typesfakes.FakeLocalParticipant) require.Equal(t, 1, fp.SendRoomUpdateCallCount()) } }) diff --git a/pkg/rtc/signalhandler.go b/pkg/rtc/signalhandler.go index 00351eb5f..71c3ccaf4 100644 --- a/pkg/rtc/signalhandler.go +++ b/pkg/rtc/signalhandler.go @@ -7,7 +7,7 @@ import ( "github.com/livekit/livekit-server/pkg/rtc/types" ) -func HandleParticipantSignal(room types.Room, participant types.Participant, req *livekit.SignalRequest, pLogger logger.Logger) error { +func HandleParticipantSignal(room types.Room, participant types.LocalParticipant, req *livekit.SignalRequest, pLogger logger.Logger) error { switch msg := req.Message.(type) { case *livekit.SignalRequest_Offer: _, err := participant.HandleOffer(FromProtoSessionDescription(msg.Offer)) diff --git a/pkg/rtc/types/interfaces.go b/pkg/rtc/types/interfaces.go index 032b93204..5ceb52230 100644 --- a/pkg/rtc/types/interfaces.go +++ b/pkg/rtc/types/interfaces.go @@ -32,8 +32,37 @@ const ( MigrateStateComplete ) +//counterfeiter:generate . Participant +type Participant interface { + ID() livekit.ParticipantID + Identity() livekit.ParticipantIdentity + + ToProto() *livekit.ParticipantInfo + + SetMetadata(metadata string) + + GetPublishedTrack(sid livekit.TrackID) MediaTrack + GetPublishedTracks() []MediaTrack + + AddSubscriber(op LocalParticipant, params AddSubscriberParams) (int, error) + RemoveSubscriber(op LocalParticipant, trackID livekit.TrackID) + + // permissions + Hidden() bool + + Start() + Close(sendLeave bool) error + + UpdateSubscriptionPermissions(permissions *livekit.UpdateSubscriptionPermissions, resolver func(participantID livekit.ParticipantID) LocalParticipant) error + UpdateVideoLayers(updateVideoLayers *livekit.UpdateVideoLayers) error + + DebugInfo() map[string]interface{} +} + //counterfeiter:generate . LocalParticipant type LocalParticipant interface { + Participant + ProtocolVersion() ProtocolVersion ConnectedAt() time.Time @@ -87,12 +116,14 @@ type LocalParticipant interface { SubscriptionPermissionUpdate(publisherID livekit.ParticipantID, trackID livekit.TrackID, allowed bool) // callbacks - OnStateChange(func(p Participant, oldState livekit.ParticipantInfo_State)) + OnStateChange(func(p LocalParticipant, oldState livekit.ParticipantInfo_State)) + // OnTrackPublished - remote added a track + OnTrackPublished(func(LocalParticipant, MediaTrack)) // 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)) + OnTrackUpdated(callback func(LocalParticipant, MediaTrack)) + OnMetadataUpdate(callback func(LocalParticipant)) + OnDataPacket(callback func(LocalParticipant, *livekit.DataPacket)) + OnClose(_callback func(LocalParticipant, map[livekit.TrackID]livekit.ParticipantID)) // updates from remotes UpdateSubscribedQuality(nodeID string, trackID livekit.TrackID, maxQuality livekit.VideoQuality) error @@ -105,77 +136,45 @@ type LocalParticipant interface { 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 - Hidden() bool - - Start() - Close(sendLeave bool) error - - // callbacks - // OnTrackPublished - remote added a remoteTrack - OnTrackPublished(func(Participant, PublishedTrack)) - - UpdateSubscriptionPermissions(permissions *livekit.UpdateSubscriptionPermissions, resolver func(participantID livekit.ParticipantID) Participant) error - UpdateVideoLayers(updateVideoLayers *livekit.UpdateVideoLayers) error - - DebugInfo() map[string]interface{} -} - // Room is a container of participants, and can provide room level actions //counterfeiter:generate . Room type Room interface { Name() livekit.RoomName - UpdateSubscriptions(participant Participant, trackIDs []livekit.TrackID, participantTracks []*livekit.ParticipantTracks, subscribe bool) error + UpdateSubscriptions(participant LocalParticipant, trackIDs []livekit.TrackID, participantTracks []*livekit.ParticipantTracks, subscribe bool) error UpdateSubscriptionPermissions(participant Participant, permissions *livekit.UpdateSubscriptionPermissions) error - SyncState(participant Participant, state *livekit.SyncState) error - SimulateScenario(participant Participant, scenario *livekit.SimulateScenario) error + SyncState(participant LocalParticipant, state *livekit.SyncState) error + SimulateScenario(participant LocalParticipant, scenario *livekit.SimulateScenario) error 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 - IsMuted() bool - SetMuted(muted bool) - UpdateVideoLayers(layers []*livekit.VideoLayer) Source() livekit.TrackSource - IsSimulcast() bool + + ToProto() *livekit.TrackInfo PublisherID() livekit.ParticipantID PublisherIdentity() livekit.ParticipantIdentity - ToProto() *livekit.TrackInfo + IsMuted() bool + SetMuted(muted bool) + + UpdateVideoLayers(layers []*livekit.VideoLayer) + IsSimulcast() bool + + Receiver() sfu.TrackReceiver + + // callbacks + OnSubscribedMaxQualityChange(f func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error) + AddOnClose(func()) // subscribers - AddSubscriber(participant Participant) error + AddSubscriber(participant LocalParticipant) error RemoveSubscriber(participantID livekit.ParticipantID) IsSubscriber(subID livekit.ParticipantID) bool GetAllSubscriberIDs() []livekit.ParticipantID @@ -189,35 +188,20 @@ type MediaTrack interface { NotifySubscriberNodeMaxQuality(nodeID string, quality livekit.VideoQuality) } -//counterfeiter:generate . LocalPublishedTrack -type LocalPublishedTrack interface { +//counterfeiter:generate . LocalMediaTrack +type LocalMediaTrack interface { + MediaTrack + SignalCid() string SdpCid() string GetAudioLevel() (level uint8, active bool) GetConnectionScore() float64 + + NotifySubscriberNodeMediaLoss(nodeID string, fractionalLoss uint8) } -// PublishedTrack is the main interface representing a track published to the room -// it's responsible for managing subscribers and forwarding data from the input track to all subscribers -//counterfeiter:generate . PublishedTrack -type PublishedTrack interface { - MediaTrack - - ToProto() *livekit.TrackInfo - - Receiver() sfu.TrackReceiver - - UpdateVideoLayers(layers []*livekit.VideoLayer) - - OnSubscribedMaxQualityChange(f func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error) - - // callbacks - AddOnClose(func()) - - LocalPublishedTrack -} - +// MediaTrack is the main interface representing a track published to the room //counterfeiter:generate . SubscribedTrack type SubscribedTrack interface { OnBind(f func()) diff --git a/pkg/rtc/types/typesfakes/fake_local_media_track.go b/pkg/rtc/types/typesfakes/fake_local_media_track.go index a10e01841..ecb3b435d 100644 --- a/pkg/rtc/types/typesfakes/fake_local_media_track.go +++ b/pkg/rtc/types/typesfakes/fake_local_media_track.go @@ -5,19 +5,968 @@ import ( "sync" "github.com/livekit/livekit-server/pkg/rtc/types" + "github.com/livekit/livekit-server/pkg/sfu" + "github.com/livekit/protocol/livekit" ) type FakeLocalMediaTrack struct { + AddOnCloseStub func(func()) + addOnCloseMutex sync.RWMutex + addOnCloseArgsForCall []struct { + arg1 func() + } + AddSubscriberStub func(types.LocalParticipant) error + addSubscriberMutex sync.RWMutex + addSubscriberArgsForCall []struct { + arg1 types.LocalParticipant + } + addSubscriberReturns struct { + result1 error + } + addSubscriberReturnsOnCall map[int]struct { + result1 error + } + GetAllSubscriberIDsStub func() []livekit.ParticipantID + getAllSubscriberIDsMutex sync.RWMutex + getAllSubscriberIDsArgsForCall []struct { + } + getAllSubscriberIDsReturns struct { + result1 []livekit.ParticipantID + } + getAllSubscriberIDsReturnsOnCall map[int]struct { + result1 []livekit.ParticipantID + } + 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 + } + GetQualityForDimensionStub func(uint32, uint32) livekit.VideoQuality + getQualityForDimensionMutex sync.RWMutex + getQualityForDimensionArgsForCall []struct { + arg1 uint32 + arg2 uint32 + } + getQualityForDimensionReturns struct { + result1 livekit.VideoQuality + } + getQualityForDimensionReturnsOnCall map[int]struct { + result1 livekit.VideoQuality + } + IDStub func() livekit.TrackID + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 livekit.TrackID + } + iDReturnsOnCall map[int]struct { + result1 livekit.TrackID + } + IsMutedStub func() bool + isMutedMutex sync.RWMutex + isMutedArgsForCall []struct { + } + isMutedReturns struct { + result1 bool + } + isMutedReturnsOnCall map[int]struct { + result1 bool + } + IsSimulcastStub func() bool + isSimulcastMutex sync.RWMutex + isSimulcastArgsForCall []struct { + } + isSimulcastReturns struct { + result1 bool + } + isSimulcastReturnsOnCall map[int]struct { + result1 bool + } + IsSubscriberStub func(livekit.ParticipantID) bool + isSubscriberMutex sync.RWMutex + isSubscriberArgsForCall []struct { + arg1 livekit.ParticipantID + } + isSubscriberReturns struct { + result1 bool + } + isSubscriberReturnsOnCall map[int]struct { + result1 bool + } + KindStub func() livekit.TrackType + kindMutex sync.RWMutex + kindArgsForCall []struct { + } + kindReturns struct { + result1 livekit.TrackType + } + kindReturnsOnCall map[int]struct { + result1 livekit.TrackType + } + NameStub func() string + nameMutex sync.RWMutex + nameArgsForCall []struct { + } + nameReturns struct { + result1 string + } + nameReturnsOnCall map[int]struct { + result1 string + } + NotifySubscriberMaxQualityStub func(livekit.ParticipantID, livekit.VideoQuality) + notifySubscriberMaxQualityMutex sync.RWMutex + notifySubscriberMaxQualityArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 livekit.VideoQuality + } + NotifySubscriberNodeMaxQualityStub func(string, livekit.VideoQuality) + notifySubscriberNodeMaxQualityMutex sync.RWMutex + notifySubscriberNodeMaxQualityArgsForCall []struct { + arg1 string + arg2 livekit.VideoQuality + } NotifySubscriberNodeMediaLossStub func(string, uint8) notifySubscriberNodeMediaLossMutex sync.RWMutex notifySubscriberNodeMediaLossArgsForCall []struct { arg1 string arg2 uint8 } + OnSubscribedMaxQualityChangeStub func(func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error) + onSubscribedMaxQualityChangeMutex sync.RWMutex + onSubscribedMaxQualityChangeArgsForCall []struct { + arg1 func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error + } + PublisherIDStub func() livekit.ParticipantID + publisherIDMutex sync.RWMutex + publisherIDArgsForCall []struct { + } + publisherIDReturns struct { + result1 livekit.ParticipantID + } + publisherIDReturnsOnCall map[int]struct { + result1 livekit.ParticipantID + } + PublisherIdentityStub func() livekit.ParticipantIdentity + publisherIdentityMutex sync.RWMutex + publisherIdentityArgsForCall []struct { + } + publisherIdentityReturns struct { + result1 livekit.ParticipantIdentity + } + publisherIdentityReturnsOnCall map[int]struct { + result1 livekit.ParticipantIdentity + } + ReceiverStub func() sfu.TrackReceiver + receiverMutex sync.RWMutex + receiverArgsForCall []struct { + } + receiverReturns struct { + result1 sfu.TrackReceiver + } + receiverReturnsOnCall map[int]struct { + result1 sfu.TrackReceiver + } + RemoveAllSubscribersStub func() + removeAllSubscribersMutex sync.RWMutex + removeAllSubscribersArgsForCall []struct { + } + RemoveSubscriberStub func(livekit.ParticipantID) + removeSubscriberMutex sync.RWMutex + removeSubscriberArgsForCall []struct { + arg1 livekit.ParticipantID + } + RevokeDisallowedSubscribersStub func([]livekit.ParticipantID) []livekit.ParticipantID + revokeDisallowedSubscribersMutex sync.RWMutex + revokeDisallowedSubscribersArgsForCall []struct { + arg1 []livekit.ParticipantID + } + revokeDisallowedSubscribersReturns struct { + result1 []livekit.ParticipantID + } + revokeDisallowedSubscribersReturnsOnCall map[int]struct { + result1 []livekit.ParticipantID + } + SdpCidStub func() string + sdpCidMutex sync.RWMutex + sdpCidArgsForCall []struct { + } + sdpCidReturns struct { + result1 string + } + sdpCidReturnsOnCall map[int]struct { + result1 string + } + SetMutedStub func(bool) + setMutedMutex sync.RWMutex + setMutedArgsForCall []struct { + arg1 bool + } + SignalCidStub func() string + signalCidMutex sync.RWMutex + signalCidArgsForCall []struct { + } + signalCidReturns struct { + result1 string + } + signalCidReturnsOnCall map[int]struct { + result1 string + } + SourceStub func() livekit.TrackSource + sourceMutex sync.RWMutex + sourceArgsForCall []struct { + } + sourceReturns struct { + result1 livekit.TrackSource + } + sourceReturnsOnCall map[int]struct { + result1 livekit.TrackSource + } + ToProtoStub func() *livekit.TrackInfo + toProtoMutex sync.RWMutex + toProtoArgsForCall []struct { + } + toProtoReturns struct { + result1 *livekit.TrackInfo + } + toProtoReturnsOnCall map[int]struct { + result1 *livekit.TrackInfo + } + UpdateVideoLayersStub func([]*livekit.VideoLayer) + updateVideoLayersMutex sync.RWMutex + updateVideoLayersArgsForCall []struct { + arg1 []*livekit.VideoLayer + } invocations map[string][][]interface{} invocationsMutex sync.RWMutex } +func (fake *FakeLocalMediaTrack) AddOnClose(arg1 func()) { + fake.addOnCloseMutex.Lock() + fake.addOnCloseArgsForCall = append(fake.addOnCloseArgsForCall, struct { + arg1 func() + }{arg1}) + stub := fake.AddOnCloseStub + fake.recordInvocation("AddOnClose", []interface{}{arg1}) + fake.addOnCloseMutex.Unlock() + if stub != nil { + fake.AddOnCloseStub(arg1) + } +} + +func (fake *FakeLocalMediaTrack) AddOnCloseCallCount() int { + fake.addOnCloseMutex.RLock() + defer fake.addOnCloseMutex.RUnlock() + return len(fake.addOnCloseArgsForCall) +} + +func (fake *FakeLocalMediaTrack) AddOnCloseCalls(stub func(func())) { + fake.addOnCloseMutex.Lock() + defer fake.addOnCloseMutex.Unlock() + fake.AddOnCloseStub = stub +} + +func (fake *FakeLocalMediaTrack) AddOnCloseArgsForCall(i int) func() { + fake.addOnCloseMutex.RLock() + defer fake.addOnCloseMutex.RUnlock() + argsForCall := fake.addOnCloseArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalMediaTrack) AddSubscriber(arg1 types.LocalParticipant) error { + fake.addSubscriberMutex.Lock() + ret, specificReturn := fake.addSubscriberReturnsOnCall[len(fake.addSubscriberArgsForCall)] + fake.addSubscriberArgsForCall = append(fake.addSubscriberArgsForCall, struct { + arg1 types.LocalParticipant + }{arg1}) + stub := fake.AddSubscriberStub + fakeReturns := fake.addSubscriberReturns + fake.recordInvocation("AddSubscriber", []interface{}{arg1}) + fake.addSubscriberMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) AddSubscriberCallCount() int { + fake.addSubscriberMutex.RLock() + defer fake.addSubscriberMutex.RUnlock() + return len(fake.addSubscriberArgsForCall) +} + +func (fake *FakeLocalMediaTrack) AddSubscriberCalls(stub func(types.LocalParticipant) error) { + fake.addSubscriberMutex.Lock() + defer fake.addSubscriberMutex.Unlock() + fake.AddSubscriberStub = stub +} + +func (fake *FakeLocalMediaTrack) AddSubscriberArgsForCall(i int) types.LocalParticipant { + fake.addSubscriberMutex.RLock() + defer fake.addSubscriberMutex.RUnlock() + argsForCall := fake.addSubscriberArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalMediaTrack) AddSubscriberReturns(result1 error) { + fake.addSubscriberMutex.Lock() + defer fake.addSubscriberMutex.Unlock() + fake.AddSubscriberStub = nil + fake.addSubscriberReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalMediaTrack) AddSubscriberReturnsOnCall(i int, result1 error) { + fake.addSubscriberMutex.Lock() + defer fake.addSubscriberMutex.Unlock() + fake.AddSubscriberStub = nil + if fake.addSubscriberReturnsOnCall == nil { + fake.addSubscriberReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.addSubscriberReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalMediaTrack) GetAllSubscriberIDs() []livekit.ParticipantID { + fake.getAllSubscriberIDsMutex.Lock() + ret, specificReturn := fake.getAllSubscriberIDsReturnsOnCall[len(fake.getAllSubscriberIDsArgsForCall)] + fake.getAllSubscriberIDsArgsForCall = append(fake.getAllSubscriberIDsArgsForCall, struct { + }{}) + stub := fake.GetAllSubscriberIDsStub + fakeReturns := fake.getAllSubscriberIDsReturns + fake.recordInvocation("GetAllSubscriberIDs", []interface{}{}) + fake.getAllSubscriberIDsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) GetAllSubscriberIDsCallCount() int { + fake.getAllSubscriberIDsMutex.RLock() + defer fake.getAllSubscriberIDsMutex.RUnlock() + return len(fake.getAllSubscriberIDsArgsForCall) +} + +func (fake *FakeLocalMediaTrack) GetAllSubscriberIDsCalls(stub func() []livekit.ParticipantID) { + fake.getAllSubscriberIDsMutex.Lock() + defer fake.getAllSubscriberIDsMutex.Unlock() + fake.GetAllSubscriberIDsStub = stub +} + +func (fake *FakeLocalMediaTrack) GetAllSubscriberIDsReturns(result1 []livekit.ParticipantID) { + fake.getAllSubscriberIDsMutex.Lock() + defer fake.getAllSubscriberIDsMutex.Unlock() + fake.GetAllSubscriberIDsStub = nil + fake.getAllSubscriberIDsReturns = struct { + result1 []livekit.ParticipantID + }{result1} +} + +func (fake *FakeLocalMediaTrack) GetAllSubscriberIDsReturnsOnCall(i int, result1 []livekit.ParticipantID) { + fake.getAllSubscriberIDsMutex.Lock() + defer fake.getAllSubscriberIDsMutex.Unlock() + fake.GetAllSubscriberIDsStub = nil + if fake.getAllSubscriberIDsReturnsOnCall == nil { + fake.getAllSubscriberIDsReturnsOnCall = make(map[int]struct { + result1 []livekit.ParticipantID + }) + } + fake.getAllSubscriberIDsReturnsOnCall[i] = struct { + result1 []livekit.ParticipantID + }{result1} +} + +func (fake *FakeLocalMediaTrack) 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 *FakeLocalMediaTrack) GetAudioLevelCallCount() int { + fake.getAudioLevelMutex.RLock() + defer fake.getAudioLevelMutex.RUnlock() + return len(fake.getAudioLevelArgsForCall) +} + +func (fake *FakeLocalMediaTrack) GetAudioLevelCalls(stub func() (uint8, bool)) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = stub +} + +func (fake *FakeLocalMediaTrack) 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 *FakeLocalMediaTrack) 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 *FakeLocalMediaTrack) 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 *FakeLocalMediaTrack) GetConnectionScoreCallCount() int { + fake.getConnectionScoreMutex.RLock() + defer fake.getConnectionScoreMutex.RUnlock() + return len(fake.getConnectionScoreArgsForCall) +} + +func (fake *FakeLocalMediaTrack) GetConnectionScoreCalls(stub func() float64) { + fake.getConnectionScoreMutex.Lock() + defer fake.getConnectionScoreMutex.Unlock() + fake.GetConnectionScoreStub = stub +} + +func (fake *FakeLocalMediaTrack) GetConnectionScoreReturns(result1 float64) { + fake.getConnectionScoreMutex.Lock() + defer fake.getConnectionScoreMutex.Unlock() + fake.GetConnectionScoreStub = nil + fake.getConnectionScoreReturns = struct { + result1 float64 + }{result1} +} + +func (fake *FakeLocalMediaTrack) 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 *FakeLocalMediaTrack) GetQualityForDimension(arg1 uint32, arg2 uint32) livekit.VideoQuality { + fake.getQualityForDimensionMutex.Lock() + ret, specificReturn := fake.getQualityForDimensionReturnsOnCall[len(fake.getQualityForDimensionArgsForCall)] + fake.getQualityForDimensionArgsForCall = append(fake.getQualityForDimensionArgsForCall, struct { + arg1 uint32 + arg2 uint32 + }{arg1, arg2}) + stub := fake.GetQualityForDimensionStub + fakeReturns := fake.getQualityForDimensionReturns + fake.recordInvocation("GetQualityForDimension", []interface{}{arg1, arg2}) + fake.getQualityForDimensionMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) GetQualityForDimensionCallCount() int { + fake.getQualityForDimensionMutex.RLock() + defer fake.getQualityForDimensionMutex.RUnlock() + return len(fake.getQualityForDimensionArgsForCall) +} + +func (fake *FakeLocalMediaTrack) GetQualityForDimensionCalls(stub func(uint32, uint32) livekit.VideoQuality) { + fake.getQualityForDimensionMutex.Lock() + defer fake.getQualityForDimensionMutex.Unlock() + fake.GetQualityForDimensionStub = stub +} + +func (fake *FakeLocalMediaTrack) GetQualityForDimensionArgsForCall(i int) (uint32, uint32) { + fake.getQualityForDimensionMutex.RLock() + defer fake.getQualityForDimensionMutex.RUnlock() + argsForCall := fake.getQualityForDimensionArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeLocalMediaTrack) GetQualityForDimensionReturns(result1 livekit.VideoQuality) { + fake.getQualityForDimensionMutex.Lock() + defer fake.getQualityForDimensionMutex.Unlock() + fake.GetQualityForDimensionStub = nil + fake.getQualityForDimensionReturns = struct { + result1 livekit.VideoQuality + }{result1} +} + +func (fake *FakeLocalMediaTrack) GetQualityForDimensionReturnsOnCall(i int, result1 livekit.VideoQuality) { + fake.getQualityForDimensionMutex.Lock() + defer fake.getQualityForDimensionMutex.Unlock() + fake.GetQualityForDimensionStub = nil + if fake.getQualityForDimensionReturnsOnCall == nil { + fake.getQualityForDimensionReturnsOnCall = make(map[int]struct { + result1 livekit.VideoQuality + }) + } + fake.getQualityForDimensionReturnsOnCall[i] = struct { + result1 livekit.VideoQuality + }{result1} +} + +func (fake *FakeLocalMediaTrack) ID() livekit.TrackID { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *FakeLocalMediaTrack) IDCalls(stub func() livekit.TrackID) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *FakeLocalMediaTrack) IDReturns(result1 livekit.TrackID) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 livekit.TrackID + }{result1} +} + +func (fake *FakeLocalMediaTrack) IDReturnsOnCall(i int, result1 livekit.TrackID) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 livekit.TrackID + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 livekit.TrackID + }{result1} +} + +func (fake *FakeLocalMediaTrack) IsMuted() bool { + fake.isMutedMutex.Lock() + ret, specificReturn := fake.isMutedReturnsOnCall[len(fake.isMutedArgsForCall)] + fake.isMutedArgsForCall = append(fake.isMutedArgsForCall, struct { + }{}) + stub := fake.IsMutedStub + fakeReturns := fake.isMutedReturns + fake.recordInvocation("IsMuted", []interface{}{}) + fake.isMutedMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) IsMutedCallCount() int { + fake.isMutedMutex.RLock() + defer fake.isMutedMutex.RUnlock() + return len(fake.isMutedArgsForCall) +} + +func (fake *FakeLocalMediaTrack) IsMutedCalls(stub func() bool) { + fake.isMutedMutex.Lock() + defer fake.isMutedMutex.Unlock() + fake.IsMutedStub = stub +} + +func (fake *FakeLocalMediaTrack) IsMutedReturns(result1 bool) { + fake.isMutedMutex.Lock() + defer fake.isMutedMutex.Unlock() + fake.IsMutedStub = nil + fake.isMutedReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalMediaTrack) IsMutedReturnsOnCall(i int, result1 bool) { + fake.isMutedMutex.Lock() + defer fake.isMutedMutex.Unlock() + fake.IsMutedStub = nil + if fake.isMutedReturnsOnCall == nil { + fake.isMutedReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isMutedReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalMediaTrack) IsSimulcast() bool { + fake.isSimulcastMutex.Lock() + ret, specificReturn := fake.isSimulcastReturnsOnCall[len(fake.isSimulcastArgsForCall)] + fake.isSimulcastArgsForCall = append(fake.isSimulcastArgsForCall, struct { + }{}) + stub := fake.IsSimulcastStub + fakeReturns := fake.isSimulcastReturns + fake.recordInvocation("IsSimulcast", []interface{}{}) + fake.isSimulcastMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) IsSimulcastCallCount() int { + fake.isSimulcastMutex.RLock() + defer fake.isSimulcastMutex.RUnlock() + return len(fake.isSimulcastArgsForCall) +} + +func (fake *FakeLocalMediaTrack) IsSimulcastCalls(stub func() bool) { + fake.isSimulcastMutex.Lock() + defer fake.isSimulcastMutex.Unlock() + fake.IsSimulcastStub = stub +} + +func (fake *FakeLocalMediaTrack) IsSimulcastReturns(result1 bool) { + fake.isSimulcastMutex.Lock() + defer fake.isSimulcastMutex.Unlock() + fake.IsSimulcastStub = nil + fake.isSimulcastReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalMediaTrack) IsSimulcastReturnsOnCall(i int, result1 bool) { + fake.isSimulcastMutex.Lock() + defer fake.isSimulcastMutex.Unlock() + fake.IsSimulcastStub = nil + if fake.isSimulcastReturnsOnCall == nil { + fake.isSimulcastReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isSimulcastReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalMediaTrack) IsSubscriber(arg1 livekit.ParticipantID) bool { + fake.isSubscriberMutex.Lock() + ret, specificReturn := fake.isSubscriberReturnsOnCall[len(fake.isSubscriberArgsForCall)] + fake.isSubscriberArgsForCall = append(fake.isSubscriberArgsForCall, struct { + arg1 livekit.ParticipantID + }{arg1}) + stub := fake.IsSubscriberStub + fakeReturns := fake.isSubscriberReturns + fake.recordInvocation("IsSubscriber", []interface{}{arg1}) + fake.isSubscriberMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) IsSubscriberCallCount() int { + fake.isSubscriberMutex.RLock() + defer fake.isSubscriberMutex.RUnlock() + return len(fake.isSubscriberArgsForCall) +} + +func (fake *FakeLocalMediaTrack) IsSubscriberCalls(stub func(livekit.ParticipantID) bool) { + fake.isSubscriberMutex.Lock() + defer fake.isSubscriberMutex.Unlock() + fake.IsSubscriberStub = stub +} + +func (fake *FakeLocalMediaTrack) IsSubscriberArgsForCall(i int) livekit.ParticipantID { + fake.isSubscriberMutex.RLock() + defer fake.isSubscriberMutex.RUnlock() + argsForCall := fake.isSubscriberArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalMediaTrack) IsSubscriberReturns(result1 bool) { + fake.isSubscriberMutex.Lock() + defer fake.isSubscriberMutex.Unlock() + fake.IsSubscriberStub = nil + fake.isSubscriberReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalMediaTrack) IsSubscriberReturnsOnCall(i int, result1 bool) { + fake.isSubscriberMutex.Lock() + defer fake.isSubscriberMutex.Unlock() + fake.IsSubscriberStub = nil + if fake.isSubscriberReturnsOnCall == nil { + fake.isSubscriberReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isSubscriberReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalMediaTrack) Kind() livekit.TrackType { + fake.kindMutex.Lock() + ret, specificReturn := fake.kindReturnsOnCall[len(fake.kindArgsForCall)] + fake.kindArgsForCall = append(fake.kindArgsForCall, struct { + }{}) + stub := fake.KindStub + fakeReturns := fake.kindReturns + fake.recordInvocation("Kind", []interface{}{}) + fake.kindMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) KindCallCount() int { + fake.kindMutex.RLock() + defer fake.kindMutex.RUnlock() + return len(fake.kindArgsForCall) +} + +func (fake *FakeLocalMediaTrack) KindCalls(stub func() livekit.TrackType) { + fake.kindMutex.Lock() + defer fake.kindMutex.Unlock() + fake.KindStub = stub +} + +func (fake *FakeLocalMediaTrack) KindReturns(result1 livekit.TrackType) { + fake.kindMutex.Lock() + defer fake.kindMutex.Unlock() + fake.KindStub = nil + fake.kindReturns = struct { + result1 livekit.TrackType + }{result1} +} + +func (fake *FakeLocalMediaTrack) KindReturnsOnCall(i int, result1 livekit.TrackType) { + fake.kindMutex.Lock() + defer fake.kindMutex.Unlock() + fake.KindStub = nil + if fake.kindReturnsOnCall == nil { + fake.kindReturnsOnCall = make(map[int]struct { + result1 livekit.TrackType + }) + } + fake.kindReturnsOnCall[i] = struct { + result1 livekit.TrackType + }{result1} +} + +func (fake *FakeLocalMediaTrack) Name() string { + fake.nameMutex.Lock() + ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)] + fake.nameArgsForCall = append(fake.nameArgsForCall, struct { + }{}) + stub := fake.NameStub + fakeReturns := fake.nameReturns + fake.recordInvocation("Name", []interface{}{}) + fake.nameMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) NameCallCount() int { + fake.nameMutex.RLock() + defer fake.nameMutex.RUnlock() + return len(fake.nameArgsForCall) +} + +func (fake *FakeLocalMediaTrack) NameCalls(stub func() string) { + fake.nameMutex.Lock() + defer fake.nameMutex.Unlock() + fake.NameStub = stub +} + +func (fake *FakeLocalMediaTrack) NameReturns(result1 string) { + fake.nameMutex.Lock() + defer fake.nameMutex.Unlock() + fake.NameStub = nil + fake.nameReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeLocalMediaTrack) NameReturnsOnCall(i int, result1 string) { + fake.nameMutex.Lock() + defer fake.nameMutex.Unlock() + fake.NameStub = nil + if fake.nameReturnsOnCall == nil { + fake.nameReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.nameReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberMaxQuality(arg1 livekit.ParticipantID, arg2 livekit.VideoQuality) { + fake.notifySubscriberMaxQualityMutex.Lock() + fake.notifySubscriberMaxQualityArgsForCall = append(fake.notifySubscriberMaxQualityArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 livekit.VideoQuality + }{arg1, arg2}) + stub := fake.NotifySubscriberMaxQualityStub + fake.recordInvocation("NotifySubscriberMaxQuality", []interface{}{arg1, arg2}) + fake.notifySubscriberMaxQualityMutex.Unlock() + if stub != nil { + fake.NotifySubscriberMaxQualityStub(arg1, arg2) + } +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberMaxQualityCallCount() int { + fake.notifySubscriberMaxQualityMutex.RLock() + defer fake.notifySubscriberMaxQualityMutex.RUnlock() + return len(fake.notifySubscriberMaxQualityArgsForCall) +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberMaxQualityCalls(stub func(livekit.ParticipantID, livekit.VideoQuality)) { + fake.notifySubscriberMaxQualityMutex.Lock() + defer fake.notifySubscriberMaxQualityMutex.Unlock() + fake.NotifySubscriberMaxQualityStub = stub +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberMaxQualityArgsForCall(i int) (livekit.ParticipantID, livekit.VideoQuality) { + fake.notifySubscriberMaxQualityMutex.RLock() + defer fake.notifySubscriberMaxQualityMutex.RUnlock() + argsForCall := fake.notifySubscriberMaxQualityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberNodeMaxQuality(arg1 string, arg2 livekit.VideoQuality) { + fake.notifySubscriberNodeMaxQualityMutex.Lock() + fake.notifySubscriberNodeMaxQualityArgsForCall = append(fake.notifySubscriberNodeMaxQualityArgsForCall, struct { + arg1 string + arg2 livekit.VideoQuality + }{arg1, arg2}) + stub := fake.NotifySubscriberNodeMaxQualityStub + fake.recordInvocation("NotifySubscriberNodeMaxQuality", []interface{}{arg1, arg2}) + fake.notifySubscriberNodeMaxQualityMutex.Unlock() + if stub != nil { + fake.NotifySubscriberNodeMaxQualityStub(arg1, arg2) + } +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberNodeMaxQualityCallCount() int { + fake.notifySubscriberNodeMaxQualityMutex.RLock() + defer fake.notifySubscriberNodeMaxQualityMutex.RUnlock() + return len(fake.notifySubscriberNodeMaxQualityArgsForCall) +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberNodeMaxQualityCalls(stub func(string, livekit.VideoQuality)) { + fake.notifySubscriberNodeMaxQualityMutex.Lock() + defer fake.notifySubscriberNodeMaxQualityMutex.Unlock() + fake.NotifySubscriberNodeMaxQualityStub = stub +} + +func (fake *FakeLocalMediaTrack) NotifySubscriberNodeMaxQualityArgsForCall(i int) (string, livekit.VideoQuality) { + fake.notifySubscriberNodeMaxQualityMutex.RLock() + defer fake.notifySubscriberNodeMaxQualityMutex.RUnlock() + argsForCall := fake.notifySubscriberNodeMaxQualityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + func (fake *FakeLocalMediaTrack) NotifySubscriberNodeMediaLoss(arg1 string, arg2 uint8) { fake.notifySubscriberNodeMediaLossMutex.Lock() fake.notifySubscriberNodeMediaLossArgsForCall = append(fake.notifySubscriberNodeMediaLossArgsForCall, struct { @@ -51,11 +1000,659 @@ func (fake *FakeLocalMediaTrack) NotifySubscriberNodeMediaLossArgsForCall(i int) return argsForCall.arg1, argsForCall.arg2 } +func (fake *FakeLocalMediaTrack) OnSubscribedMaxQualityChange(arg1 func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error) { + fake.onSubscribedMaxQualityChangeMutex.Lock() + fake.onSubscribedMaxQualityChangeArgsForCall = append(fake.onSubscribedMaxQualityChangeArgsForCall, struct { + arg1 func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error + }{arg1}) + stub := fake.OnSubscribedMaxQualityChangeStub + fake.recordInvocation("OnSubscribedMaxQualityChange", []interface{}{arg1}) + fake.onSubscribedMaxQualityChangeMutex.Unlock() + if stub != nil { + fake.OnSubscribedMaxQualityChangeStub(arg1) + } +} + +func (fake *FakeLocalMediaTrack) OnSubscribedMaxQualityChangeCallCount() int { + fake.onSubscribedMaxQualityChangeMutex.RLock() + defer fake.onSubscribedMaxQualityChangeMutex.RUnlock() + return len(fake.onSubscribedMaxQualityChangeArgsForCall) +} + +func (fake *FakeLocalMediaTrack) OnSubscribedMaxQualityChangeCalls(stub func(func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error)) { + fake.onSubscribedMaxQualityChangeMutex.Lock() + defer fake.onSubscribedMaxQualityChangeMutex.Unlock() + fake.OnSubscribedMaxQualityChangeStub = stub +} + +func (fake *FakeLocalMediaTrack) OnSubscribedMaxQualityChangeArgsForCall(i int) func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error { + fake.onSubscribedMaxQualityChangeMutex.RLock() + defer fake.onSubscribedMaxQualityChangeMutex.RUnlock() + argsForCall := fake.onSubscribedMaxQualityChangeArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalMediaTrack) PublisherID() livekit.ParticipantID { + fake.publisherIDMutex.Lock() + ret, specificReturn := fake.publisherIDReturnsOnCall[len(fake.publisherIDArgsForCall)] + fake.publisherIDArgsForCall = append(fake.publisherIDArgsForCall, struct { + }{}) + stub := fake.PublisherIDStub + fakeReturns := fake.publisherIDReturns + fake.recordInvocation("PublisherID", []interface{}{}) + fake.publisherIDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) PublisherIDCallCount() int { + fake.publisherIDMutex.RLock() + defer fake.publisherIDMutex.RUnlock() + return len(fake.publisherIDArgsForCall) +} + +func (fake *FakeLocalMediaTrack) PublisherIDCalls(stub func() livekit.ParticipantID) { + fake.publisherIDMutex.Lock() + defer fake.publisherIDMutex.Unlock() + fake.PublisherIDStub = stub +} + +func (fake *FakeLocalMediaTrack) PublisherIDReturns(result1 livekit.ParticipantID) { + fake.publisherIDMutex.Lock() + defer fake.publisherIDMutex.Unlock() + fake.PublisherIDStub = nil + fake.publisherIDReturns = struct { + result1 livekit.ParticipantID + }{result1} +} + +func (fake *FakeLocalMediaTrack) PublisherIDReturnsOnCall(i int, result1 livekit.ParticipantID) { + fake.publisherIDMutex.Lock() + defer fake.publisherIDMutex.Unlock() + fake.PublisherIDStub = nil + if fake.publisherIDReturnsOnCall == nil { + fake.publisherIDReturnsOnCall = make(map[int]struct { + result1 livekit.ParticipantID + }) + } + fake.publisherIDReturnsOnCall[i] = struct { + result1 livekit.ParticipantID + }{result1} +} + +func (fake *FakeLocalMediaTrack) PublisherIdentity() livekit.ParticipantIdentity { + fake.publisherIdentityMutex.Lock() + ret, specificReturn := fake.publisherIdentityReturnsOnCall[len(fake.publisherIdentityArgsForCall)] + fake.publisherIdentityArgsForCall = append(fake.publisherIdentityArgsForCall, struct { + }{}) + stub := fake.PublisherIdentityStub + fakeReturns := fake.publisherIdentityReturns + fake.recordInvocation("PublisherIdentity", []interface{}{}) + fake.publisherIdentityMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) PublisherIdentityCallCount() int { + fake.publisherIdentityMutex.RLock() + defer fake.publisherIdentityMutex.RUnlock() + return len(fake.publisherIdentityArgsForCall) +} + +func (fake *FakeLocalMediaTrack) PublisherIdentityCalls(stub func() livekit.ParticipantIdentity) { + fake.publisherIdentityMutex.Lock() + defer fake.publisherIdentityMutex.Unlock() + fake.PublisherIdentityStub = stub +} + +func (fake *FakeLocalMediaTrack) PublisherIdentityReturns(result1 livekit.ParticipantIdentity) { + fake.publisherIdentityMutex.Lock() + defer fake.publisherIdentityMutex.Unlock() + fake.PublisherIdentityStub = nil + fake.publisherIdentityReturns = struct { + result1 livekit.ParticipantIdentity + }{result1} +} + +func (fake *FakeLocalMediaTrack) PublisherIdentityReturnsOnCall(i int, result1 livekit.ParticipantIdentity) { + fake.publisherIdentityMutex.Lock() + defer fake.publisherIdentityMutex.Unlock() + fake.PublisherIdentityStub = nil + if fake.publisherIdentityReturnsOnCall == nil { + fake.publisherIdentityReturnsOnCall = make(map[int]struct { + result1 livekit.ParticipantIdentity + }) + } + fake.publisherIdentityReturnsOnCall[i] = struct { + result1 livekit.ParticipantIdentity + }{result1} +} + +func (fake *FakeLocalMediaTrack) Receiver() sfu.TrackReceiver { + fake.receiverMutex.Lock() + ret, specificReturn := fake.receiverReturnsOnCall[len(fake.receiverArgsForCall)] + fake.receiverArgsForCall = append(fake.receiverArgsForCall, struct { + }{}) + stub := fake.ReceiverStub + fakeReturns := fake.receiverReturns + fake.recordInvocation("Receiver", []interface{}{}) + fake.receiverMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) ReceiverCallCount() int { + fake.receiverMutex.RLock() + defer fake.receiverMutex.RUnlock() + return len(fake.receiverArgsForCall) +} + +func (fake *FakeLocalMediaTrack) ReceiverCalls(stub func() sfu.TrackReceiver) { + fake.receiverMutex.Lock() + defer fake.receiverMutex.Unlock() + fake.ReceiverStub = stub +} + +func (fake *FakeLocalMediaTrack) ReceiverReturns(result1 sfu.TrackReceiver) { + fake.receiverMutex.Lock() + defer fake.receiverMutex.Unlock() + fake.ReceiverStub = nil + fake.receiverReturns = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeLocalMediaTrack) ReceiverReturnsOnCall(i int, result1 sfu.TrackReceiver) { + fake.receiverMutex.Lock() + defer fake.receiverMutex.Unlock() + fake.ReceiverStub = nil + if fake.receiverReturnsOnCall == nil { + fake.receiverReturnsOnCall = make(map[int]struct { + result1 sfu.TrackReceiver + }) + } + fake.receiverReturnsOnCall[i] = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeLocalMediaTrack) RemoveAllSubscribers() { + fake.removeAllSubscribersMutex.Lock() + fake.removeAllSubscribersArgsForCall = append(fake.removeAllSubscribersArgsForCall, struct { + }{}) + stub := fake.RemoveAllSubscribersStub + fake.recordInvocation("RemoveAllSubscribers", []interface{}{}) + fake.removeAllSubscribersMutex.Unlock() + if stub != nil { + fake.RemoveAllSubscribersStub() + } +} + +func (fake *FakeLocalMediaTrack) RemoveAllSubscribersCallCount() int { + fake.removeAllSubscribersMutex.RLock() + defer fake.removeAllSubscribersMutex.RUnlock() + return len(fake.removeAllSubscribersArgsForCall) +} + +func (fake *FakeLocalMediaTrack) RemoveAllSubscribersCalls(stub func()) { + fake.removeAllSubscribersMutex.Lock() + defer fake.removeAllSubscribersMutex.Unlock() + fake.RemoveAllSubscribersStub = stub +} + +func (fake *FakeLocalMediaTrack) RemoveSubscriber(arg1 livekit.ParticipantID) { + fake.removeSubscriberMutex.Lock() + fake.removeSubscriberArgsForCall = append(fake.removeSubscriberArgsForCall, struct { + arg1 livekit.ParticipantID + }{arg1}) + stub := fake.RemoveSubscriberStub + fake.recordInvocation("RemoveSubscriber", []interface{}{arg1}) + fake.removeSubscriberMutex.Unlock() + if stub != nil { + fake.RemoveSubscriberStub(arg1) + } +} + +func (fake *FakeLocalMediaTrack) RemoveSubscriberCallCount() int { + fake.removeSubscriberMutex.RLock() + defer fake.removeSubscriberMutex.RUnlock() + return len(fake.removeSubscriberArgsForCall) +} + +func (fake *FakeLocalMediaTrack) RemoveSubscriberCalls(stub func(livekit.ParticipantID)) { + fake.removeSubscriberMutex.Lock() + defer fake.removeSubscriberMutex.Unlock() + fake.RemoveSubscriberStub = stub +} + +func (fake *FakeLocalMediaTrack) RemoveSubscriberArgsForCall(i int) livekit.ParticipantID { + fake.removeSubscriberMutex.RLock() + defer fake.removeSubscriberMutex.RUnlock() + argsForCall := fake.removeSubscriberArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalMediaTrack) RevokeDisallowedSubscribers(arg1 []livekit.ParticipantID) []livekit.ParticipantID { + var arg1Copy []livekit.ParticipantID + if arg1 != nil { + arg1Copy = make([]livekit.ParticipantID, len(arg1)) + copy(arg1Copy, arg1) + } + fake.revokeDisallowedSubscribersMutex.Lock() + ret, specificReturn := fake.revokeDisallowedSubscribersReturnsOnCall[len(fake.revokeDisallowedSubscribersArgsForCall)] + fake.revokeDisallowedSubscribersArgsForCall = append(fake.revokeDisallowedSubscribersArgsForCall, struct { + arg1 []livekit.ParticipantID + }{arg1Copy}) + stub := fake.RevokeDisallowedSubscribersStub + fakeReturns := fake.revokeDisallowedSubscribersReturns + fake.recordInvocation("RevokeDisallowedSubscribers", []interface{}{arg1Copy}) + fake.revokeDisallowedSubscribersMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) RevokeDisallowedSubscribersCallCount() int { + fake.revokeDisallowedSubscribersMutex.RLock() + defer fake.revokeDisallowedSubscribersMutex.RUnlock() + return len(fake.revokeDisallowedSubscribersArgsForCall) +} + +func (fake *FakeLocalMediaTrack) RevokeDisallowedSubscribersCalls(stub func([]livekit.ParticipantID) []livekit.ParticipantID) { + fake.revokeDisallowedSubscribersMutex.Lock() + defer fake.revokeDisallowedSubscribersMutex.Unlock() + fake.RevokeDisallowedSubscribersStub = stub +} + +func (fake *FakeLocalMediaTrack) RevokeDisallowedSubscribersArgsForCall(i int) []livekit.ParticipantID { + fake.revokeDisallowedSubscribersMutex.RLock() + defer fake.revokeDisallowedSubscribersMutex.RUnlock() + argsForCall := fake.revokeDisallowedSubscribersArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalMediaTrack) RevokeDisallowedSubscribersReturns(result1 []livekit.ParticipantID) { + fake.revokeDisallowedSubscribersMutex.Lock() + defer fake.revokeDisallowedSubscribersMutex.Unlock() + fake.RevokeDisallowedSubscribersStub = nil + fake.revokeDisallowedSubscribersReturns = struct { + result1 []livekit.ParticipantID + }{result1} +} + +func (fake *FakeLocalMediaTrack) RevokeDisallowedSubscribersReturnsOnCall(i int, result1 []livekit.ParticipantID) { + fake.revokeDisallowedSubscribersMutex.Lock() + defer fake.revokeDisallowedSubscribersMutex.Unlock() + fake.RevokeDisallowedSubscribersStub = nil + if fake.revokeDisallowedSubscribersReturnsOnCall == nil { + fake.revokeDisallowedSubscribersReturnsOnCall = make(map[int]struct { + result1 []livekit.ParticipantID + }) + } + fake.revokeDisallowedSubscribersReturnsOnCall[i] = struct { + result1 []livekit.ParticipantID + }{result1} +} + +func (fake *FakeLocalMediaTrack) 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 *FakeLocalMediaTrack) SdpCidCallCount() int { + fake.sdpCidMutex.RLock() + defer fake.sdpCidMutex.RUnlock() + return len(fake.sdpCidArgsForCall) +} + +func (fake *FakeLocalMediaTrack) SdpCidCalls(stub func() string) { + fake.sdpCidMutex.Lock() + defer fake.sdpCidMutex.Unlock() + fake.SdpCidStub = stub +} + +func (fake *FakeLocalMediaTrack) SdpCidReturns(result1 string) { + fake.sdpCidMutex.Lock() + defer fake.sdpCidMutex.Unlock() + fake.SdpCidStub = nil + fake.sdpCidReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeLocalMediaTrack) 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 *FakeLocalMediaTrack) SetMuted(arg1 bool) { + fake.setMutedMutex.Lock() + fake.setMutedArgsForCall = append(fake.setMutedArgsForCall, struct { + arg1 bool + }{arg1}) + stub := fake.SetMutedStub + fake.recordInvocation("SetMuted", []interface{}{arg1}) + fake.setMutedMutex.Unlock() + if stub != nil { + fake.SetMutedStub(arg1) + } +} + +func (fake *FakeLocalMediaTrack) SetMutedCallCount() int { + fake.setMutedMutex.RLock() + defer fake.setMutedMutex.RUnlock() + return len(fake.setMutedArgsForCall) +} + +func (fake *FakeLocalMediaTrack) SetMutedCalls(stub func(bool)) { + fake.setMutedMutex.Lock() + defer fake.setMutedMutex.Unlock() + fake.SetMutedStub = stub +} + +func (fake *FakeLocalMediaTrack) SetMutedArgsForCall(i int) bool { + fake.setMutedMutex.RLock() + defer fake.setMutedMutex.RUnlock() + argsForCall := fake.setMutedArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalMediaTrack) 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 *FakeLocalMediaTrack) SignalCidCallCount() int { + fake.signalCidMutex.RLock() + defer fake.signalCidMutex.RUnlock() + return len(fake.signalCidArgsForCall) +} + +func (fake *FakeLocalMediaTrack) SignalCidCalls(stub func() string) { + fake.signalCidMutex.Lock() + defer fake.signalCidMutex.Unlock() + fake.SignalCidStub = stub +} + +func (fake *FakeLocalMediaTrack) SignalCidReturns(result1 string) { + fake.signalCidMutex.Lock() + defer fake.signalCidMutex.Unlock() + fake.SignalCidStub = nil + fake.signalCidReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeLocalMediaTrack) 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 *FakeLocalMediaTrack) Source() livekit.TrackSource { + fake.sourceMutex.Lock() + ret, specificReturn := fake.sourceReturnsOnCall[len(fake.sourceArgsForCall)] + fake.sourceArgsForCall = append(fake.sourceArgsForCall, struct { + }{}) + stub := fake.SourceStub + fakeReturns := fake.sourceReturns + fake.recordInvocation("Source", []interface{}{}) + fake.sourceMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) SourceCallCount() int { + fake.sourceMutex.RLock() + defer fake.sourceMutex.RUnlock() + return len(fake.sourceArgsForCall) +} + +func (fake *FakeLocalMediaTrack) SourceCalls(stub func() livekit.TrackSource) { + fake.sourceMutex.Lock() + defer fake.sourceMutex.Unlock() + fake.SourceStub = stub +} + +func (fake *FakeLocalMediaTrack) SourceReturns(result1 livekit.TrackSource) { + fake.sourceMutex.Lock() + defer fake.sourceMutex.Unlock() + fake.SourceStub = nil + fake.sourceReturns = struct { + result1 livekit.TrackSource + }{result1} +} + +func (fake *FakeLocalMediaTrack) SourceReturnsOnCall(i int, result1 livekit.TrackSource) { + fake.sourceMutex.Lock() + defer fake.sourceMutex.Unlock() + fake.SourceStub = nil + if fake.sourceReturnsOnCall == nil { + fake.sourceReturnsOnCall = make(map[int]struct { + result1 livekit.TrackSource + }) + } + fake.sourceReturnsOnCall[i] = struct { + result1 livekit.TrackSource + }{result1} +} + +func (fake *FakeLocalMediaTrack) ToProto() *livekit.TrackInfo { + fake.toProtoMutex.Lock() + ret, specificReturn := fake.toProtoReturnsOnCall[len(fake.toProtoArgsForCall)] + fake.toProtoArgsForCall = append(fake.toProtoArgsForCall, struct { + }{}) + stub := fake.ToProtoStub + fakeReturns := fake.toProtoReturns + fake.recordInvocation("ToProto", []interface{}{}) + fake.toProtoMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalMediaTrack) ToProtoCallCount() int { + fake.toProtoMutex.RLock() + defer fake.toProtoMutex.RUnlock() + return len(fake.toProtoArgsForCall) +} + +func (fake *FakeLocalMediaTrack) ToProtoCalls(stub func() *livekit.TrackInfo) { + fake.toProtoMutex.Lock() + defer fake.toProtoMutex.Unlock() + fake.ToProtoStub = stub +} + +func (fake *FakeLocalMediaTrack) ToProtoReturns(result1 *livekit.TrackInfo) { + fake.toProtoMutex.Lock() + defer fake.toProtoMutex.Unlock() + fake.ToProtoStub = nil + fake.toProtoReturns = struct { + result1 *livekit.TrackInfo + }{result1} +} + +func (fake *FakeLocalMediaTrack) ToProtoReturnsOnCall(i int, result1 *livekit.TrackInfo) { + fake.toProtoMutex.Lock() + defer fake.toProtoMutex.Unlock() + fake.ToProtoStub = nil + if fake.toProtoReturnsOnCall == nil { + fake.toProtoReturnsOnCall = make(map[int]struct { + result1 *livekit.TrackInfo + }) + } + fake.toProtoReturnsOnCall[i] = struct { + result1 *livekit.TrackInfo + }{result1} +} + +func (fake *FakeLocalMediaTrack) UpdateVideoLayers(arg1 []*livekit.VideoLayer) { + var arg1Copy []*livekit.VideoLayer + if arg1 != nil { + arg1Copy = make([]*livekit.VideoLayer, len(arg1)) + copy(arg1Copy, arg1) + } + fake.updateVideoLayersMutex.Lock() + fake.updateVideoLayersArgsForCall = append(fake.updateVideoLayersArgsForCall, struct { + arg1 []*livekit.VideoLayer + }{arg1Copy}) + stub := fake.UpdateVideoLayersStub + fake.recordInvocation("UpdateVideoLayers", []interface{}{arg1Copy}) + fake.updateVideoLayersMutex.Unlock() + if stub != nil { + fake.UpdateVideoLayersStub(arg1) + } +} + +func (fake *FakeLocalMediaTrack) UpdateVideoLayersCallCount() int { + fake.updateVideoLayersMutex.RLock() + defer fake.updateVideoLayersMutex.RUnlock() + return len(fake.updateVideoLayersArgsForCall) +} + +func (fake *FakeLocalMediaTrack) UpdateVideoLayersCalls(stub func([]*livekit.VideoLayer)) { + fake.updateVideoLayersMutex.Lock() + defer fake.updateVideoLayersMutex.Unlock() + fake.UpdateVideoLayersStub = stub +} + +func (fake *FakeLocalMediaTrack) UpdateVideoLayersArgsForCall(i int) []*livekit.VideoLayer { + fake.updateVideoLayersMutex.RLock() + defer fake.updateVideoLayersMutex.RUnlock() + argsForCall := fake.updateVideoLayersArgsForCall[i] + return argsForCall.arg1 +} + func (fake *FakeLocalMediaTrack) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() + fake.addOnCloseMutex.RLock() + defer fake.addOnCloseMutex.RUnlock() + fake.addSubscriberMutex.RLock() + defer fake.addSubscriberMutex.RUnlock() + fake.getAllSubscriberIDsMutex.RLock() + defer fake.getAllSubscriberIDsMutex.RUnlock() + fake.getAudioLevelMutex.RLock() + defer fake.getAudioLevelMutex.RUnlock() + fake.getConnectionScoreMutex.RLock() + defer fake.getConnectionScoreMutex.RUnlock() + fake.getQualityForDimensionMutex.RLock() + defer fake.getQualityForDimensionMutex.RUnlock() + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + fake.isMutedMutex.RLock() + defer fake.isMutedMutex.RUnlock() + fake.isSimulcastMutex.RLock() + defer fake.isSimulcastMutex.RUnlock() + fake.isSubscriberMutex.RLock() + defer fake.isSubscriberMutex.RUnlock() + fake.kindMutex.RLock() + defer fake.kindMutex.RUnlock() + fake.nameMutex.RLock() + defer fake.nameMutex.RUnlock() + fake.notifySubscriberMaxQualityMutex.RLock() + defer fake.notifySubscriberMaxQualityMutex.RUnlock() + fake.notifySubscriberNodeMaxQualityMutex.RLock() + defer fake.notifySubscriberNodeMaxQualityMutex.RUnlock() fake.notifySubscriberNodeMediaLossMutex.RLock() defer fake.notifySubscriberNodeMediaLossMutex.RUnlock() + fake.onSubscribedMaxQualityChangeMutex.RLock() + defer fake.onSubscribedMaxQualityChangeMutex.RUnlock() + fake.publisherIDMutex.RLock() + defer fake.publisherIDMutex.RUnlock() + fake.publisherIdentityMutex.RLock() + defer fake.publisherIdentityMutex.RUnlock() + fake.receiverMutex.RLock() + defer fake.receiverMutex.RUnlock() + fake.removeAllSubscribersMutex.RLock() + defer fake.removeAllSubscribersMutex.RUnlock() + fake.removeSubscriberMutex.RLock() + defer fake.removeSubscriberMutex.RUnlock() + fake.revokeDisallowedSubscribersMutex.RLock() + defer fake.revokeDisallowedSubscribersMutex.RUnlock() + fake.sdpCidMutex.RLock() + defer fake.sdpCidMutex.RUnlock() + fake.setMutedMutex.RLock() + defer fake.setMutedMutex.RUnlock() + fake.signalCidMutex.RLock() + defer fake.signalCidMutex.RUnlock() + fake.sourceMutex.RLock() + defer fake.sourceMutex.RUnlock() + fake.toProtoMutex.RLock() + defer fake.toProtoMutex.RUnlock() + fake.updateVideoLayersMutex.RLock() + defer fake.updateVideoLayersMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/pkg/rtc/types/typesfakes/fake_local_participant.go b/pkg/rtc/types/typesfakes/fake_local_participant.go index 7be300433..599d474a9 100644 --- a/pkg/rtc/types/typesfakes/fake_local_participant.go +++ b/pkg/rtc/types/typesfakes/fake_local_participant.go @@ -35,6 +35,20 @@ type FakeLocalParticipant struct { addSubscribedTrackArgsForCall []struct { arg1 types.SubscribedTrack } + AddSubscriberStub func(types.LocalParticipant, types.AddSubscriberParams) (int, error) + addSubscriberMutex sync.RWMutex + addSubscriberArgsForCall []struct { + arg1 types.LocalParticipant + arg2 types.AddSubscriberParams + } + addSubscriberReturns struct { + result1 int + result2 error + } + addSubscriberReturnsOnCall map[int]struct { + result1 int + result2 error + } AddTrackStub func(*livekit.AddTrackRequest) addTrackMutex sync.RWMutex addTrackArgsForCall []struct { @@ -70,6 +84,17 @@ type FakeLocalParticipant struct { canSubscribeReturnsOnCall map[int]struct { result1 bool } + CloseStub func(bool) error + closeMutex sync.RWMutex + closeArgsForCall []struct { + arg1 bool + } + closeReturns struct { + result1 error + } + closeReturnsOnCall map[int]struct { + result1 error + } ConnectedAtStub func() time.Time connectedAtMutex sync.RWMutex connectedAtArgsForCall []struct { @@ -80,6 +105,16 @@ type FakeLocalParticipant struct { connectedAtReturnsOnCall map[int]struct { result1 time.Time } + DebugInfoStub func() map[string]interface{} + debugInfoMutex sync.RWMutex + debugInfoArgsForCall []struct { + } + debugInfoReturns struct { + result1 map[string]interface{} + } + debugInfoReturnsOnCall map[int]struct { + result1 map[string]interface{} + } GetAudioLevelStub func() (uint8, bool) getAudioLevelMutex sync.RWMutex getAudioLevelArgsForCall []struct { @@ -102,6 +137,27 @@ type FakeLocalParticipant struct { getConnectionQualityReturnsOnCall map[int]struct { result1 *livekit.ConnectionQualityInfo } + GetPublishedTrackStub func(livekit.TrackID) types.MediaTrack + getPublishedTrackMutex sync.RWMutex + getPublishedTrackArgsForCall []struct { + arg1 livekit.TrackID + } + getPublishedTrackReturns struct { + result1 types.MediaTrack + } + getPublishedTrackReturnsOnCall map[int]struct { + result1 types.MediaTrack + } + GetPublishedTracksStub func() []types.MediaTrack + getPublishedTracksMutex sync.RWMutex + getPublishedTracksArgsForCall []struct { + } + getPublishedTracksReturns struct { + result1 []types.MediaTrack + } + getPublishedTracksReturnsOnCall map[int]struct { + result1 []types.MediaTrack + } GetResponseSinkStub func() routing.MessageSink getResponseSinkMutex sync.RWMutex getResponseSinkArgsForCall []struct { @@ -167,6 +223,16 @@ type FakeLocalParticipant struct { result1 webrtc.SessionDescription result2 error } + HiddenStub func() bool + hiddenMutex sync.RWMutex + hiddenArgsForCall []struct { + } + hiddenReturns struct { + result1 bool + } + hiddenReturnsOnCall map[int]struct { + result1 bool + } ICERestartStub func() error iCERestartMutex sync.RWMutex iCERestartArgsForCall []struct { @@ -177,6 +243,26 @@ type FakeLocalParticipant struct { iCERestartReturnsOnCall map[int]struct { result1 error } + IDStub func() livekit.ParticipantID + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 livekit.ParticipantID + } + iDReturnsOnCall map[int]struct { + result1 livekit.ParticipantID + } + IdentityStub func() livekit.ParticipantIdentity + identityMutex sync.RWMutex + identityArgsForCall []struct { + } + identityReturns struct { + result1 livekit.ParticipantIdentity + } + identityReturnsOnCall map[int]struct { + result1 livekit.ParticipantIdentity + } IsReadyStub func() bool isReadyMutex sync.RWMutex isReadyArgsForCall []struct { @@ -211,30 +297,35 @@ type FakeLocalParticipant struct { negotiateMutex sync.RWMutex negotiateArgsForCall []struct { } - OnCloseStub func(func(types.Participant, map[livekit.TrackID]livekit.ParticipantID)) + OnCloseStub func(func(types.LocalParticipant, map[livekit.TrackID]livekit.ParticipantID)) onCloseMutex sync.RWMutex onCloseArgsForCall []struct { - arg1 func(types.Participant, map[livekit.TrackID]livekit.ParticipantID) + arg1 func(types.LocalParticipant, map[livekit.TrackID]livekit.ParticipantID) } - OnDataPacketStub func(func(types.Participant, *livekit.DataPacket)) + OnDataPacketStub func(func(types.LocalParticipant, *livekit.DataPacket)) onDataPacketMutex sync.RWMutex onDataPacketArgsForCall []struct { - arg1 func(types.Participant, *livekit.DataPacket) + arg1 func(types.LocalParticipant, *livekit.DataPacket) } - OnMetadataUpdateStub func(func(types.Participant)) + OnMetadataUpdateStub func(func(types.LocalParticipant)) onMetadataUpdateMutex sync.RWMutex onMetadataUpdateArgsForCall []struct { - arg1 func(types.Participant) + arg1 func(types.LocalParticipant) } - OnStateChangeStub func(func(p types.Participant, oldState livekit.ParticipantInfo_State)) + OnStateChangeStub func(func(p types.LocalParticipant, oldState livekit.ParticipantInfo_State)) onStateChangeMutex sync.RWMutex onStateChangeArgsForCall []struct { - arg1 func(p types.Participant, oldState livekit.ParticipantInfo_State) + arg1 func(p types.LocalParticipant, oldState livekit.ParticipantInfo_State) } - OnTrackUpdatedStub func(func(types.Participant, types.PublishedTrack)) + OnTrackPublishedStub func(func(types.LocalParticipant, types.MediaTrack)) + onTrackPublishedMutex sync.RWMutex + onTrackPublishedArgsForCall []struct { + arg1 func(types.LocalParticipant, types.MediaTrack) + } + OnTrackUpdatedStub func(func(types.LocalParticipant, types.MediaTrack)) onTrackUpdatedMutex sync.RWMutex onTrackUpdatedArgsForCall []struct { - arg1 func(types.Participant, types.PublishedTrack) + arg1 func(types.LocalParticipant, types.MediaTrack) } ProtocolVersionStub func() types.ProtocolVersion protocolVersionMutex sync.RWMutex @@ -251,6 +342,12 @@ type FakeLocalParticipant struct { removeSubscribedTrackArgsForCall []struct { arg1 types.SubscribedTrack } + RemoveSubscriberStub func(types.LocalParticipant, livekit.TrackID) + removeSubscriberMutex sync.RWMutex + removeSubscriberArgsForCall []struct { + arg1 types.LocalParticipant + arg2 livekit.TrackID + } SendConnectionQualityUpdateStub func(*livekit.ConnectionQualityUpdate) error sendConnectionQualityUpdateMutex sync.RWMutex sendConnectionQualityUpdateArgsForCall []struct { @@ -320,6 +417,11 @@ type FakeLocalParticipant struct { sendSpeakerUpdateReturnsOnCall map[int]struct { result1 error } + SetMetadataStub func(string) + setMetadataMutex sync.RWMutex + setMetadataArgsForCall []struct { + arg1 string + } SetMigrateStateStub func(types.MigrateState) setMigrateStateMutex sync.RWMutex setMigrateStateArgsForCall []struct { @@ -347,6 +449,10 @@ type FakeLocalParticipant struct { arg2 bool arg3 bool } + StartStub func() + startMutex sync.RWMutex + startArgsForCall []struct { + } StateStub func() livekit.ParticipantInfo_State stateMutex sync.RWMutex stateArgsForCall []struct { @@ -394,6 +500,16 @@ type FakeLocalParticipant struct { arg2 livekit.TrackID arg3 bool } + ToProtoStub func() *livekit.ParticipantInfo + toProtoMutex sync.RWMutex + toProtoArgsForCall []struct { + } + toProtoReturns struct { + result1 *livekit.ParticipantInfo + } + toProtoReturnsOnCall map[int]struct { + result1 *livekit.ParticipantInfo + } UpdateMediaLossStub func(string, livekit.TrackID, uint32) error updateMediaLossMutex sync.RWMutex updateMediaLossArgsForCall []struct { @@ -420,6 +536,29 @@ type FakeLocalParticipant struct { updateSubscribedQualityReturnsOnCall map[int]struct { result1 error } + UpdateSubscriptionPermissionsStub func(*livekit.UpdateSubscriptionPermissions, func(participantID livekit.ParticipantID) types.LocalParticipant) error + updateSubscriptionPermissionsMutex sync.RWMutex + updateSubscriptionPermissionsArgsForCall []struct { + arg1 *livekit.UpdateSubscriptionPermissions + arg2 func(participantID livekit.ParticipantID) types.LocalParticipant + } + updateSubscriptionPermissionsReturns struct { + result1 error + } + updateSubscriptionPermissionsReturnsOnCall map[int]struct { + result1 error + } + UpdateVideoLayersStub func(*livekit.UpdateVideoLayers) error + updateVideoLayersMutex sync.RWMutex + updateVideoLayersArgsForCall []struct { + arg1 *livekit.UpdateVideoLayers + } + updateVideoLayersReturns struct { + result1 error + } + updateVideoLayersReturnsOnCall map[int]struct { + result1 error + } invocations map[string][][]interface{} invocationsMutex sync.RWMutex } @@ -551,6 +690,71 @@ func (fake *FakeLocalParticipant) AddSubscribedTrackArgsForCall(i int) types.Sub return argsForCall.arg1 } +func (fake *FakeLocalParticipant) AddSubscriber(arg1 types.LocalParticipant, arg2 types.AddSubscriberParams) (int, error) { + fake.addSubscriberMutex.Lock() + ret, specificReturn := fake.addSubscriberReturnsOnCall[len(fake.addSubscriberArgsForCall)] + fake.addSubscriberArgsForCall = append(fake.addSubscriberArgsForCall, struct { + arg1 types.LocalParticipant + arg2 types.AddSubscriberParams + }{arg1, arg2}) + stub := fake.AddSubscriberStub + fakeReturns := fake.addSubscriberReturns + fake.recordInvocation("AddSubscriber", []interface{}{arg1, arg2}) + fake.addSubscriberMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeLocalParticipant) AddSubscriberCallCount() int { + fake.addSubscriberMutex.RLock() + defer fake.addSubscriberMutex.RUnlock() + return len(fake.addSubscriberArgsForCall) +} + +func (fake *FakeLocalParticipant) AddSubscriberCalls(stub func(types.LocalParticipant, types.AddSubscriberParams) (int, error)) { + fake.addSubscriberMutex.Lock() + defer fake.addSubscriberMutex.Unlock() + fake.AddSubscriberStub = stub +} + +func (fake *FakeLocalParticipant) AddSubscriberArgsForCall(i int) (types.LocalParticipant, types.AddSubscriberParams) { + fake.addSubscriberMutex.RLock() + defer fake.addSubscriberMutex.RUnlock() + argsForCall := fake.addSubscriberArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeLocalParticipant) AddSubscriberReturns(result1 int, result2 error) { + fake.addSubscriberMutex.Lock() + defer fake.addSubscriberMutex.Unlock() + fake.AddSubscriberStub = nil + fake.addSubscriberReturns = struct { + result1 int + result2 error + }{result1, result2} +} + +func (fake *FakeLocalParticipant) AddSubscriberReturnsOnCall(i int, result1 int, result2 error) { + fake.addSubscriberMutex.Lock() + defer fake.addSubscriberMutex.Unlock() + fake.AddSubscriberStub = nil + if fake.addSubscriberReturnsOnCall == nil { + fake.addSubscriberReturnsOnCall = make(map[int]struct { + result1 int + result2 error + }) + } + fake.addSubscriberReturnsOnCall[i] = struct { + result1 int + result2 error + }{result1, result2} +} + func (fake *FakeLocalParticipant) AddTrack(arg1 *livekit.AddTrackRequest) { fake.addTrackMutex.Lock() fake.addTrackArgsForCall = append(fake.addTrackArgsForCall, struct { @@ -742,6 +946,67 @@ func (fake *FakeLocalParticipant) CanSubscribeReturnsOnCall(i int, result1 bool) }{result1} } +func (fake *FakeLocalParticipant) Close(arg1 bool) error { + fake.closeMutex.Lock() + ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] + fake.closeArgsForCall = append(fake.closeArgsForCall, struct { + arg1 bool + }{arg1}) + stub := fake.CloseStub + fakeReturns := fake.closeReturns + fake.recordInvocation("Close", []interface{}{arg1}) + fake.closeMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) CloseCallCount() int { + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + return len(fake.closeArgsForCall) +} + +func (fake *FakeLocalParticipant) CloseCalls(stub func(bool) error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = stub +} + +func (fake *FakeLocalParticipant) CloseArgsForCall(i int) bool { + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + argsForCall := fake.closeArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) CloseReturns(result1 error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = nil + fake.closeReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) CloseReturnsOnCall(i int, result1 error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = nil + if fake.closeReturnsOnCall == nil { + fake.closeReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.closeReturnsOnCall[i] = struct { + result1 error + }{result1} +} + func (fake *FakeLocalParticipant) ConnectedAt() time.Time { fake.connectedAtMutex.Lock() ret, specificReturn := fake.connectedAtReturnsOnCall[len(fake.connectedAtArgsForCall)] @@ -795,6 +1060,59 @@ func (fake *FakeLocalParticipant) ConnectedAtReturnsOnCall(i int, result1 time.T }{result1} } +func (fake *FakeLocalParticipant) DebugInfo() map[string]interface{} { + fake.debugInfoMutex.Lock() + ret, specificReturn := fake.debugInfoReturnsOnCall[len(fake.debugInfoArgsForCall)] + fake.debugInfoArgsForCall = append(fake.debugInfoArgsForCall, struct { + }{}) + stub := fake.DebugInfoStub + fakeReturns := fake.debugInfoReturns + fake.recordInvocation("DebugInfo", []interface{}{}) + fake.debugInfoMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) DebugInfoCallCount() int { + fake.debugInfoMutex.RLock() + defer fake.debugInfoMutex.RUnlock() + return len(fake.debugInfoArgsForCall) +} + +func (fake *FakeLocalParticipant) DebugInfoCalls(stub func() map[string]interface{}) { + fake.debugInfoMutex.Lock() + defer fake.debugInfoMutex.Unlock() + fake.DebugInfoStub = stub +} + +func (fake *FakeLocalParticipant) DebugInfoReturns(result1 map[string]interface{}) { + fake.debugInfoMutex.Lock() + defer fake.debugInfoMutex.Unlock() + fake.DebugInfoStub = nil + fake.debugInfoReturns = struct { + result1 map[string]interface{} + }{result1} +} + +func (fake *FakeLocalParticipant) DebugInfoReturnsOnCall(i int, result1 map[string]interface{}) { + fake.debugInfoMutex.Lock() + defer fake.debugInfoMutex.Unlock() + fake.DebugInfoStub = nil + if fake.debugInfoReturnsOnCall == nil { + fake.debugInfoReturnsOnCall = make(map[int]struct { + result1 map[string]interface{} + }) + } + fake.debugInfoReturnsOnCall[i] = struct { + result1 map[string]interface{} + }{result1} +} + func (fake *FakeLocalParticipant) GetAudioLevel() (uint8, bool) { fake.getAudioLevelMutex.Lock() ret, specificReturn := fake.getAudioLevelReturnsOnCall[len(fake.getAudioLevelArgsForCall)] @@ -904,6 +1222,120 @@ func (fake *FakeLocalParticipant) GetConnectionQualityReturnsOnCall(i int, resul }{result1} } +func (fake *FakeLocalParticipant) GetPublishedTrack(arg1 livekit.TrackID) types.MediaTrack { + fake.getPublishedTrackMutex.Lock() + ret, specificReturn := fake.getPublishedTrackReturnsOnCall[len(fake.getPublishedTrackArgsForCall)] + fake.getPublishedTrackArgsForCall = append(fake.getPublishedTrackArgsForCall, struct { + arg1 livekit.TrackID + }{arg1}) + stub := fake.GetPublishedTrackStub + fakeReturns := fake.getPublishedTrackReturns + fake.recordInvocation("GetPublishedTrack", []interface{}{arg1}) + fake.getPublishedTrackMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) GetPublishedTrackCallCount() int { + fake.getPublishedTrackMutex.RLock() + defer fake.getPublishedTrackMutex.RUnlock() + return len(fake.getPublishedTrackArgsForCall) +} + +func (fake *FakeLocalParticipant) GetPublishedTrackCalls(stub func(livekit.TrackID) types.MediaTrack) { + fake.getPublishedTrackMutex.Lock() + defer fake.getPublishedTrackMutex.Unlock() + fake.GetPublishedTrackStub = stub +} + +func (fake *FakeLocalParticipant) GetPublishedTrackArgsForCall(i int) livekit.TrackID { + fake.getPublishedTrackMutex.RLock() + defer fake.getPublishedTrackMutex.RUnlock() + argsForCall := fake.getPublishedTrackArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) GetPublishedTrackReturns(result1 types.MediaTrack) { + fake.getPublishedTrackMutex.Lock() + defer fake.getPublishedTrackMutex.Unlock() + fake.GetPublishedTrackStub = nil + fake.getPublishedTrackReturns = struct { + result1 types.MediaTrack + }{result1} +} + +func (fake *FakeLocalParticipant) GetPublishedTrackReturnsOnCall(i int, result1 types.MediaTrack) { + fake.getPublishedTrackMutex.Lock() + defer fake.getPublishedTrackMutex.Unlock() + fake.GetPublishedTrackStub = nil + if fake.getPublishedTrackReturnsOnCall == nil { + fake.getPublishedTrackReturnsOnCall = make(map[int]struct { + result1 types.MediaTrack + }) + } + fake.getPublishedTrackReturnsOnCall[i] = struct { + result1 types.MediaTrack + }{result1} +} + +func (fake *FakeLocalParticipant) GetPublishedTracks() []types.MediaTrack { + fake.getPublishedTracksMutex.Lock() + ret, specificReturn := fake.getPublishedTracksReturnsOnCall[len(fake.getPublishedTracksArgsForCall)] + fake.getPublishedTracksArgsForCall = append(fake.getPublishedTracksArgsForCall, struct { + }{}) + stub := fake.GetPublishedTracksStub + fakeReturns := fake.getPublishedTracksReturns + fake.recordInvocation("GetPublishedTracks", []interface{}{}) + fake.getPublishedTracksMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) GetPublishedTracksCallCount() int { + fake.getPublishedTracksMutex.RLock() + defer fake.getPublishedTracksMutex.RUnlock() + return len(fake.getPublishedTracksArgsForCall) +} + +func (fake *FakeLocalParticipant) GetPublishedTracksCalls(stub func() []types.MediaTrack) { + fake.getPublishedTracksMutex.Lock() + defer fake.getPublishedTracksMutex.Unlock() + fake.GetPublishedTracksStub = stub +} + +func (fake *FakeLocalParticipant) GetPublishedTracksReturns(result1 []types.MediaTrack) { + fake.getPublishedTracksMutex.Lock() + defer fake.getPublishedTracksMutex.Unlock() + fake.GetPublishedTracksStub = nil + fake.getPublishedTracksReturns = struct { + result1 []types.MediaTrack + }{result1} +} + +func (fake *FakeLocalParticipant) GetPublishedTracksReturnsOnCall(i int, result1 []types.MediaTrack) { + fake.getPublishedTracksMutex.Lock() + defer fake.getPublishedTracksMutex.Unlock() + fake.GetPublishedTracksStub = nil + if fake.getPublishedTracksReturnsOnCall == nil { + fake.getPublishedTracksReturnsOnCall = make(map[int]struct { + result1 []types.MediaTrack + }) + } + fake.getPublishedTracksReturnsOnCall[i] = struct { + result1 []types.MediaTrack + }{result1} +} + func (fake *FakeLocalParticipant) GetResponseSink() routing.MessageSink { fake.getResponseSinkMutex.Lock() ret, specificReturn := fake.getResponseSinkReturnsOnCall[len(fake.getResponseSinkArgsForCall)] @@ -1249,6 +1681,59 @@ func (fake *FakeLocalParticipant) HandleOfferReturnsOnCall(i int, result1 webrtc }{result1, result2} } +func (fake *FakeLocalParticipant) Hidden() bool { + fake.hiddenMutex.Lock() + ret, specificReturn := fake.hiddenReturnsOnCall[len(fake.hiddenArgsForCall)] + fake.hiddenArgsForCall = append(fake.hiddenArgsForCall, struct { + }{}) + stub := fake.HiddenStub + fakeReturns := fake.hiddenReturns + fake.recordInvocation("Hidden", []interface{}{}) + fake.hiddenMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) HiddenCallCount() int { + fake.hiddenMutex.RLock() + defer fake.hiddenMutex.RUnlock() + return len(fake.hiddenArgsForCall) +} + +func (fake *FakeLocalParticipant) HiddenCalls(stub func() bool) { + fake.hiddenMutex.Lock() + defer fake.hiddenMutex.Unlock() + fake.HiddenStub = stub +} + +func (fake *FakeLocalParticipant) HiddenReturns(result1 bool) { + fake.hiddenMutex.Lock() + defer fake.hiddenMutex.Unlock() + fake.HiddenStub = nil + fake.hiddenReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) HiddenReturnsOnCall(i int, result1 bool) { + fake.hiddenMutex.Lock() + defer fake.hiddenMutex.Unlock() + fake.HiddenStub = nil + if fake.hiddenReturnsOnCall == nil { + fake.hiddenReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.hiddenReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + func (fake *FakeLocalParticipant) ICERestart() error { fake.iCERestartMutex.Lock() ret, specificReturn := fake.iCERestartReturnsOnCall[len(fake.iCERestartArgsForCall)] @@ -1302,6 +1787,112 @@ func (fake *FakeLocalParticipant) ICERestartReturnsOnCall(i int, result1 error) }{result1} } +func (fake *FakeLocalParticipant) ID() livekit.ParticipantID { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *FakeLocalParticipant) IDCalls(stub func() livekit.ParticipantID) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *FakeLocalParticipant) IDReturns(result1 livekit.ParticipantID) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 livekit.ParticipantID + }{result1} +} + +func (fake *FakeLocalParticipant) IDReturnsOnCall(i int, result1 livekit.ParticipantID) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 livekit.ParticipantID + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 livekit.ParticipantID + }{result1} +} + +func (fake *FakeLocalParticipant) Identity() livekit.ParticipantIdentity { + fake.identityMutex.Lock() + ret, specificReturn := fake.identityReturnsOnCall[len(fake.identityArgsForCall)] + fake.identityArgsForCall = append(fake.identityArgsForCall, struct { + }{}) + stub := fake.IdentityStub + fakeReturns := fake.identityReturns + fake.recordInvocation("Identity", []interface{}{}) + fake.identityMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) IdentityCallCount() int { + fake.identityMutex.RLock() + defer fake.identityMutex.RUnlock() + return len(fake.identityArgsForCall) +} + +func (fake *FakeLocalParticipant) IdentityCalls(stub func() livekit.ParticipantIdentity) { + fake.identityMutex.Lock() + defer fake.identityMutex.Unlock() + fake.IdentityStub = stub +} + +func (fake *FakeLocalParticipant) IdentityReturns(result1 livekit.ParticipantIdentity) { + fake.identityMutex.Lock() + defer fake.identityMutex.Unlock() + fake.IdentityStub = nil + fake.identityReturns = struct { + result1 livekit.ParticipantIdentity + }{result1} +} + +func (fake *FakeLocalParticipant) IdentityReturnsOnCall(i int, result1 livekit.ParticipantIdentity) { + fake.identityMutex.Lock() + defer fake.identityMutex.Unlock() + fake.IdentityStub = nil + if fake.identityReturnsOnCall == nil { + fake.identityReturnsOnCall = make(map[int]struct { + result1 livekit.ParticipantIdentity + }) + } + fake.identityReturnsOnCall[i] = struct { + result1 livekit.ParticipantIdentity + }{result1} +} + func (fake *FakeLocalParticipant) IsReady() bool { fake.isReadyMutex.Lock() ret, specificReturn := fake.isReadyReturnsOnCall[len(fake.isReadyArgsForCall)] @@ -1485,10 +2076,10 @@ func (fake *FakeLocalParticipant) NegotiateCalls(stub func()) { fake.NegotiateStub = stub } -func (fake *FakeLocalParticipant) OnClose(arg1 func(types.Participant, map[livekit.TrackID]livekit.ParticipantID)) { +func (fake *FakeLocalParticipant) OnClose(arg1 func(types.LocalParticipant, map[livekit.TrackID]livekit.ParticipantID)) { fake.onCloseMutex.Lock() fake.onCloseArgsForCall = append(fake.onCloseArgsForCall, struct { - arg1 func(types.Participant, map[livekit.TrackID]livekit.ParticipantID) + arg1 func(types.LocalParticipant, map[livekit.TrackID]livekit.ParticipantID) }{arg1}) stub := fake.OnCloseStub fake.recordInvocation("OnClose", []interface{}{arg1}) @@ -1504,23 +2095,23 @@ func (fake *FakeLocalParticipant) OnCloseCallCount() int { return len(fake.onCloseArgsForCall) } -func (fake *FakeLocalParticipant) OnCloseCalls(stub func(func(types.Participant, map[livekit.TrackID]livekit.ParticipantID))) { +func (fake *FakeLocalParticipant) OnCloseCalls(stub func(func(types.LocalParticipant, 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) { +func (fake *FakeLocalParticipant) OnCloseArgsForCall(i int) func(types.LocalParticipant, 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)) { +func (fake *FakeLocalParticipant) OnDataPacket(arg1 func(types.LocalParticipant, *livekit.DataPacket)) { fake.onDataPacketMutex.Lock() fake.onDataPacketArgsForCall = append(fake.onDataPacketArgsForCall, struct { - arg1 func(types.Participant, *livekit.DataPacket) + arg1 func(types.LocalParticipant, *livekit.DataPacket) }{arg1}) stub := fake.OnDataPacketStub fake.recordInvocation("OnDataPacket", []interface{}{arg1}) @@ -1536,23 +2127,23 @@ func (fake *FakeLocalParticipant) OnDataPacketCallCount() int { return len(fake.onDataPacketArgsForCall) } -func (fake *FakeLocalParticipant) OnDataPacketCalls(stub func(func(types.Participant, *livekit.DataPacket))) { +func (fake *FakeLocalParticipant) OnDataPacketCalls(stub func(func(types.LocalParticipant, *livekit.DataPacket))) { fake.onDataPacketMutex.Lock() defer fake.onDataPacketMutex.Unlock() fake.OnDataPacketStub = stub } -func (fake *FakeLocalParticipant) OnDataPacketArgsForCall(i int) func(types.Participant, *livekit.DataPacket) { +func (fake *FakeLocalParticipant) OnDataPacketArgsForCall(i int) func(types.LocalParticipant, *livekit.DataPacket) { fake.onDataPacketMutex.RLock() defer fake.onDataPacketMutex.RUnlock() argsForCall := fake.onDataPacketArgsForCall[i] return argsForCall.arg1 } -func (fake *FakeLocalParticipant) OnMetadataUpdate(arg1 func(types.Participant)) { +func (fake *FakeLocalParticipant) OnMetadataUpdate(arg1 func(types.LocalParticipant)) { fake.onMetadataUpdateMutex.Lock() fake.onMetadataUpdateArgsForCall = append(fake.onMetadataUpdateArgsForCall, struct { - arg1 func(types.Participant) + arg1 func(types.LocalParticipant) }{arg1}) stub := fake.OnMetadataUpdateStub fake.recordInvocation("OnMetadataUpdate", []interface{}{arg1}) @@ -1568,23 +2159,23 @@ func (fake *FakeLocalParticipant) OnMetadataUpdateCallCount() int { return len(fake.onMetadataUpdateArgsForCall) } -func (fake *FakeLocalParticipant) OnMetadataUpdateCalls(stub func(func(types.Participant))) { +func (fake *FakeLocalParticipant) OnMetadataUpdateCalls(stub func(func(types.LocalParticipant))) { fake.onMetadataUpdateMutex.Lock() defer fake.onMetadataUpdateMutex.Unlock() fake.OnMetadataUpdateStub = stub } -func (fake *FakeLocalParticipant) OnMetadataUpdateArgsForCall(i int) func(types.Participant) { +func (fake *FakeLocalParticipant) OnMetadataUpdateArgsForCall(i int) func(types.LocalParticipant) { 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)) { +func (fake *FakeLocalParticipant) OnStateChange(arg1 func(p types.LocalParticipant, oldState livekit.ParticipantInfo_State)) { fake.onStateChangeMutex.Lock() fake.onStateChangeArgsForCall = append(fake.onStateChangeArgsForCall, struct { - arg1 func(p types.Participant, oldState livekit.ParticipantInfo_State) + arg1 func(p types.LocalParticipant, oldState livekit.ParticipantInfo_State) }{arg1}) stub := fake.OnStateChangeStub fake.recordInvocation("OnStateChange", []interface{}{arg1}) @@ -1600,23 +2191,55 @@ func (fake *FakeLocalParticipant) OnStateChangeCallCount() int { return len(fake.onStateChangeArgsForCall) } -func (fake *FakeLocalParticipant) OnStateChangeCalls(stub func(func(p types.Participant, oldState livekit.ParticipantInfo_State))) { +func (fake *FakeLocalParticipant) OnStateChangeCalls(stub func(func(p types.LocalParticipant, 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) { +func (fake *FakeLocalParticipant) OnStateChangeArgsForCall(i int) func(p types.LocalParticipant, 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)) { +func (fake *FakeLocalParticipant) OnTrackPublished(arg1 func(types.LocalParticipant, types.MediaTrack)) { + fake.onTrackPublishedMutex.Lock() + fake.onTrackPublishedArgsForCall = append(fake.onTrackPublishedArgsForCall, struct { + arg1 func(types.LocalParticipant, types.MediaTrack) + }{arg1}) + stub := fake.OnTrackPublishedStub + fake.recordInvocation("OnTrackPublished", []interface{}{arg1}) + fake.onTrackPublishedMutex.Unlock() + if stub != nil { + fake.OnTrackPublishedStub(arg1) + } +} + +func (fake *FakeLocalParticipant) OnTrackPublishedCallCount() int { + fake.onTrackPublishedMutex.RLock() + defer fake.onTrackPublishedMutex.RUnlock() + return len(fake.onTrackPublishedArgsForCall) +} + +func (fake *FakeLocalParticipant) OnTrackPublishedCalls(stub func(func(types.LocalParticipant, types.MediaTrack))) { + fake.onTrackPublishedMutex.Lock() + defer fake.onTrackPublishedMutex.Unlock() + fake.OnTrackPublishedStub = stub +} + +func (fake *FakeLocalParticipant) OnTrackPublishedArgsForCall(i int) func(types.LocalParticipant, types.MediaTrack) { + fake.onTrackPublishedMutex.RLock() + defer fake.onTrackPublishedMutex.RUnlock() + argsForCall := fake.onTrackPublishedArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) OnTrackUpdated(arg1 func(types.LocalParticipant, types.MediaTrack)) { fake.onTrackUpdatedMutex.Lock() fake.onTrackUpdatedArgsForCall = append(fake.onTrackUpdatedArgsForCall, struct { - arg1 func(types.Participant, types.PublishedTrack) + arg1 func(types.LocalParticipant, types.MediaTrack) }{arg1}) stub := fake.OnTrackUpdatedStub fake.recordInvocation("OnTrackUpdated", []interface{}{arg1}) @@ -1632,13 +2255,13 @@ func (fake *FakeLocalParticipant) OnTrackUpdatedCallCount() int { return len(fake.onTrackUpdatedArgsForCall) } -func (fake *FakeLocalParticipant) OnTrackUpdatedCalls(stub func(func(types.Participant, types.PublishedTrack))) { +func (fake *FakeLocalParticipant) OnTrackUpdatedCalls(stub func(func(types.LocalParticipant, types.MediaTrack))) { fake.onTrackUpdatedMutex.Lock() defer fake.onTrackUpdatedMutex.Unlock() fake.OnTrackUpdatedStub = stub } -func (fake *FakeLocalParticipant) OnTrackUpdatedArgsForCall(i int) func(types.Participant, types.PublishedTrack) { +func (fake *FakeLocalParticipant) OnTrackUpdatedArgsForCall(i int) func(types.LocalParticipant, types.MediaTrack) { fake.onTrackUpdatedMutex.RLock() defer fake.onTrackUpdatedMutex.RUnlock() argsForCall := fake.onTrackUpdatedArgsForCall[i] @@ -1730,6 +2353,39 @@ func (fake *FakeLocalParticipant) RemoveSubscribedTrackArgsForCall(i int) types. return argsForCall.arg1 } +func (fake *FakeLocalParticipant) RemoveSubscriber(arg1 types.LocalParticipant, arg2 livekit.TrackID) { + fake.removeSubscriberMutex.Lock() + fake.removeSubscriberArgsForCall = append(fake.removeSubscriberArgsForCall, struct { + arg1 types.LocalParticipant + arg2 livekit.TrackID + }{arg1, arg2}) + stub := fake.RemoveSubscriberStub + fake.recordInvocation("RemoveSubscriber", []interface{}{arg1, arg2}) + fake.removeSubscriberMutex.Unlock() + if stub != nil { + fake.RemoveSubscriberStub(arg1, arg2) + } +} + +func (fake *FakeLocalParticipant) RemoveSubscriberCallCount() int { + fake.removeSubscriberMutex.RLock() + defer fake.removeSubscriberMutex.RUnlock() + return len(fake.removeSubscriberArgsForCall) +} + +func (fake *FakeLocalParticipant) RemoveSubscriberCalls(stub func(types.LocalParticipant, livekit.TrackID)) { + fake.removeSubscriberMutex.Lock() + defer fake.removeSubscriberMutex.Unlock() + fake.RemoveSubscriberStub = stub +} + +func (fake *FakeLocalParticipant) RemoveSubscriberArgsForCall(i int) (types.LocalParticipant, livekit.TrackID) { + fake.removeSubscriberMutex.RLock() + defer fake.removeSubscriberMutex.RUnlock() + argsForCall := fake.removeSubscriberArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + func (fake *FakeLocalParticipant) SendConnectionQualityUpdate(arg1 *livekit.ConnectionQualityUpdate) error { fake.sendConnectionQualityUpdateMutex.Lock() ret, specificReturn := fake.sendConnectionQualityUpdateReturnsOnCall[len(fake.sendConnectionQualityUpdateArgsForCall)] @@ -2119,6 +2775,38 @@ func (fake *FakeLocalParticipant) SendSpeakerUpdateReturnsOnCall(i int, result1 }{result1} } +func (fake *FakeLocalParticipant) SetMetadata(arg1 string) { + fake.setMetadataMutex.Lock() + fake.setMetadataArgsForCall = append(fake.setMetadataArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.SetMetadataStub + fake.recordInvocation("SetMetadata", []interface{}{arg1}) + fake.setMetadataMutex.Unlock() + if stub != nil { + fake.SetMetadataStub(arg1) + } +} + +func (fake *FakeLocalParticipant) SetMetadataCallCount() int { + fake.setMetadataMutex.RLock() + defer fake.setMetadataMutex.RUnlock() + return len(fake.setMetadataArgsForCall) +} + +func (fake *FakeLocalParticipant) SetMetadataCalls(stub func(string)) { + fake.setMetadataMutex.Lock() + defer fake.setMetadataMutex.Unlock() + fake.SetMetadataStub = stub +} + +func (fake *FakeLocalParticipant) SetMetadataArgsForCall(i int) string { + fake.setMetadataMutex.RLock() + defer fake.setMetadataMutex.RUnlock() + argsForCall := fake.setMetadataArgsForCall[i] + return argsForCall.arg1 +} + func (fake *FakeLocalParticipant) SetMigrateState(arg1 types.MigrateState) { fake.setMigrateStateMutex.Lock() fake.setMigrateStateArgsForCall = append(fake.setMigrateStateArgsForCall, struct { @@ -2281,6 +2969,30 @@ func (fake *FakeLocalParticipant) SetTrackMutedArgsForCall(i int) (livekit.Track return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 } +func (fake *FakeLocalParticipant) Start() { + fake.startMutex.Lock() + fake.startArgsForCall = append(fake.startArgsForCall, struct { + }{}) + stub := fake.StartStub + fake.recordInvocation("Start", []interface{}{}) + fake.startMutex.Unlock() + if stub != nil { + fake.StartStub() + } +} + +func (fake *FakeLocalParticipant) StartCallCount() int { + fake.startMutex.RLock() + defer fake.startMutex.RUnlock() + return len(fake.startArgsForCall) +} + +func (fake *FakeLocalParticipant) StartCalls(stub func()) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = stub +} + func (fake *FakeLocalParticipant) State() livekit.ParticipantInfo_State { fake.stateMutex.Lock() ret, specificReturn := fake.stateReturnsOnCall[len(fake.stateArgsForCall)] @@ -2527,6 +3239,59 @@ func (fake *FakeLocalParticipant) SubscriptionPermissionUpdateArgsForCall(i int) return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 } +func (fake *FakeLocalParticipant) ToProto() *livekit.ParticipantInfo { + fake.toProtoMutex.Lock() + ret, specificReturn := fake.toProtoReturnsOnCall[len(fake.toProtoArgsForCall)] + fake.toProtoArgsForCall = append(fake.toProtoArgsForCall, struct { + }{}) + stub := fake.ToProtoStub + fakeReturns := fake.toProtoReturns + fake.recordInvocation("ToProto", []interface{}{}) + fake.toProtoMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) ToProtoCallCount() int { + fake.toProtoMutex.RLock() + defer fake.toProtoMutex.RUnlock() + return len(fake.toProtoArgsForCall) +} + +func (fake *FakeLocalParticipant) ToProtoCalls(stub func() *livekit.ParticipantInfo) { + fake.toProtoMutex.Lock() + defer fake.toProtoMutex.Unlock() + fake.ToProtoStub = stub +} + +func (fake *FakeLocalParticipant) ToProtoReturns(result1 *livekit.ParticipantInfo) { + fake.toProtoMutex.Lock() + defer fake.toProtoMutex.Unlock() + fake.ToProtoStub = nil + fake.toProtoReturns = struct { + result1 *livekit.ParticipantInfo + }{result1} +} + +func (fake *FakeLocalParticipant) ToProtoReturnsOnCall(i int, result1 *livekit.ParticipantInfo) { + fake.toProtoMutex.Lock() + defer fake.toProtoMutex.Unlock() + fake.ToProtoStub = nil + if fake.toProtoReturnsOnCall == nil { + fake.toProtoReturnsOnCall = make(map[int]struct { + result1 *livekit.ParticipantInfo + }) + } + fake.toProtoReturnsOnCall[i] = struct { + result1 *livekit.ParticipantInfo + }{result1} +} + func (fake *FakeLocalParticipant) UpdateMediaLoss(arg1 string, arg2 livekit.TrackID, arg3 uint32) error { fake.updateMediaLossMutex.Lock() ret, specificReturn := fake.updateMediaLossReturnsOnCall[len(fake.updateMediaLossArgsForCall)] @@ -2653,6 +3418,129 @@ func (fake *FakeLocalParticipant) UpdateSubscribedQualityReturnsOnCall(i int, re }{result1} } +func (fake *FakeLocalParticipant) UpdateSubscriptionPermissions(arg1 *livekit.UpdateSubscriptionPermissions, arg2 func(participantID livekit.ParticipantID) types.LocalParticipant) error { + fake.updateSubscriptionPermissionsMutex.Lock() + ret, specificReturn := fake.updateSubscriptionPermissionsReturnsOnCall[len(fake.updateSubscriptionPermissionsArgsForCall)] + fake.updateSubscriptionPermissionsArgsForCall = append(fake.updateSubscriptionPermissionsArgsForCall, struct { + arg1 *livekit.UpdateSubscriptionPermissions + arg2 func(participantID livekit.ParticipantID) types.LocalParticipant + }{arg1, arg2}) + stub := fake.UpdateSubscriptionPermissionsStub + fakeReturns := fake.updateSubscriptionPermissionsReturns + fake.recordInvocation("UpdateSubscriptionPermissions", []interface{}{arg1, arg2}) + fake.updateSubscriptionPermissionsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) UpdateSubscriptionPermissionsCallCount() int { + fake.updateSubscriptionPermissionsMutex.RLock() + defer fake.updateSubscriptionPermissionsMutex.RUnlock() + return len(fake.updateSubscriptionPermissionsArgsForCall) +} + +func (fake *FakeLocalParticipant) UpdateSubscriptionPermissionsCalls(stub func(*livekit.UpdateSubscriptionPermissions, func(participantID livekit.ParticipantID) types.LocalParticipant) error) { + fake.updateSubscriptionPermissionsMutex.Lock() + defer fake.updateSubscriptionPermissionsMutex.Unlock() + fake.UpdateSubscriptionPermissionsStub = stub +} + +func (fake *FakeLocalParticipant) UpdateSubscriptionPermissionsArgsForCall(i int) (*livekit.UpdateSubscriptionPermissions, func(participantID livekit.ParticipantID) types.LocalParticipant) { + fake.updateSubscriptionPermissionsMutex.RLock() + defer fake.updateSubscriptionPermissionsMutex.RUnlock() + argsForCall := fake.updateSubscriptionPermissionsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeLocalParticipant) UpdateSubscriptionPermissionsReturns(result1 error) { + fake.updateSubscriptionPermissionsMutex.Lock() + defer fake.updateSubscriptionPermissionsMutex.Unlock() + fake.UpdateSubscriptionPermissionsStub = nil + fake.updateSubscriptionPermissionsReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) UpdateSubscriptionPermissionsReturnsOnCall(i int, result1 error) { + fake.updateSubscriptionPermissionsMutex.Lock() + defer fake.updateSubscriptionPermissionsMutex.Unlock() + fake.UpdateSubscriptionPermissionsStub = nil + if fake.updateSubscriptionPermissionsReturnsOnCall == nil { + fake.updateSubscriptionPermissionsReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateSubscriptionPermissionsReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) UpdateVideoLayers(arg1 *livekit.UpdateVideoLayers) error { + fake.updateVideoLayersMutex.Lock() + ret, specificReturn := fake.updateVideoLayersReturnsOnCall[len(fake.updateVideoLayersArgsForCall)] + fake.updateVideoLayersArgsForCall = append(fake.updateVideoLayersArgsForCall, struct { + arg1 *livekit.UpdateVideoLayers + }{arg1}) + stub := fake.UpdateVideoLayersStub + fakeReturns := fake.updateVideoLayersReturns + fake.recordInvocation("UpdateVideoLayers", []interface{}{arg1}) + fake.updateVideoLayersMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) UpdateVideoLayersCallCount() int { + fake.updateVideoLayersMutex.RLock() + defer fake.updateVideoLayersMutex.RUnlock() + return len(fake.updateVideoLayersArgsForCall) +} + +func (fake *FakeLocalParticipant) UpdateVideoLayersCalls(stub func(*livekit.UpdateVideoLayers) error) { + fake.updateVideoLayersMutex.Lock() + defer fake.updateVideoLayersMutex.Unlock() + fake.UpdateVideoLayersStub = stub +} + +func (fake *FakeLocalParticipant) UpdateVideoLayersArgsForCall(i int) *livekit.UpdateVideoLayers { + fake.updateVideoLayersMutex.RLock() + defer fake.updateVideoLayersMutex.RUnlock() + argsForCall := fake.updateVideoLayersArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLocalParticipant) UpdateVideoLayersReturns(result1 error) { + fake.updateVideoLayersMutex.Lock() + defer fake.updateVideoLayersMutex.Unlock() + fake.UpdateVideoLayersStub = nil + fake.updateVideoLayersReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeLocalParticipant) UpdateVideoLayersReturnsOnCall(i int, result1 error) { + fake.updateVideoLayersMutex.Lock() + defer fake.updateVideoLayersMutex.Unlock() + fake.UpdateVideoLayersStub = nil + if fake.updateVideoLayersReturnsOnCall == nil { + fake.updateVideoLayersReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateVideoLayersReturnsOnCall[i] = struct { + result1 error + }{result1} +} + func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() @@ -2662,6 +3550,8 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { defer fake.addMigratedTrackMutex.RUnlock() fake.addSubscribedTrackMutex.RLock() defer fake.addSubscribedTrackMutex.RUnlock() + fake.addSubscriberMutex.RLock() + defer fake.addSubscriberMutex.RUnlock() fake.addTrackMutex.RLock() defer fake.addTrackMutex.RUnlock() fake.canPublishMutex.RLock() @@ -2670,12 +3560,20 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { defer fake.canPublishDataMutex.RUnlock() fake.canSubscribeMutex.RLock() defer fake.canSubscribeMutex.RUnlock() + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() fake.connectedAtMutex.RLock() defer fake.connectedAtMutex.RUnlock() + fake.debugInfoMutex.RLock() + defer fake.debugInfoMutex.RUnlock() fake.getAudioLevelMutex.RLock() defer fake.getAudioLevelMutex.RUnlock() fake.getConnectionQualityMutex.RLock() defer fake.getConnectionQualityMutex.RUnlock() + fake.getPublishedTrackMutex.RLock() + defer fake.getPublishedTrackMutex.RUnlock() + fake.getPublishedTracksMutex.RLock() + defer fake.getPublishedTracksMutex.RUnlock() fake.getResponseSinkMutex.RLock() defer fake.getResponseSinkMutex.RUnlock() fake.getSubscribedParticipantsMutex.RLock() @@ -2688,8 +3586,14 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { defer fake.handleAnswerMutex.RUnlock() fake.handleOfferMutex.RLock() defer fake.handleOfferMutex.RUnlock() + fake.hiddenMutex.RLock() + defer fake.hiddenMutex.RUnlock() fake.iCERestartMutex.RLock() defer fake.iCERestartMutex.RUnlock() + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + fake.identityMutex.RLock() + defer fake.identityMutex.RUnlock() fake.isReadyMutex.RLock() defer fake.isReadyMutex.RUnlock() fake.isRecorderMutex.RLock() @@ -2706,12 +3610,16 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { defer fake.onMetadataUpdateMutex.RUnlock() fake.onStateChangeMutex.RLock() defer fake.onStateChangeMutex.RUnlock() + fake.onTrackPublishedMutex.RLock() + defer fake.onTrackPublishedMutex.RUnlock() fake.onTrackUpdatedMutex.RLock() defer fake.onTrackUpdatedMutex.RUnlock() fake.protocolVersionMutex.RLock() defer fake.protocolVersionMutex.RUnlock() fake.removeSubscribedTrackMutex.RLock() defer fake.removeSubscribedTrackMutex.RUnlock() + fake.removeSubscriberMutex.RLock() + defer fake.removeSubscriberMutex.RUnlock() fake.sendConnectionQualityUpdateMutex.RLock() defer fake.sendConnectionQualityUpdateMutex.RUnlock() fake.sendDataPacketMutex.RLock() @@ -2724,6 +3632,8 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { defer fake.sendRoomUpdateMutex.RUnlock() fake.sendSpeakerUpdateMutex.RLock() defer fake.sendSpeakerUpdateMutex.RUnlock() + fake.setMetadataMutex.RLock() + defer fake.setMetadataMutex.RUnlock() fake.setMigrateStateMutex.RLock() defer fake.setMigrateStateMutex.RUnlock() fake.setPermissionMutex.RLock() @@ -2734,6 +3644,8 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { defer fake.setResponseSinkMutex.RUnlock() fake.setTrackMutedMutex.RLock() defer fake.setTrackMutedMutex.RUnlock() + fake.startMutex.RLock() + defer fake.startMutex.RUnlock() fake.stateMutex.RLock() defer fake.stateMutex.RUnlock() fake.subscriberAsPrimaryMutex.RLock() @@ -2744,10 +3656,16 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { defer fake.subscriberPCMutex.RUnlock() fake.subscriptionPermissionUpdateMutex.RLock() defer fake.subscriptionPermissionUpdateMutex.RUnlock() + fake.toProtoMutex.RLock() + defer fake.toProtoMutex.RUnlock() fake.updateMediaLossMutex.RLock() defer fake.updateMediaLossMutex.RUnlock() fake.updateSubscribedQualityMutex.RLock() defer fake.updateSubscribedQualityMutex.RUnlock() + fake.updateSubscriptionPermissionsMutex.RLock() + defer fake.updateSubscriptionPermissionsMutex.RUnlock() + fake.updateVideoLayersMutex.RLock() + defer fake.updateVideoLayersMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/pkg/rtc/types/typesfakes/fake_local_published_track.go b/pkg/rtc/types/typesfakes/fake_local_published_track.go deleted file mode 100644 index 97675484b..000000000 --- a/pkg/rtc/types/typesfakes/fake_local_published_track.go +++ /dev/null @@ -1,302 +0,0 @@ -// 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_media_track.go b/pkg/rtc/types/typesfakes/fake_media_track.go index f0824b835..244332347 100644 --- a/pkg/rtc/types/typesfakes/fake_media_track.go +++ b/pkg/rtc/types/typesfakes/fake_media_track.go @@ -5,14 +5,20 @@ import ( "sync" "github.com/livekit/livekit-server/pkg/rtc/types" + "github.com/livekit/livekit-server/pkg/sfu" "github.com/livekit/protocol/livekit" ) type FakeMediaTrack struct { - AddSubscriberStub func(types.Participant) error + AddOnCloseStub func(func()) + addOnCloseMutex sync.RWMutex + addOnCloseArgsForCall []struct { + arg1 func() + } + AddSubscriberStub func(types.LocalParticipant) error addSubscriberMutex sync.RWMutex addSubscriberArgsForCall []struct { - arg1 types.Participant + arg1 types.LocalParticipant } addSubscriberReturns struct { result1 error @@ -115,11 +121,10 @@ type FakeMediaTrack struct { arg1 string arg2 livekit.VideoQuality } - NotifySubscriberNodeMediaLossStub func(string, uint8) - notifySubscriberNodeMediaLossMutex sync.RWMutex - notifySubscriberNodeMediaLossArgsForCall []struct { - arg1 string - arg2 uint8 + OnSubscribedMaxQualityChangeStub func(func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error) + onSubscribedMaxQualityChangeMutex sync.RWMutex + onSubscribedMaxQualityChangeArgsForCall []struct { + arg1 func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error } PublisherIDStub func() livekit.ParticipantID publisherIDMutex sync.RWMutex @@ -141,6 +146,16 @@ type FakeMediaTrack struct { publisherIdentityReturnsOnCall map[int]struct { result1 livekit.ParticipantIdentity } + ReceiverStub func() sfu.TrackReceiver + receiverMutex sync.RWMutex + receiverArgsForCall []struct { + } + receiverReturns struct { + result1 sfu.TrackReceiver + } + receiverReturnsOnCall map[int]struct { + result1 sfu.TrackReceiver + } RemoveAllSubscribersStub func() removeAllSubscribersMutex sync.RWMutex removeAllSubscribersArgsForCall []struct { @@ -195,11 +210,43 @@ type FakeMediaTrack struct { invocationsMutex sync.RWMutex } -func (fake *FakeMediaTrack) AddSubscriber(arg1 types.Participant) error { +func (fake *FakeMediaTrack) AddOnClose(arg1 func()) { + fake.addOnCloseMutex.Lock() + fake.addOnCloseArgsForCall = append(fake.addOnCloseArgsForCall, struct { + arg1 func() + }{arg1}) + stub := fake.AddOnCloseStub + fake.recordInvocation("AddOnClose", []interface{}{arg1}) + fake.addOnCloseMutex.Unlock() + if stub != nil { + fake.AddOnCloseStub(arg1) + } +} + +func (fake *FakeMediaTrack) AddOnCloseCallCount() int { + fake.addOnCloseMutex.RLock() + defer fake.addOnCloseMutex.RUnlock() + return len(fake.addOnCloseArgsForCall) +} + +func (fake *FakeMediaTrack) AddOnCloseCalls(stub func(func())) { + fake.addOnCloseMutex.Lock() + defer fake.addOnCloseMutex.Unlock() + fake.AddOnCloseStub = stub +} + +func (fake *FakeMediaTrack) AddOnCloseArgsForCall(i int) func() { + fake.addOnCloseMutex.RLock() + defer fake.addOnCloseMutex.RUnlock() + argsForCall := fake.addOnCloseArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeMediaTrack) AddSubscriber(arg1 types.LocalParticipant) error { fake.addSubscriberMutex.Lock() ret, specificReturn := fake.addSubscriberReturnsOnCall[len(fake.addSubscriberArgsForCall)] fake.addSubscriberArgsForCall = append(fake.addSubscriberArgsForCall, struct { - arg1 types.Participant + arg1 types.LocalParticipant }{arg1}) stub := fake.AddSubscriberStub fakeReturns := fake.addSubscriberReturns @@ -220,13 +267,13 @@ func (fake *FakeMediaTrack) AddSubscriberCallCount() int { return len(fake.addSubscriberArgsForCall) } -func (fake *FakeMediaTrack) AddSubscriberCalls(stub func(types.Participant) error) { +func (fake *FakeMediaTrack) AddSubscriberCalls(stub func(types.LocalParticipant) error) { fake.addSubscriberMutex.Lock() defer fake.addSubscriberMutex.Unlock() fake.AddSubscriberStub = stub } -func (fake *FakeMediaTrack) AddSubscriberArgsForCall(i int) types.Participant { +func (fake *FakeMediaTrack) AddSubscriberArgsForCall(i int) types.LocalParticipant { fake.addSubscriberMutex.RLock() defer fake.addSubscriberMutex.RUnlock() argsForCall := fake.addSubscriberArgsForCall[i] @@ -763,37 +810,36 @@ func (fake *FakeMediaTrack) NotifySubscriberNodeMaxQualityArgsForCall(i int) (st return argsForCall.arg1, argsForCall.arg2 } -func (fake *FakeMediaTrack) 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() +func (fake *FakeMediaTrack) OnSubscribedMaxQualityChange(arg1 func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error) { + fake.onSubscribedMaxQualityChangeMutex.Lock() + fake.onSubscribedMaxQualityChangeArgsForCall = append(fake.onSubscribedMaxQualityChangeArgsForCall, struct { + arg1 func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error + }{arg1}) + stub := fake.OnSubscribedMaxQualityChangeStub + fake.recordInvocation("OnSubscribedMaxQualityChange", []interface{}{arg1}) + fake.onSubscribedMaxQualityChangeMutex.Unlock() if stub != nil { - fake.NotifySubscriberNodeMediaLossStub(arg1, arg2) + fake.OnSubscribedMaxQualityChangeStub(arg1) } } -func (fake *FakeMediaTrack) NotifySubscriberNodeMediaLossCallCount() int { - fake.notifySubscriberNodeMediaLossMutex.RLock() - defer fake.notifySubscriberNodeMediaLossMutex.RUnlock() - return len(fake.notifySubscriberNodeMediaLossArgsForCall) +func (fake *FakeMediaTrack) OnSubscribedMaxQualityChangeCallCount() int { + fake.onSubscribedMaxQualityChangeMutex.RLock() + defer fake.onSubscribedMaxQualityChangeMutex.RUnlock() + return len(fake.onSubscribedMaxQualityChangeArgsForCall) } -func (fake *FakeMediaTrack) NotifySubscriberNodeMediaLossCalls(stub func(string, uint8)) { - fake.notifySubscriberNodeMediaLossMutex.Lock() - defer fake.notifySubscriberNodeMediaLossMutex.Unlock() - fake.NotifySubscriberNodeMediaLossStub = stub +func (fake *FakeMediaTrack) OnSubscribedMaxQualityChangeCalls(stub func(func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error)) { + fake.onSubscribedMaxQualityChangeMutex.Lock() + defer fake.onSubscribedMaxQualityChangeMutex.Unlock() + fake.OnSubscribedMaxQualityChangeStub = stub } -func (fake *FakeMediaTrack) NotifySubscriberNodeMediaLossArgsForCall(i int) (string, uint8) { - fake.notifySubscriberNodeMediaLossMutex.RLock() - defer fake.notifySubscriberNodeMediaLossMutex.RUnlock() - argsForCall := fake.notifySubscriberNodeMediaLossArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 +func (fake *FakeMediaTrack) OnSubscribedMaxQualityChangeArgsForCall(i int) func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error { + fake.onSubscribedMaxQualityChangeMutex.RLock() + defer fake.onSubscribedMaxQualityChangeMutex.RUnlock() + argsForCall := fake.onSubscribedMaxQualityChangeArgsForCall[i] + return argsForCall.arg1 } func (fake *FakeMediaTrack) PublisherID() livekit.ParticipantID { @@ -902,6 +948,59 @@ func (fake *FakeMediaTrack) PublisherIdentityReturnsOnCall(i int, result1 liveki }{result1} } +func (fake *FakeMediaTrack) Receiver() sfu.TrackReceiver { + fake.receiverMutex.Lock() + ret, specificReturn := fake.receiverReturnsOnCall[len(fake.receiverArgsForCall)] + fake.receiverArgsForCall = append(fake.receiverArgsForCall, struct { + }{}) + stub := fake.ReceiverStub + fakeReturns := fake.receiverReturns + fake.recordInvocation("Receiver", []interface{}{}) + fake.receiverMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeMediaTrack) ReceiverCallCount() int { + fake.receiverMutex.RLock() + defer fake.receiverMutex.RUnlock() + return len(fake.receiverArgsForCall) +} + +func (fake *FakeMediaTrack) ReceiverCalls(stub func() sfu.TrackReceiver) { + fake.receiverMutex.Lock() + defer fake.receiverMutex.Unlock() + fake.ReceiverStub = stub +} + +func (fake *FakeMediaTrack) ReceiverReturns(result1 sfu.TrackReceiver) { + fake.receiverMutex.Lock() + defer fake.receiverMutex.Unlock() + fake.ReceiverStub = nil + fake.receiverReturns = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeMediaTrack) ReceiverReturnsOnCall(i int, result1 sfu.TrackReceiver) { + fake.receiverMutex.Lock() + defer fake.receiverMutex.Unlock() + fake.ReceiverStub = nil + if fake.receiverReturnsOnCall == nil { + fake.receiverReturnsOnCall = make(map[int]struct { + result1 sfu.TrackReceiver + }) + } + fake.receiverReturnsOnCall[i] = struct { + result1 sfu.TrackReceiver + }{result1} +} + func (fake *FakeMediaTrack) RemoveAllSubscribers() { fake.removeAllSubscribersMutex.Lock() fake.removeAllSubscribersArgsForCall = append(fake.removeAllSubscribersArgsForCall, struct { @@ -1202,6 +1301,8 @@ func (fake *FakeMediaTrack) UpdateVideoLayersArgsForCall(i int) []*livekit.Video func (fake *FakeMediaTrack) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() + fake.addOnCloseMutex.RLock() + defer fake.addOnCloseMutex.RUnlock() fake.addSubscriberMutex.RLock() defer fake.addSubscriberMutex.RUnlock() fake.getAllSubscriberIDsMutex.RLock() @@ -1224,12 +1325,14 @@ func (fake *FakeMediaTrack) Invocations() map[string][][]interface{} { defer fake.notifySubscriberMaxQualityMutex.RUnlock() fake.notifySubscriberNodeMaxQualityMutex.RLock() defer fake.notifySubscriberNodeMaxQualityMutex.RUnlock() - fake.notifySubscriberNodeMediaLossMutex.RLock() - defer fake.notifySubscriberNodeMediaLossMutex.RUnlock() + fake.onSubscribedMaxQualityChangeMutex.RLock() + defer fake.onSubscribedMaxQualityChangeMutex.RUnlock() fake.publisherIDMutex.RLock() defer fake.publisherIDMutex.RUnlock() fake.publisherIdentityMutex.RLock() defer fake.publisherIdentityMutex.RUnlock() + fake.receiverMutex.RLock() + defer fake.receiverMutex.RUnlock() fake.removeAllSubscribersMutex.RLock() defer fake.removeAllSubscribersMutex.RUnlock() fake.removeSubscriberMutex.RLock() diff --git a/pkg/rtc/types/typesfakes/fake_participant.go b/pkg/rtc/types/typesfakes/fake_participant.go index a3dae0d79..507b7b87e 100644 --- a/pkg/rtc/types/typesfakes/fake_participant.go +++ b/pkg/rtc/types/typesfakes/fake_participant.go @@ -3,42 +3,16 @@ 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 FakeParticipant 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 - } - AddSubscriberStub func(types.Participant, types.AddSubscriberParams) (int, error) + AddSubscriberStub func(types.LocalParticipant, types.AddSubscriberParams) (int, error) addSubscriberMutex sync.RWMutex addSubscriberArgsForCall []struct { - arg1 types.Participant + arg1 types.LocalParticipant arg2 types.AddSubscriberParams } addSubscriberReturns struct { @@ -49,41 +23,6 @@ type FakeParticipant struct { result1 int result2 error } - 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 - } CloseStub func(bool) error closeMutex sync.RWMutex closeArgsForCall []struct { @@ -95,16 +34,6 @@ type FakeParticipant struct { closeReturnsOnCall map[int]struct { result1 error } - ConnectedAtStub func() time.Time - connectedAtMutex sync.RWMutex - connectedAtArgsForCall []struct { - } - connectedAtReturns struct { - result1 time.Time - } - connectedAtReturnsOnCall map[int]struct { - result1 time.Time - } DebugInfoStub func() map[string]interface{} debugInfoMutex sync.RWMutex debugInfoArgsForCall []struct { @@ -115,113 +44,26 @@ type FakeParticipant struct { debugInfoReturnsOnCall map[int]struct { result1 map[string]interface{} } - 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 - } - GetPublishedTrackStub func(livekit.TrackID) types.PublishedTrack + GetPublishedTrackStub func(livekit.TrackID) types.MediaTrack getPublishedTrackMutex sync.RWMutex getPublishedTrackArgsForCall []struct { arg1 livekit.TrackID } getPublishedTrackReturns struct { - result1 types.PublishedTrack + result1 types.MediaTrack } getPublishedTrackReturnsOnCall map[int]struct { - result1 types.PublishedTrack + result1 types.MediaTrack } - GetPublishedTracksStub func() []types.PublishedTrack + GetPublishedTracksStub func() []types.MediaTrack getPublishedTracksMutex sync.RWMutex getPublishedTracksArgsForCall []struct { } getPublishedTracksReturns struct { - result1 []types.PublishedTrack + result1 []types.MediaTrack } getPublishedTracksReturnsOnCall map[int]struct { - result1 []types.PublishedTrack - } - 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 + result1 []types.MediaTrack } HiddenStub func() bool hiddenMutex sync.RWMutex @@ -233,16 +75,6 @@ type FakeParticipant struct { hiddenReturnsOnCall map[int]struct { result1 bool } - ICERestartStub func() error - iCERestartMutex sync.RWMutex - iCERestartArgsForCall []struct { - } - iCERestartReturns struct { - result1 error - } - iCERestartReturnsOnCall map[int]struct { - result1 error - } IDStub func() livekit.ParticipantID iDMutex sync.RWMutex iDArgsForCall []struct { @@ -263,243 +95,21 @@ type FakeParticipant struct { identityReturnsOnCall map[int]struct { result1 livekit.ParticipantIdentity } - 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) - } - OnTrackPublishedStub func(func(types.Participant, types.PublishedTrack)) - onTrackPublishedMutex sync.RWMutex - onTrackPublishedArgsForCall []struct { - arg1 func(types.Participant, types.PublishedTrack) - } - 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 - } - RemoveSubscriberStub func(types.Participant, livekit.TrackID) + RemoveSubscriberStub func(types.LocalParticipant, livekit.TrackID) removeSubscriberMutex sync.RWMutex removeSubscriberArgsForCall []struct { - arg1 types.Participant + arg1 types.LocalParticipant arg2 livekit.TrackID } - 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 - } SetMetadataStub func(string) setMetadataMutex sync.RWMutex setMetadataArgsForCall []struct { arg1 string } - 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 - } StartStub func() startMutex sync.RWMutex startArgsForCall []struct { } - 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 - } ToProtoStub func() *livekit.ParticipantInfo toProtoMutex sync.RWMutex toProtoArgsForCall []struct { @@ -510,37 +120,11 @@ type FakeParticipant struct { toProtoReturnsOnCall map[int]struct { result1 *livekit.ParticipantInfo } - 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 - } - UpdateSubscriptionPermissionsStub func(*livekit.UpdateSubscriptionPermissions, func(participantID livekit.ParticipantID) types.Participant) error + UpdateSubscriptionPermissionsStub func(*livekit.UpdateSubscriptionPermissions, func(participantID livekit.ParticipantID) types.LocalParticipant) error updateSubscriptionPermissionsMutex sync.RWMutex updateSubscriptionPermissionsArgsForCall []struct { arg1 *livekit.UpdateSubscriptionPermissions - arg2 func(participantID livekit.ParticipantID) types.Participant + arg2 func(participantID livekit.ParticipantID) types.LocalParticipant } updateSubscriptionPermissionsReturns struct { result1 error @@ -563,138 +147,11 @@ type FakeParticipant struct { invocationsMutex sync.RWMutex } -func (fake *FakeParticipant) 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 *FakeParticipant) AddICECandidateCallCount() int { - fake.addICECandidateMutex.RLock() - defer fake.addICECandidateMutex.RUnlock() - return len(fake.addICECandidateArgsForCall) -} - -func (fake *FakeParticipant) AddICECandidateCalls(stub func(webrtc.ICECandidateInit, livekit.SignalTarget) error) { - fake.addICECandidateMutex.Lock() - defer fake.addICECandidateMutex.Unlock() - fake.AddICECandidateStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) AddICECandidateReturns(result1 error) { - fake.addICECandidateMutex.Lock() - defer fake.addICECandidateMutex.Unlock() - fake.AddICECandidateStub = nil - fake.addICECandidateReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) AddMigratedTrackCallCount() int { - fake.addMigratedTrackMutex.RLock() - defer fake.addMigratedTrackMutex.RUnlock() - return len(fake.addMigratedTrackArgsForCall) -} - -func (fake *FakeParticipant) AddMigratedTrackCalls(stub func(string, *livekit.TrackInfo)) { - fake.addMigratedTrackMutex.Lock() - defer fake.addMigratedTrackMutex.Unlock() - fake.AddMigratedTrackStub = stub -} - -func (fake *FakeParticipant) AddMigratedTrackArgsForCall(i int) (string, *livekit.TrackInfo) { - fake.addMigratedTrackMutex.RLock() - defer fake.addMigratedTrackMutex.RUnlock() - argsForCall := fake.addMigratedTrackArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) AddSubscribedTrackCallCount() int { - fake.addSubscribedTrackMutex.RLock() - defer fake.addSubscribedTrackMutex.RUnlock() - return len(fake.addSubscribedTrackArgsForCall) -} - -func (fake *FakeParticipant) AddSubscribedTrackCalls(stub func(types.SubscribedTrack)) { - fake.addSubscribedTrackMutex.Lock() - defer fake.addSubscribedTrackMutex.Unlock() - fake.AddSubscribedTrackStub = stub -} - -func (fake *FakeParticipant) AddSubscribedTrackArgsForCall(i int) types.SubscribedTrack { - fake.addSubscribedTrackMutex.RLock() - defer fake.addSubscribedTrackMutex.RUnlock() - argsForCall := fake.addSubscribedTrackArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) AddSubscriber(arg1 types.Participant, arg2 types.AddSubscriberParams) (int, error) { +func (fake *FakeParticipant) AddSubscriber(arg1 types.LocalParticipant, arg2 types.AddSubscriberParams) (int, error) { fake.addSubscriberMutex.Lock() ret, specificReturn := fake.addSubscriberReturnsOnCall[len(fake.addSubscriberArgsForCall)] fake.addSubscriberArgsForCall = append(fake.addSubscriberArgsForCall, struct { - arg1 types.Participant + arg1 types.LocalParticipant arg2 types.AddSubscriberParams }{arg1, arg2}) stub := fake.AddSubscriberStub @@ -716,13 +173,13 @@ func (fake *FakeParticipant) AddSubscriberCallCount() int { return len(fake.addSubscriberArgsForCall) } -func (fake *FakeParticipant) AddSubscriberCalls(stub func(types.Participant, types.AddSubscriberParams) (int, error)) { +func (fake *FakeParticipant) AddSubscriberCalls(stub func(types.LocalParticipant, types.AddSubscriberParams) (int, error)) { fake.addSubscriberMutex.Lock() defer fake.addSubscriberMutex.Unlock() fake.AddSubscriberStub = stub } -func (fake *FakeParticipant) AddSubscriberArgsForCall(i int) (types.Participant, types.AddSubscriberParams) { +func (fake *FakeParticipant) AddSubscriberArgsForCall(i int) (types.LocalParticipant, types.AddSubscriberParams) { fake.addSubscriberMutex.RLock() defer fake.addSubscriberMutex.RUnlock() argsForCall := fake.addSubscriberArgsForCall[i] @@ -755,197 +212,6 @@ func (fake *FakeParticipant) AddSubscriberReturnsOnCall(i int, result1 int, resu }{result1, result2} } -func (fake *FakeParticipant) 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 *FakeParticipant) AddTrackCallCount() int { - fake.addTrackMutex.RLock() - defer fake.addTrackMutex.RUnlock() - return len(fake.addTrackArgsForCall) -} - -func (fake *FakeParticipant) AddTrackCalls(stub func(*livekit.AddTrackRequest)) { - fake.addTrackMutex.Lock() - defer fake.addTrackMutex.Unlock() - fake.AddTrackStub = stub -} - -func (fake *FakeParticipant) AddTrackArgsForCall(i int) *livekit.AddTrackRequest { - fake.addTrackMutex.RLock() - defer fake.addTrackMutex.RUnlock() - argsForCall := fake.addTrackArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) CanPublishCallCount() int { - fake.canPublishMutex.RLock() - defer fake.canPublishMutex.RUnlock() - return len(fake.canPublishArgsForCall) -} - -func (fake *FakeParticipant) CanPublishCalls(stub func() bool) { - fake.canPublishMutex.Lock() - defer fake.canPublishMutex.Unlock() - fake.CanPublishStub = stub -} - -func (fake *FakeParticipant) CanPublishReturns(result1 bool) { - fake.canPublishMutex.Lock() - defer fake.canPublishMutex.Unlock() - fake.CanPublishStub = nil - fake.canPublishReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) CanPublishDataCallCount() int { - fake.canPublishDataMutex.RLock() - defer fake.canPublishDataMutex.RUnlock() - return len(fake.canPublishDataArgsForCall) -} - -func (fake *FakeParticipant) CanPublishDataCalls(stub func() bool) { - fake.canPublishDataMutex.Lock() - defer fake.canPublishDataMutex.Unlock() - fake.CanPublishDataStub = stub -} - -func (fake *FakeParticipant) CanPublishDataReturns(result1 bool) { - fake.canPublishDataMutex.Lock() - defer fake.canPublishDataMutex.Unlock() - fake.CanPublishDataStub = nil - fake.canPublishDataReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) CanSubscribeCallCount() int { - fake.canSubscribeMutex.RLock() - defer fake.canSubscribeMutex.RUnlock() - return len(fake.canSubscribeArgsForCall) -} - -func (fake *FakeParticipant) CanSubscribeCalls(stub func() bool) { - fake.canSubscribeMutex.Lock() - defer fake.canSubscribeMutex.Unlock() - fake.CanSubscribeStub = stub -} - -func (fake *FakeParticipant) CanSubscribeReturns(result1 bool) { - fake.canSubscribeMutex.Lock() - defer fake.canSubscribeMutex.Unlock() - fake.CanSubscribeStub = nil - fake.canSubscribeReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) Close(arg1 bool) error { fake.closeMutex.Lock() ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] @@ -1007,59 +273,6 @@ func (fake *FakeParticipant) CloseReturnsOnCall(i int, result1 error) { }{result1} } -func (fake *FakeParticipant) 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 *FakeParticipant) ConnectedAtCallCount() int { - fake.connectedAtMutex.RLock() - defer fake.connectedAtMutex.RUnlock() - return len(fake.connectedAtArgsForCall) -} - -func (fake *FakeParticipant) ConnectedAtCalls(stub func() time.Time) { - fake.connectedAtMutex.Lock() - defer fake.connectedAtMutex.Unlock() - fake.ConnectedAtStub = stub -} - -func (fake *FakeParticipant) ConnectedAtReturns(result1 time.Time) { - fake.connectedAtMutex.Lock() - defer fake.connectedAtMutex.Unlock() - fake.ConnectedAtStub = nil - fake.connectedAtReturns = struct { - result1 time.Time - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) DebugInfo() map[string]interface{} { fake.debugInfoMutex.Lock() ret, specificReturn := fake.debugInfoReturnsOnCall[len(fake.debugInfoArgsForCall)] @@ -1113,116 +326,7 @@ func (fake *FakeParticipant) DebugInfoReturnsOnCall(i int, result1 map[string]in }{result1} } -func (fake *FakeParticipant) 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 *FakeParticipant) GetAudioLevelCallCount() int { - fake.getAudioLevelMutex.RLock() - defer fake.getAudioLevelMutex.RUnlock() - return len(fake.getAudioLevelArgsForCall) -} - -func (fake *FakeParticipant) GetAudioLevelCalls(stub func() (uint8, bool)) { - fake.getAudioLevelMutex.Lock() - defer fake.getAudioLevelMutex.Unlock() - fake.GetAudioLevelStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) GetConnectionQualityCallCount() int { - fake.getConnectionQualityMutex.RLock() - defer fake.getConnectionQualityMutex.RUnlock() - return len(fake.getConnectionQualityArgsForCall) -} - -func (fake *FakeParticipant) GetConnectionQualityCalls(stub func() *livekit.ConnectionQualityInfo) { - fake.getConnectionQualityMutex.Lock() - defer fake.getConnectionQualityMutex.Unlock() - fake.GetConnectionQualityStub = stub -} - -func (fake *FakeParticipant) GetConnectionQualityReturns(result1 *livekit.ConnectionQualityInfo) { - fake.getConnectionQualityMutex.Lock() - defer fake.getConnectionQualityMutex.Unlock() - fake.GetConnectionQualityStub = nil - fake.getConnectionQualityReturns = struct { - result1 *livekit.ConnectionQualityInfo - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) GetPublishedTrack(arg1 livekit.TrackID) types.PublishedTrack { +func (fake *FakeParticipant) GetPublishedTrack(arg1 livekit.TrackID) types.MediaTrack { fake.getPublishedTrackMutex.Lock() ret, specificReturn := fake.getPublishedTrackReturnsOnCall[len(fake.getPublishedTrackArgsForCall)] fake.getPublishedTrackArgsForCall = append(fake.getPublishedTrackArgsForCall, struct { @@ -1247,7 +351,7 @@ func (fake *FakeParticipant) GetPublishedTrackCallCount() int { return len(fake.getPublishedTrackArgsForCall) } -func (fake *FakeParticipant) GetPublishedTrackCalls(stub func(livekit.TrackID) types.PublishedTrack) { +func (fake *FakeParticipant) GetPublishedTrackCalls(stub func(livekit.TrackID) types.MediaTrack) { fake.getPublishedTrackMutex.Lock() defer fake.getPublishedTrackMutex.Unlock() fake.GetPublishedTrackStub = stub @@ -1260,30 +364,30 @@ func (fake *FakeParticipant) GetPublishedTrackArgsForCall(i int) livekit.TrackID return argsForCall.arg1 } -func (fake *FakeParticipant) GetPublishedTrackReturns(result1 types.PublishedTrack) { +func (fake *FakeParticipant) GetPublishedTrackReturns(result1 types.MediaTrack) { fake.getPublishedTrackMutex.Lock() defer fake.getPublishedTrackMutex.Unlock() fake.GetPublishedTrackStub = nil fake.getPublishedTrackReturns = struct { - result1 types.PublishedTrack + result1 types.MediaTrack }{result1} } -func (fake *FakeParticipant) GetPublishedTrackReturnsOnCall(i int, result1 types.PublishedTrack) { +func (fake *FakeParticipant) GetPublishedTrackReturnsOnCall(i int, result1 types.MediaTrack) { fake.getPublishedTrackMutex.Lock() defer fake.getPublishedTrackMutex.Unlock() fake.GetPublishedTrackStub = nil if fake.getPublishedTrackReturnsOnCall == nil { fake.getPublishedTrackReturnsOnCall = make(map[int]struct { - result1 types.PublishedTrack + result1 types.MediaTrack }) } fake.getPublishedTrackReturnsOnCall[i] = struct { - result1 types.PublishedTrack + result1 types.MediaTrack }{result1} } -func (fake *FakeParticipant) GetPublishedTracks() []types.PublishedTrack { +func (fake *FakeParticipant) GetPublishedTracks() []types.MediaTrack { fake.getPublishedTracksMutex.Lock() ret, specificReturn := fake.getPublishedTracksReturnsOnCall[len(fake.getPublishedTracksArgsForCall)] fake.getPublishedTracksArgsForCall = append(fake.getPublishedTracksArgsForCall, struct { @@ -1307,380 +411,35 @@ func (fake *FakeParticipant) GetPublishedTracksCallCount() int { return len(fake.getPublishedTracksArgsForCall) } -func (fake *FakeParticipant) GetPublishedTracksCalls(stub func() []types.PublishedTrack) { +func (fake *FakeParticipant) GetPublishedTracksCalls(stub func() []types.MediaTrack) { fake.getPublishedTracksMutex.Lock() defer fake.getPublishedTracksMutex.Unlock() fake.GetPublishedTracksStub = stub } -func (fake *FakeParticipant) GetPublishedTracksReturns(result1 []types.PublishedTrack) { +func (fake *FakeParticipant) GetPublishedTracksReturns(result1 []types.MediaTrack) { fake.getPublishedTracksMutex.Lock() defer fake.getPublishedTracksMutex.Unlock() fake.GetPublishedTracksStub = nil fake.getPublishedTracksReturns = struct { - result1 []types.PublishedTrack + result1 []types.MediaTrack }{result1} } -func (fake *FakeParticipant) GetPublishedTracksReturnsOnCall(i int, result1 []types.PublishedTrack) { +func (fake *FakeParticipant) GetPublishedTracksReturnsOnCall(i int, result1 []types.MediaTrack) { fake.getPublishedTracksMutex.Lock() defer fake.getPublishedTracksMutex.Unlock() fake.GetPublishedTracksStub = nil if fake.getPublishedTracksReturnsOnCall == nil { fake.getPublishedTracksReturnsOnCall = make(map[int]struct { - result1 []types.PublishedTrack + result1 []types.MediaTrack }) } fake.getPublishedTracksReturnsOnCall[i] = struct { - result1 []types.PublishedTrack + result1 []types.MediaTrack }{result1} } -func (fake *FakeParticipant) 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 *FakeParticipant) GetResponseSinkCallCount() int { - fake.getResponseSinkMutex.RLock() - defer fake.getResponseSinkMutex.RUnlock() - return len(fake.getResponseSinkArgsForCall) -} - -func (fake *FakeParticipant) GetResponseSinkCalls(stub func() routing.MessageSink) { - fake.getResponseSinkMutex.Lock() - defer fake.getResponseSinkMutex.Unlock() - fake.GetResponseSinkStub = stub -} - -func (fake *FakeParticipant) GetResponseSinkReturns(result1 routing.MessageSink) { - fake.getResponseSinkMutex.Lock() - defer fake.getResponseSinkMutex.Unlock() - fake.GetResponseSinkStub = nil - fake.getResponseSinkReturns = struct { - result1 routing.MessageSink - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) GetSubscribedParticipantsCallCount() int { - fake.getSubscribedParticipantsMutex.RLock() - defer fake.getSubscribedParticipantsMutex.RUnlock() - return len(fake.getSubscribedParticipantsArgsForCall) -} - -func (fake *FakeParticipant) GetSubscribedParticipantsCalls(stub func() []livekit.ParticipantID) { - fake.getSubscribedParticipantsMutex.Lock() - defer fake.getSubscribedParticipantsMutex.Unlock() - fake.GetSubscribedParticipantsStub = stub -} - -func (fake *FakeParticipant) GetSubscribedParticipantsReturns(result1 []livekit.ParticipantID) { - fake.getSubscribedParticipantsMutex.Lock() - defer fake.getSubscribedParticipantsMutex.Unlock() - fake.GetSubscribedParticipantsStub = nil - fake.getSubscribedParticipantsReturns = struct { - result1 []livekit.ParticipantID - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) GetSubscribedTrackCallCount() int { - fake.getSubscribedTrackMutex.RLock() - defer fake.getSubscribedTrackMutex.RUnlock() - return len(fake.getSubscribedTrackArgsForCall) -} - -func (fake *FakeParticipant) GetSubscribedTrackCalls(stub func(livekit.TrackID) types.SubscribedTrack) { - fake.getSubscribedTrackMutex.Lock() - defer fake.getSubscribedTrackMutex.Unlock() - fake.GetSubscribedTrackStub = stub -} - -func (fake *FakeParticipant) GetSubscribedTrackArgsForCall(i int) livekit.TrackID { - fake.getSubscribedTrackMutex.RLock() - defer fake.getSubscribedTrackMutex.RUnlock() - argsForCall := fake.getSubscribedTrackArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) GetSubscribedTrackReturns(result1 types.SubscribedTrack) { - fake.getSubscribedTrackMutex.Lock() - defer fake.getSubscribedTrackMutex.Unlock() - fake.GetSubscribedTrackStub = nil - fake.getSubscribedTrackReturns = struct { - result1 types.SubscribedTrack - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) GetSubscribedTracksCallCount() int { - fake.getSubscribedTracksMutex.RLock() - defer fake.getSubscribedTracksMutex.RUnlock() - return len(fake.getSubscribedTracksArgsForCall) -} - -func (fake *FakeParticipant) GetSubscribedTracksCalls(stub func() []types.SubscribedTrack) { - fake.getSubscribedTracksMutex.Lock() - defer fake.getSubscribedTracksMutex.Unlock() - fake.GetSubscribedTracksStub = stub -} - -func (fake *FakeParticipant) GetSubscribedTracksReturns(result1 []types.SubscribedTrack) { - fake.getSubscribedTracksMutex.Lock() - defer fake.getSubscribedTracksMutex.Unlock() - fake.GetSubscribedTracksStub = nil - fake.getSubscribedTracksReturns = struct { - result1 []types.SubscribedTrack - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) HandleAnswerCallCount() int { - fake.handleAnswerMutex.RLock() - defer fake.handleAnswerMutex.RUnlock() - return len(fake.handleAnswerArgsForCall) -} - -func (fake *FakeParticipant) HandleAnswerCalls(stub func(webrtc.SessionDescription) error) { - fake.handleAnswerMutex.Lock() - defer fake.handleAnswerMutex.Unlock() - fake.HandleAnswerStub = stub -} - -func (fake *FakeParticipant) HandleAnswerArgsForCall(i int) webrtc.SessionDescription { - fake.handleAnswerMutex.RLock() - defer fake.handleAnswerMutex.RUnlock() - argsForCall := fake.handleAnswerArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) HandleAnswerReturns(result1 error) { - fake.handleAnswerMutex.Lock() - defer fake.handleAnswerMutex.Unlock() - fake.HandleAnswerStub = nil - fake.handleAnswerReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) HandleOfferCallCount() int { - fake.handleOfferMutex.RLock() - defer fake.handleOfferMutex.RUnlock() - return len(fake.handleOfferArgsForCall) -} - -func (fake *FakeParticipant) HandleOfferCalls(stub func(webrtc.SessionDescription) (webrtc.SessionDescription, error)) { - fake.handleOfferMutex.Lock() - defer fake.handleOfferMutex.Unlock() - fake.HandleOfferStub = stub -} - -func (fake *FakeParticipant) HandleOfferArgsForCall(i int) webrtc.SessionDescription { - fake.handleOfferMutex.RLock() - defer fake.handleOfferMutex.RUnlock() - argsForCall := fake.handleOfferArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) Hidden() bool { fake.hiddenMutex.Lock() ret, specificReturn := fake.hiddenReturnsOnCall[len(fake.hiddenArgsForCall)] @@ -1734,59 +493,6 @@ func (fake *FakeParticipant) HiddenReturnsOnCall(i int, result1 bool) { }{result1} } -func (fake *FakeParticipant) 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 *FakeParticipant) ICERestartCallCount() int { - fake.iCERestartMutex.RLock() - defer fake.iCERestartMutex.RUnlock() - return len(fake.iCERestartArgsForCall) -} - -func (fake *FakeParticipant) ICERestartCalls(stub func() error) { - fake.iCERestartMutex.Lock() - defer fake.iCERestartMutex.Unlock() - fake.ICERestartStub = stub -} - -func (fake *FakeParticipant) ICERestartReturns(result1 error) { - fake.iCERestartMutex.Lock() - defer fake.iCERestartMutex.Unlock() - fake.ICERestartStub = nil - fake.iCERestartReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) ID() livekit.ParticipantID { fake.iDMutex.Lock() ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] @@ -1893,470 +599,10 @@ func (fake *FakeParticipant) IdentityReturnsOnCall(i int, result1 livekit.Partic }{result1} } -func (fake *FakeParticipant) 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 *FakeParticipant) IsReadyCallCount() int { - fake.isReadyMutex.RLock() - defer fake.isReadyMutex.RUnlock() - return len(fake.isReadyArgsForCall) -} - -func (fake *FakeParticipant) IsReadyCalls(stub func() bool) { - fake.isReadyMutex.Lock() - defer fake.isReadyMutex.Unlock() - fake.IsReadyStub = stub -} - -func (fake *FakeParticipant) IsReadyReturns(result1 bool) { - fake.isReadyMutex.Lock() - defer fake.isReadyMutex.Unlock() - fake.IsReadyStub = nil - fake.isReadyReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) IsRecorderCallCount() int { - fake.isRecorderMutex.RLock() - defer fake.isRecorderMutex.RUnlock() - return len(fake.isRecorderArgsForCall) -} - -func (fake *FakeParticipant) IsRecorderCalls(stub func() bool) { - fake.isRecorderMutex.Lock() - defer fake.isRecorderMutex.Unlock() - fake.IsRecorderStub = stub -} - -func (fake *FakeParticipant) IsRecorderReturns(result1 bool) { - fake.isRecorderMutex.Lock() - defer fake.isRecorderMutex.Unlock() - fake.IsRecorderStub = nil - fake.isRecorderReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) MigrateStateCallCount() int { - fake.migrateStateMutex.RLock() - defer fake.migrateStateMutex.RUnlock() - return len(fake.migrateStateArgsForCall) -} - -func (fake *FakeParticipant) MigrateStateCalls(stub func() types.MigrateState) { - fake.migrateStateMutex.Lock() - defer fake.migrateStateMutex.Unlock() - fake.MigrateStateStub = stub -} - -func (fake *FakeParticipant) MigrateStateReturns(result1 types.MigrateState) { - fake.migrateStateMutex.Lock() - defer fake.migrateStateMutex.Unlock() - fake.MigrateStateStub = nil - fake.migrateStateReturns = struct { - result1 types.MigrateState - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) NegotiateCallCount() int { - fake.negotiateMutex.RLock() - defer fake.negotiateMutex.RUnlock() - return len(fake.negotiateArgsForCall) -} - -func (fake *FakeParticipant) NegotiateCalls(stub func()) { - fake.negotiateMutex.Lock() - defer fake.negotiateMutex.Unlock() - fake.NegotiateStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) OnCloseCallCount() int { - fake.onCloseMutex.RLock() - defer fake.onCloseMutex.RUnlock() - return len(fake.onCloseArgsForCall) -} - -func (fake *FakeParticipant) OnCloseCalls(stub func(func(types.Participant, map[livekit.TrackID]livekit.ParticipantID))) { - fake.onCloseMutex.Lock() - defer fake.onCloseMutex.Unlock() - fake.OnCloseStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) OnDataPacketCallCount() int { - fake.onDataPacketMutex.RLock() - defer fake.onDataPacketMutex.RUnlock() - return len(fake.onDataPacketArgsForCall) -} - -func (fake *FakeParticipant) OnDataPacketCalls(stub func(func(types.Participant, *livekit.DataPacket))) { - fake.onDataPacketMutex.Lock() - defer fake.onDataPacketMutex.Unlock() - fake.OnDataPacketStub = stub -} - -func (fake *FakeParticipant) OnDataPacketArgsForCall(i int) func(types.Participant, *livekit.DataPacket) { - fake.onDataPacketMutex.RLock() - defer fake.onDataPacketMutex.RUnlock() - argsForCall := fake.onDataPacketArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) OnMetadataUpdateCallCount() int { - fake.onMetadataUpdateMutex.RLock() - defer fake.onMetadataUpdateMutex.RUnlock() - return len(fake.onMetadataUpdateArgsForCall) -} - -func (fake *FakeParticipant) OnMetadataUpdateCalls(stub func(func(types.Participant))) { - fake.onMetadataUpdateMutex.Lock() - defer fake.onMetadataUpdateMutex.Unlock() - fake.OnMetadataUpdateStub = stub -} - -func (fake *FakeParticipant) OnMetadataUpdateArgsForCall(i int) func(types.Participant) { - fake.onMetadataUpdateMutex.RLock() - defer fake.onMetadataUpdateMutex.RUnlock() - argsForCall := fake.onMetadataUpdateArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) OnStateChangeCallCount() int { - fake.onStateChangeMutex.RLock() - defer fake.onStateChangeMutex.RUnlock() - return len(fake.onStateChangeArgsForCall) -} - -func (fake *FakeParticipant) OnStateChangeCalls(stub func(func(p types.Participant, oldState livekit.ParticipantInfo_State))) { - fake.onStateChangeMutex.Lock() - defer fake.onStateChangeMutex.Unlock() - fake.OnStateChangeStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) OnTrackPublished(arg1 func(types.Participant, types.PublishedTrack)) { - fake.onTrackPublishedMutex.Lock() - fake.onTrackPublishedArgsForCall = append(fake.onTrackPublishedArgsForCall, struct { - arg1 func(types.Participant, types.PublishedTrack) - }{arg1}) - stub := fake.OnTrackPublishedStub - fake.recordInvocation("OnTrackPublished", []interface{}{arg1}) - fake.onTrackPublishedMutex.Unlock() - if stub != nil { - fake.OnTrackPublishedStub(arg1) - } -} - -func (fake *FakeParticipant) OnTrackPublishedCallCount() int { - fake.onTrackPublishedMutex.RLock() - defer fake.onTrackPublishedMutex.RUnlock() - return len(fake.onTrackPublishedArgsForCall) -} - -func (fake *FakeParticipant) OnTrackPublishedCalls(stub func(func(types.Participant, types.PublishedTrack))) { - fake.onTrackPublishedMutex.Lock() - defer fake.onTrackPublishedMutex.Unlock() - fake.OnTrackPublishedStub = stub -} - -func (fake *FakeParticipant) OnTrackPublishedArgsForCall(i int) func(types.Participant, types.PublishedTrack) { - fake.onTrackPublishedMutex.RLock() - defer fake.onTrackPublishedMutex.RUnlock() - argsForCall := fake.onTrackPublishedArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) OnTrackUpdatedCallCount() int { - fake.onTrackUpdatedMutex.RLock() - defer fake.onTrackUpdatedMutex.RUnlock() - return len(fake.onTrackUpdatedArgsForCall) -} - -func (fake *FakeParticipant) OnTrackUpdatedCalls(stub func(func(types.Participant, types.PublishedTrack))) { - fake.onTrackUpdatedMutex.Lock() - defer fake.onTrackUpdatedMutex.Unlock() - fake.OnTrackUpdatedStub = stub -} - -func (fake *FakeParticipant) OnTrackUpdatedArgsForCall(i int) func(types.Participant, types.PublishedTrack) { - fake.onTrackUpdatedMutex.RLock() - defer fake.onTrackUpdatedMutex.RUnlock() - argsForCall := fake.onTrackUpdatedArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) ProtocolVersionCallCount() int { - fake.protocolVersionMutex.RLock() - defer fake.protocolVersionMutex.RUnlock() - return len(fake.protocolVersionArgsForCall) -} - -func (fake *FakeParticipant) ProtocolVersionCalls(stub func() types.ProtocolVersion) { - fake.protocolVersionMutex.Lock() - defer fake.protocolVersionMutex.Unlock() - fake.ProtocolVersionStub = stub -} - -func (fake *FakeParticipant) ProtocolVersionReturns(result1 types.ProtocolVersion) { - fake.protocolVersionMutex.Lock() - defer fake.protocolVersionMutex.Unlock() - fake.ProtocolVersionStub = nil - fake.protocolVersionReturns = struct { - result1 types.ProtocolVersion - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) RemoveSubscribedTrackCallCount() int { - fake.removeSubscribedTrackMutex.RLock() - defer fake.removeSubscribedTrackMutex.RUnlock() - return len(fake.removeSubscribedTrackArgsForCall) -} - -func (fake *FakeParticipant) RemoveSubscribedTrackCalls(stub func(types.SubscribedTrack)) { - fake.removeSubscribedTrackMutex.Lock() - defer fake.removeSubscribedTrackMutex.Unlock() - fake.RemoveSubscribedTrackStub = stub -} - -func (fake *FakeParticipant) RemoveSubscribedTrackArgsForCall(i int) types.SubscribedTrack { - fake.removeSubscribedTrackMutex.RLock() - defer fake.removeSubscribedTrackMutex.RUnlock() - argsForCall := fake.removeSubscribedTrackArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) RemoveSubscriber(arg1 types.Participant, arg2 livekit.TrackID) { +func (fake *FakeParticipant) RemoveSubscriber(arg1 types.LocalParticipant, arg2 livekit.TrackID) { fake.removeSubscriberMutex.Lock() fake.removeSubscriberArgsForCall = append(fake.removeSubscriberArgsForCall, struct { - arg1 types.Participant + arg1 types.LocalParticipant arg2 livekit.TrackID }{arg1, arg2}) stub := fake.RemoveSubscriberStub @@ -2373,408 +619,19 @@ func (fake *FakeParticipant) RemoveSubscriberCallCount() int { return len(fake.removeSubscriberArgsForCall) } -func (fake *FakeParticipant) RemoveSubscriberCalls(stub func(types.Participant, livekit.TrackID)) { +func (fake *FakeParticipant) RemoveSubscriberCalls(stub func(types.LocalParticipant, livekit.TrackID)) { fake.removeSubscriberMutex.Lock() defer fake.removeSubscriberMutex.Unlock() fake.RemoveSubscriberStub = stub } -func (fake *FakeParticipant) RemoveSubscriberArgsForCall(i int) (types.Participant, livekit.TrackID) { +func (fake *FakeParticipant) RemoveSubscriberArgsForCall(i int) (types.LocalParticipant, livekit.TrackID) { fake.removeSubscriberMutex.RLock() defer fake.removeSubscriberMutex.RUnlock() argsForCall := fake.removeSubscriberArgsForCall[i] return argsForCall.arg1, argsForCall.arg2 } -func (fake *FakeParticipant) 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 *FakeParticipant) SendConnectionQualityUpdateCallCount() int { - fake.sendConnectionQualityUpdateMutex.RLock() - defer fake.sendConnectionQualityUpdateMutex.RUnlock() - return len(fake.sendConnectionQualityUpdateArgsForCall) -} - -func (fake *FakeParticipant) SendConnectionQualityUpdateCalls(stub func(*livekit.ConnectionQualityUpdate) error) { - fake.sendConnectionQualityUpdateMutex.Lock() - defer fake.sendConnectionQualityUpdateMutex.Unlock() - fake.SendConnectionQualityUpdateStub = stub -} - -func (fake *FakeParticipant) SendConnectionQualityUpdateArgsForCall(i int) *livekit.ConnectionQualityUpdate { - fake.sendConnectionQualityUpdateMutex.RLock() - defer fake.sendConnectionQualityUpdateMutex.RUnlock() - argsForCall := fake.sendConnectionQualityUpdateArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) SendConnectionQualityUpdateReturns(result1 error) { - fake.sendConnectionQualityUpdateMutex.Lock() - defer fake.sendConnectionQualityUpdateMutex.Unlock() - fake.SendConnectionQualityUpdateStub = nil - fake.sendConnectionQualityUpdateReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) SendDataPacketCallCount() int { - fake.sendDataPacketMutex.RLock() - defer fake.sendDataPacketMutex.RUnlock() - return len(fake.sendDataPacketArgsForCall) -} - -func (fake *FakeParticipant) SendDataPacketCalls(stub func(*livekit.DataPacket) error) { - fake.sendDataPacketMutex.Lock() - defer fake.sendDataPacketMutex.Unlock() - fake.SendDataPacketStub = stub -} - -func (fake *FakeParticipant) SendDataPacketArgsForCall(i int) *livekit.DataPacket { - fake.sendDataPacketMutex.RLock() - defer fake.sendDataPacketMutex.RUnlock() - argsForCall := fake.sendDataPacketArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) SendDataPacketReturns(result1 error) { - fake.sendDataPacketMutex.Lock() - defer fake.sendDataPacketMutex.Unlock() - fake.SendDataPacketStub = nil - fake.sendDataPacketReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) SendJoinResponseCallCount() int { - fake.sendJoinResponseMutex.RLock() - defer fake.sendJoinResponseMutex.RUnlock() - return len(fake.sendJoinResponseArgsForCall) -} - -func (fake *FakeParticipant) SendJoinResponseCalls(stub func(*livekit.Room, []*livekit.ParticipantInfo, []*livekit.ICEServer) error) { - fake.sendJoinResponseMutex.Lock() - defer fake.sendJoinResponseMutex.Unlock() - fake.SendJoinResponseStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) SendJoinResponseReturns(result1 error) { - fake.sendJoinResponseMutex.Lock() - defer fake.sendJoinResponseMutex.Unlock() - fake.SendJoinResponseStub = nil - fake.sendJoinResponseReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) SendParticipantUpdateCallCount() int { - fake.sendParticipantUpdateMutex.RLock() - defer fake.sendParticipantUpdateMutex.RUnlock() - return len(fake.sendParticipantUpdateArgsForCall) -} - -func (fake *FakeParticipant) SendParticipantUpdateCalls(stub func([]*livekit.ParticipantInfo, time.Time) error) { - fake.sendParticipantUpdateMutex.Lock() - defer fake.sendParticipantUpdateMutex.Unlock() - fake.SendParticipantUpdateStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) SendParticipantUpdateReturns(result1 error) { - fake.sendParticipantUpdateMutex.Lock() - defer fake.sendParticipantUpdateMutex.Unlock() - fake.SendParticipantUpdateStub = nil - fake.sendParticipantUpdateReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) SendRoomUpdateCallCount() int { - fake.sendRoomUpdateMutex.RLock() - defer fake.sendRoomUpdateMutex.RUnlock() - return len(fake.sendRoomUpdateArgsForCall) -} - -func (fake *FakeParticipant) SendRoomUpdateCalls(stub func(*livekit.Room) error) { - fake.sendRoomUpdateMutex.Lock() - defer fake.sendRoomUpdateMutex.Unlock() - fake.SendRoomUpdateStub = stub -} - -func (fake *FakeParticipant) SendRoomUpdateArgsForCall(i int) *livekit.Room { - fake.sendRoomUpdateMutex.RLock() - defer fake.sendRoomUpdateMutex.RUnlock() - argsForCall := fake.sendRoomUpdateArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) SendRoomUpdateReturns(result1 error) { - fake.sendRoomUpdateMutex.Lock() - defer fake.sendRoomUpdateMutex.Unlock() - fake.SendRoomUpdateStub = nil - fake.sendRoomUpdateReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) SendSpeakerUpdateCallCount() int { - fake.sendSpeakerUpdateMutex.RLock() - defer fake.sendSpeakerUpdateMutex.RUnlock() - return len(fake.sendSpeakerUpdateArgsForCall) -} - -func (fake *FakeParticipant) SendSpeakerUpdateCalls(stub func([]*livekit.SpeakerInfo) error) { - fake.sendSpeakerUpdateMutex.Lock() - defer fake.sendSpeakerUpdateMutex.Unlock() - fake.SendSpeakerUpdateStub = stub -} - -func (fake *FakeParticipant) SendSpeakerUpdateArgsForCall(i int) []*livekit.SpeakerInfo { - fake.sendSpeakerUpdateMutex.RLock() - defer fake.sendSpeakerUpdateMutex.RUnlock() - argsForCall := fake.sendSpeakerUpdateArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) SendSpeakerUpdateReturns(result1 error) { - fake.sendSpeakerUpdateMutex.Lock() - defer fake.sendSpeakerUpdateMutex.Unlock() - fake.SendSpeakerUpdateStub = nil - fake.sendSpeakerUpdateReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) SetMetadata(arg1 string) { fake.setMetadataMutex.Lock() fake.setMetadataArgsForCall = append(fake.setMetadataArgsForCall, struct { @@ -2807,168 +664,6 @@ func (fake *FakeParticipant) SetMetadataArgsForCall(i int) string { return argsForCall.arg1 } -func (fake *FakeParticipant) 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 *FakeParticipant) SetMigrateStateCallCount() int { - fake.setMigrateStateMutex.RLock() - defer fake.setMigrateStateMutex.RUnlock() - return len(fake.setMigrateStateArgsForCall) -} - -func (fake *FakeParticipant) SetMigrateStateCalls(stub func(types.MigrateState)) { - fake.setMigrateStateMutex.Lock() - defer fake.setMigrateStateMutex.Unlock() - fake.SetMigrateStateStub = stub -} - -func (fake *FakeParticipant) SetMigrateStateArgsForCall(i int) types.MigrateState { - fake.setMigrateStateMutex.RLock() - defer fake.setMigrateStateMutex.RUnlock() - argsForCall := fake.setMigrateStateArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) SetPermissionCallCount() int { - fake.setPermissionMutex.RLock() - defer fake.setPermissionMutex.RUnlock() - return len(fake.setPermissionArgsForCall) -} - -func (fake *FakeParticipant) SetPermissionCalls(stub func(*livekit.ParticipantPermission)) { - fake.setPermissionMutex.Lock() - defer fake.setPermissionMutex.Unlock() - fake.SetPermissionStub = stub -} - -func (fake *FakeParticipant) SetPermissionArgsForCall(i int) *livekit.ParticipantPermission { - fake.setPermissionMutex.RLock() - defer fake.setPermissionMutex.RUnlock() - argsForCall := fake.setPermissionArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) SetPreviousAnswerCallCount() int { - fake.setPreviousAnswerMutex.RLock() - defer fake.setPreviousAnswerMutex.RUnlock() - return len(fake.setPreviousAnswerArgsForCall) -} - -func (fake *FakeParticipant) SetPreviousAnswerCalls(stub func(*webrtc.SessionDescription)) { - fake.setPreviousAnswerMutex.Lock() - defer fake.setPreviousAnswerMutex.Unlock() - fake.SetPreviousAnswerStub = stub -} - -func (fake *FakeParticipant) SetPreviousAnswerArgsForCall(i int) *webrtc.SessionDescription { - fake.setPreviousAnswerMutex.RLock() - defer fake.setPreviousAnswerMutex.RUnlock() - argsForCall := fake.setPreviousAnswerArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) SetResponseSinkCallCount() int { - fake.setResponseSinkMutex.RLock() - defer fake.setResponseSinkMutex.RUnlock() - return len(fake.setResponseSinkArgsForCall) -} - -func (fake *FakeParticipant) SetResponseSinkCalls(stub func(routing.MessageSink)) { - fake.setResponseSinkMutex.Lock() - defer fake.setResponseSinkMutex.Unlock() - fake.SetResponseSinkStub = stub -} - -func (fake *FakeParticipant) SetResponseSinkArgsForCall(i int) routing.MessageSink { - fake.setResponseSinkMutex.RLock() - defer fake.setResponseSinkMutex.RUnlock() - argsForCall := fake.setResponseSinkArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeParticipant) 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 *FakeParticipant) SetTrackMutedCallCount() int { - fake.setTrackMutedMutex.RLock() - defer fake.setTrackMutedMutex.RUnlock() - return len(fake.setTrackMutedArgsForCall) -} - -func (fake *FakeParticipant) SetTrackMutedCalls(stub func(livekit.TrackID, bool, bool)) { - fake.setTrackMutedMutex.Lock() - defer fake.setTrackMutedMutex.Unlock() - fake.SetTrackMutedStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) Start() { fake.startMutex.Lock() fake.startArgsForCall = append(fake.startArgsForCall, struct { @@ -2993,252 +688,6 @@ func (fake *FakeParticipant) StartCalls(stub func()) { fake.StartStub = stub } -func (fake *FakeParticipant) 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 *FakeParticipant) StateCallCount() int { - fake.stateMutex.RLock() - defer fake.stateMutex.RUnlock() - return len(fake.stateArgsForCall) -} - -func (fake *FakeParticipant) StateCalls(stub func() livekit.ParticipantInfo_State) { - fake.stateMutex.Lock() - defer fake.stateMutex.Unlock() - fake.StateStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) SubscriberAsPrimaryCallCount() int { - fake.subscriberAsPrimaryMutex.RLock() - defer fake.subscriberAsPrimaryMutex.RUnlock() - return len(fake.subscriberAsPrimaryArgsForCall) -} - -func (fake *FakeParticipant) SubscriberAsPrimaryCalls(stub func() bool) { - fake.subscriberAsPrimaryMutex.Lock() - defer fake.subscriberAsPrimaryMutex.Unlock() - fake.SubscriberAsPrimaryStub = stub -} - -func (fake *FakeParticipant) SubscriberAsPrimaryReturns(result1 bool) { - fake.subscriberAsPrimaryMutex.Lock() - defer fake.subscriberAsPrimaryMutex.Unlock() - fake.SubscriberAsPrimaryStub = nil - fake.subscriberAsPrimaryReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) SubscriberMediaEngineCallCount() int { - fake.subscriberMediaEngineMutex.RLock() - defer fake.subscriberMediaEngineMutex.RUnlock() - return len(fake.subscriberMediaEngineArgsForCall) -} - -func (fake *FakeParticipant) SubscriberMediaEngineCalls(stub func() *webrtc.MediaEngine) { - fake.subscriberMediaEngineMutex.Lock() - defer fake.subscriberMediaEngineMutex.Unlock() - fake.SubscriberMediaEngineStub = stub -} - -func (fake *FakeParticipant) SubscriberMediaEngineReturns(result1 *webrtc.MediaEngine) { - fake.subscriberMediaEngineMutex.Lock() - defer fake.subscriberMediaEngineMutex.Unlock() - fake.SubscriberMediaEngineStub = nil - fake.subscriberMediaEngineReturns = struct { - result1 *webrtc.MediaEngine - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) SubscriberPCCallCount() int { - fake.subscriberPCMutex.RLock() - defer fake.subscriberPCMutex.RUnlock() - return len(fake.subscriberPCArgsForCall) -} - -func (fake *FakeParticipant) SubscriberPCCalls(stub func() *webrtc.PeerConnection) { - fake.subscriberPCMutex.Lock() - defer fake.subscriberPCMutex.Unlock() - fake.SubscriberPCStub = stub -} - -func (fake *FakeParticipant) SubscriberPCReturns(result1 *webrtc.PeerConnection) { - fake.subscriberPCMutex.Lock() - defer fake.subscriberPCMutex.Unlock() - fake.SubscriberPCStub = nil - fake.subscriberPCReturns = struct { - result1 *webrtc.PeerConnection - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) SubscriptionPermissionUpdateCallCount() int { - fake.subscriptionPermissionUpdateMutex.RLock() - defer fake.subscriptionPermissionUpdateMutex.RUnlock() - return len(fake.subscriptionPermissionUpdateArgsForCall) -} - -func (fake *FakeParticipant) SubscriptionPermissionUpdateCalls(stub func(livekit.ParticipantID, livekit.TrackID, bool)) { - fake.subscriptionPermissionUpdateMutex.Lock() - defer fake.subscriptionPermissionUpdateMutex.Unlock() - fake.SubscriptionPermissionUpdateStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) ToProto() *livekit.ParticipantInfo { fake.toProtoMutex.Lock() ret, specificReturn := fake.toProtoReturnsOnCall[len(fake.toProtoArgsForCall)] @@ -3292,138 +741,12 @@ func (fake *FakeParticipant) ToProtoReturnsOnCall(i int, result1 *livekit.Partic }{result1} } -func (fake *FakeParticipant) 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 *FakeParticipant) UpdateMediaLossCallCount() int { - fake.updateMediaLossMutex.RLock() - defer fake.updateMediaLossMutex.RUnlock() - return len(fake.updateMediaLossArgsForCall) -} - -func (fake *FakeParticipant) UpdateMediaLossCalls(stub func(string, livekit.TrackID, uint32) error) { - fake.updateMediaLossMutex.Lock() - defer fake.updateMediaLossMutex.Unlock() - fake.UpdateMediaLossStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) UpdateMediaLossReturns(result1 error) { - fake.updateMediaLossMutex.Lock() - defer fake.updateMediaLossMutex.Unlock() - fake.UpdateMediaLossStub = nil - fake.updateMediaLossReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) 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 *FakeParticipant) UpdateSubscribedQualityCallCount() int { - fake.updateSubscribedQualityMutex.RLock() - defer fake.updateSubscribedQualityMutex.RUnlock() - return len(fake.updateSubscribedQualityArgsForCall) -} - -func (fake *FakeParticipant) UpdateSubscribedQualityCalls(stub func(string, livekit.TrackID, livekit.VideoQuality) error) { - fake.updateSubscribedQualityMutex.Lock() - defer fake.updateSubscribedQualityMutex.Unlock() - fake.UpdateSubscribedQualityStub = stub -} - -func (fake *FakeParticipant) 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 *FakeParticipant) UpdateSubscribedQualityReturns(result1 error) { - fake.updateSubscribedQualityMutex.Lock() - defer fake.updateSubscribedQualityMutex.Unlock() - fake.UpdateSubscribedQualityStub = nil - fake.updateSubscribedQualityReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeParticipant) 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 *FakeParticipant) UpdateSubscriptionPermissions(arg1 *livekit.UpdateSubscriptionPermissions, arg2 func(participantID livekit.ParticipantID) types.Participant) error { +func (fake *FakeParticipant) UpdateSubscriptionPermissions(arg1 *livekit.UpdateSubscriptionPermissions, arg2 func(participantID livekit.ParticipantID) types.LocalParticipant) error { fake.updateSubscriptionPermissionsMutex.Lock() ret, specificReturn := fake.updateSubscriptionPermissionsReturnsOnCall[len(fake.updateSubscriptionPermissionsArgsForCall)] fake.updateSubscriptionPermissionsArgsForCall = append(fake.updateSubscriptionPermissionsArgsForCall, struct { arg1 *livekit.UpdateSubscriptionPermissions - arg2 func(participantID livekit.ParticipantID) types.Participant + arg2 func(participantID livekit.ParticipantID) types.LocalParticipant }{arg1, arg2}) stub := fake.UpdateSubscriptionPermissionsStub fakeReturns := fake.updateSubscriptionPermissionsReturns @@ -3444,13 +767,13 @@ func (fake *FakeParticipant) UpdateSubscriptionPermissionsCallCount() int { return len(fake.updateSubscriptionPermissionsArgsForCall) } -func (fake *FakeParticipant) UpdateSubscriptionPermissionsCalls(stub func(*livekit.UpdateSubscriptionPermissions, func(participantID livekit.ParticipantID) types.Participant) error) { +func (fake *FakeParticipant) UpdateSubscriptionPermissionsCalls(stub func(*livekit.UpdateSubscriptionPermissions, func(participantID livekit.ParticipantID) types.LocalParticipant) error) { fake.updateSubscriptionPermissionsMutex.Lock() defer fake.updateSubscriptionPermissionsMutex.Unlock() fake.UpdateSubscriptionPermissionsStub = stub } -func (fake *FakeParticipant) UpdateSubscriptionPermissionsArgsForCall(i int) (*livekit.UpdateSubscriptionPermissions, func(participantID livekit.ParticipantID) types.Participant) { +func (fake *FakeParticipant) UpdateSubscriptionPermissionsArgsForCall(i int) (*livekit.UpdateSubscriptionPermissions, func(participantID livekit.ParticipantID) types.LocalParticipant) { fake.updateSubscriptionPermissionsMutex.RLock() defer fake.updateSubscriptionPermissionsMutex.RUnlock() argsForCall := fake.updateSubscriptionPermissionsArgsForCall[i] @@ -3544,124 +867,30 @@ func (fake *FakeParticipant) UpdateVideoLayersReturnsOnCall(i int, result1 error func (fake *FakeParticipant) 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.addSubscriberMutex.RLock() defer fake.addSubscriberMutex.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.closeMutex.RLock() defer fake.closeMutex.RUnlock() - fake.connectedAtMutex.RLock() - defer fake.connectedAtMutex.RUnlock() fake.debugInfoMutex.RLock() defer fake.debugInfoMutex.RUnlock() - fake.getAudioLevelMutex.RLock() - defer fake.getAudioLevelMutex.RUnlock() - fake.getConnectionQualityMutex.RLock() - defer fake.getConnectionQualityMutex.RUnlock() fake.getPublishedTrackMutex.RLock() defer fake.getPublishedTrackMutex.RUnlock() fake.getPublishedTracksMutex.RLock() defer fake.getPublishedTracksMutex.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.hiddenMutex.RLock() defer fake.hiddenMutex.RUnlock() - fake.iCERestartMutex.RLock() - defer fake.iCERestartMutex.RUnlock() fake.iDMutex.RLock() defer fake.iDMutex.RUnlock() fake.identityMutex.RLock() defer fake.identityMutex.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.onTrackPublishedMutex.RLock() - defer fake.onTrackPublishedMutex.RUnlock() - fake.onTrackUpdatedMutex.RLock() - defer fake.onTrackUpdatedMutex.RUnlock() - fake.protocolVersionMutex.RLock() - defer fake.protocolVersionMutex.RUnlock() - fake.removeSubscribedTrackMutex.RLock() - defer fake.removeSubscribedTrackMutex.RUnlock() fake.removeSubscriberMutex.RLock() defer fake.removeSubscriberMutex.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.setMetadataMutex.RLock() defer fake.setMetadataMutex.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.startMutex.RLock() defer fake.startMutex.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.toProtoMutex.RLock() defer fake.toProtoMutex.RUnlock() - fake.updateMediaLossMutex.RLock() - defer fake.updateMediaLossMutex.RUnlock() - fake.updateSubscribedQualityMutex.RLock() - defer fake.updateSubscribedQualityMutex.RUnlock() fake.updateSubscriptionPermissionsMutex.RLock() defer fake.updateSubscriptionPermissionsMutex.RUnlock() fake.updateVideoLayersMutex.RLock() diff --git a/pkg/rtc/types/typesfakes/fake_published_track.go b/pkg/rtc/types/typesfakes/fake_published_track.go deleted file mode 100644 index 2c920c45b..000000000 --- a/pkg/rtc/types/typesfakes/fake_published_track.go +++ /dev/null @@ -1,1675 +0,0 @@ -// Code generated by counterfeiter. DO NOT EDIT. -package typesfakes - -import ( - "sync" - - "github.com/livekit/livekit-server/pkg/rtc/types" - "github.com/livekit/livekit-server/pkg/sfu" - "github.com/livekit/protocol/livekit" -) - -type FakePublishedTrack struct { - AddOnCloseStub func(func()) - addOnCloseMutex sync.RWMutex - addOnCloseArgsForCall []struct { - arg1 func() - } - AddSubscriberStub func(types.Participant) error - addSubscriberMutex sync.RWMutex - addSubscriberArgsForCall []struct { - arg1 types.Participant - } - addSubscriberReturns struct { - result1 error - } - addSubscriberReturnsOnCall map[int]struct { - result1 error - } - GetAllSubscriberIDsStub func() []livekit.ParticipantID - getAllSubscriberIDsMutex sync.RWMutex - getAllSubscriberIDsArgsForCall []struct { - } - getAllSubscriberIDsReturns struct { - result1 []livekit.ParticipantID - } - getAllSubscriberIDsReturnsOnCall map[int]struct { - result1 []livekit.ParticipantID - } - 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 - } - GetQualityForDimensionStub func(uint32, uint32) livekit.VideoQuality - getQualityForDimensionMutex sync.RWMutex - getQualityForDimensionArgsForCall []struct { - arg1 uint32 - arg2 uint32 - } - getQualityForDimensionReturns struct { - result1 livekit.VideoQuality - } - getQualityForDimensionReturnsOnCall map[int]struct { - result1 livekit.VideoQuality - } - IDStub func() livekit.TrackID - iDMutex sync.RWMutex - iDArgsForCall []struct { - } - iDReturns struct { - result1 livekit.TrackID - } - iDReturnsOnCall map[int]struct { - result1 livekit.TrackID - } - IsMutedStub func() bool - isMutedMutex sync.RWMutex - isMutedArgsForCall []struct { - } - isMutedReturns struct { - result1 bool - } - isMutedReturnsOnCall map[int]struct { - result1 bool - } - IsSimulcastStub func() bool - isSimulcastMutex sync.RWMutex - isSimulcastArgsForCall []struct { - } - isSimulcastReturns struct { - result1 bool - } - isSimulcastReturnsOnCall map[int]struct { - result1 bool - } - IsSubscriberStub func(livekit.ParticipantID) bool - isSubscriberMutex sync.RWMutex - isSubscriberArgsForCall []struct { - arg1 livekit.ParticipantID - } - isSubscriberReturns struct { - result1 bool - } - isSubscriberReturnsOnCall map[int]struct { - result1 bool - } - KindStub func() livekit.TrackType - kindMutex sync.RWMutex - kindArgsForCall []struct { - } - kindReturns struct { - result1 livekit.TrackType - } - kindReturnsOnCall map[int]struct { - result1 livekit.TrackType - } - NameStub func() string - nameMutex sync.RWMutex - nameArgsForCall []struct { - } - nameReturns struct { - result1 string - } - nameReturnsOnCall map[int]struct { - result1 string - } - NotifySubscriberMaxQualityStub func(livekit.ParticipantID, livekit.VideoQuality) - notifySubscriberMaxQualityMutex sync.RWMutex - notifySubscriberMaxQualityArgsForCall []struct { - arg1 livekit.ParticipantID - arg2 livekit.VideoQuality - } - NotifySubscriberNodeMaxQualityStub func(string, livekit.VideoQuality) - notifySubscriberNodeMaxQualityMutex sync.RWMutex - notifySubscriberNodeMaxQualityArgsForCall []struct { - arg1 string - arg2 livekit.VideoQuality - } - NotifySubscriberNodeMediaLossStub func(string, uint8) - notifySubscriberNodeMediaLossMutex sync.RWMutex - notifySubscriberNodeMediaLossArgsForCall []struct { - arg1 string - arg2 uint8 - } - OnSubscribedMaxQualityChangeStub func(func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error) - onSubscribedMaxQualityChangeMutex sync.RWMutex - onSubscribedMaxQualityChangeArgsForCall []struct { - arg1 func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error - } - PublisherIDStub func() livekit.ParticipantID - publisherIDMutex sync.RWMutex - publisherIDArgsForCall []struct { - } - publisherIDReturns struct { - result1 livekit.ParticipantID - } - publisherIDReturnsOnCall map[int]struct { - result1 livekit.ParticipantID - } - PublisherIdentityStub func() livekit.ParticipantIdentity - publisherIdentityMutex sync.RWMutex - publisherIdentityArgsForCall []struct { - } - publisherIdentityReturns struct { - result1 livekit.ParticipantIdentity - } - publisherIdentityReturnsOnCall map[int]struct { - result1 livekit.ParticipantIdentity - } - ReceiverStub func() sfu.TrackReceiver - receiverMutex sync.RWMutex - receiverArgsForCall []struct { - } - receiverReturns struct { - result1 sfu.TrackReceiver - } - receiverReturnsOnCall map[int]struct { - result1 sfu.TrackReceiver - } - RemoveAllSubscribersStub func() - removeAllSubscribersMutex sync.RWMutex - removeAllSubscribersArgsForCall []struct { - } - RemoveSubscriberStub func(livekit.ParticipantID) - removeSubscriberMutex sync.RWMutex - removeSubscriberArgsForCall []struct { - arg1 livekit.ParticipantID - } - RevokeDisallowedSubscribersStub func([]livekit.ParticipantID) []livekit.ParticipantID - revokeDisallowedSubscribersMutex sync.RWMutex - revokeDisallowedSubscribersArgsForCall []struct { - arg1 []livekit.ParticipantID - } - revokeDisallowedSubscribersReturns struct { - result1 []livekit.ParticipantID - } - revokeDisallowedSubscribersReturnsOnCall map[int]struct { - result1 []livekit.ParticipantID - } - SdpCidStub func() string - sdpCidMutex sync.RWMutex - sdpCidArgsForCall []struct { - } - sdpCidReturns struct { - result1 string - } - sdpCidReturnsOnCall map[int]struct { - result1 string - } - SetMutedStub func(bool) - setMutedMutex sync.RWMutex - setMutedArgsForCall []struct { - arg1 bool - } - SignalCidStub func() string - signalCidMutex sync.RWMutex - signalCidArgsForCall []struct { - } - signalCidReturns struct { - result1 string - } - signalCidReturnsOnCall map[int]struct { - result1 string - } - SourceStub func() livekit.TrackSource - sourceMutex sync.RWMutex - sourceArgsForCall []struct { - } - sourceReturns struct { - result1 livekit.TrackSource - } - sourceReturnsOnCall map[int]struct { - result1 livekit.TrackSource - } - ToProtoStub func() *livekit.TrackInfo - toProtoMutex sync.RWMutex - toProtoArgsForCall []struct { - } - toProtoReturns struct { - result1 *livekit.TrackInfo - } - toProtoReturnsOnCall map[int]struct { - result1 *livekit.TrackInfo - } - UpdateVideoLayersStub func([]*livekit.VideoLayer) - updateVideoLayersMutex sync.RWMutex - updateVideoLayersArgsForCall []struct { - arg1 []*livekit.VideoLayer - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakePublishedTrack) AddOnClose(arg1 func()) { - fake.addOnCloseMutex.Lock() - fake.addOnCloseArgsForCall = append(fake.addOnCloseArgsForCall, struct { - arg1 func() - }{arg1}) - stub := fake.AddOnCloseStub - fake.recordInvocation("AddOnClose", []interface{}{arg1}) - fake.addOnCloseMutex.Unlock() - if stub != nil { - fake.AddOnCloseStub(arg1) - } -} - -func (fake *FakePublishedTrack) AddOnCloseCallCount() int { - fake.addOnCloseMutex.RLock() - defer fake.addOnCloseMutex.RUnlock() - return len(fake.addOnCloseArgsForCall) -} - -func (fake *FakePublishedTrack) AddOnCloseCalls(stub func(func())) { - fake.addOnCloseMutex.Lock() - defer fake.addOnCloseMutex.Unlock() - fake.AddOnCloseStub = stub -} - -func (fake *FakePublishedTrack) AddOnCloseArgsForCall(i int) func() { - fake.addOnCloseMutex.RLock() - defer fake.addOnCloseMutex.RUnlock() - argsForCall := fake.addOnCloseArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakePublishedTrack) AddSubscriber(arg1 types.Participant) error { - fake.addSubscriberMutex.Lock() - ret, specificReturn := fake.addSubscriberReturnsOnCall[len(fake.addSubscriberArgsForCall)] - fake.addSubscriberArgsForCall = append(fake.addSubscriberArgsForCall, struct { - arg1 types.Participant - }{arg1}) - stub := fake.AddSubscriberStub - fakeReturns := fake.addSubscriberReturns - fake.recordInvocation("AddSubscriber", []interface{}{arg1}) - fake.addSubscriberMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) AddSubscriberCallCount() int { - fake.addSubscriberMutex.RLock() - defer fake.addSubscriberMutex.RUnlock() - return len(fake.addSubscriberArgsForCall) -} - -func (fake *FakePublishedTrack) AddSubscriberCalls(stub func(types.Participant) error) { - fake.addSubscriberMutex.Lock() - defer fake.addSubscriberMutex.Unlock() - fake.AddSubscriberStub = stub -} - -func (fake *FakePublishedTrack) AddSubscriberArgsForCall(i int) types.Participant { - fake.addSubscriberMutex.RLock() - defer fake.addSubscriberMutex.RUnlock() - argsForCall := fake.addSubscriberArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakePublishedTrack) AddSubscriberReturns(result1 error) { - fake.addSubscriberMutex.Lock() - defer fake.addSubscriberMutex.Unlock() - fake.AddSubscriberStub = nil - fake.addSubscriberReturns = struct { - result1 error - }{result1} -} - -func (fake *FakePublishedTrack) AddSubscriberReturnsOnCall(i int, result1 error) { - fake.addSubscriberMutex.Lock() - defer fake.addSubscriberMutex.Unlock() - fake.AddSubscriberStub = nil - if fake.addSubscriberReturnsOnCall == nil { - fake.addSubscriberReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.addSubscriberReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakePublishedTrack) GetAllSubscriberIDs() []livekit.ParticipantID { - fake.getAllSubscriberIDsMutex.Lock() - ret, specificReturn := fake.getAllSubscriberIDsReturnsOnCall[len(fake.getAllSubscriberIDsArgsForCall)] - fake.getAllSubscriberIDsArgsForCall = append(fake.getAllSubscriberIDsArgsForCall, struct { - }{}) - stub := fake.GetAllSubscriberIDsStub - fakeReturns := fake.getAllSubscriberIDsReturns - fake.recordInvocation("GetAllSubscriberIDs", []interface{}{}) - fake.getAllSubscriberIDsMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) GetAllSubscriberIDsCallCount() int { - fake.getAllSubscriberIDsMutex.RLock() - defer fake.getAllSubscriberIDsMutex.RUnlock() - return len(fake.getAllSubscriberIDsArgsForCall) -} - -func (fake *FakePublishedTrack) GetAllSubscriberIDsCalls(stub func() []livekit.ParticipantID) { - fake.getAllSubscriberIDsMutex.Lock() - defer fake.getAllSubscriberIDsMutex.Unlock() - fake.GetAllSubscriberIDsStub = stub -} - -func (fake *FakePublishedTrack) GetAllSubscriberIDsReturns(result1 []livekit.ParticipantID) { - fake.getAllSubscriberIDsMutex.Lock() - defer fake.getAllSubscriberIDsMutex.Unlock() - fake.GetAllSubscriberIDsStub = nil - fake.getAllSubscriberIDsReturns = struct { - result1 []livekit.ParticipantID - }{result1} -} - -func (fake *FakePublishedTrack) GetAllSubscriberIDsReturnsOnCall(i int, result1 []livekit.ParticipantID) { - fake.getAllSubscriberIDsMutex.Lock() - defer fake.getAllSubscriberIDsMutex.Unlock() - fake.GetAllSubscriberIDsStub = nil - if fake.getAllSubscriberIDsReturnsOnCall == nil { - fake.getAllSubscriberIDsReturnsOnCall = make(map[int]struct { - result1 []livekit.ParticipantID - }) - } - fake.getAllSubscriberIDsReturnsOnCall[i] = struct { - result1 []livekit.ParticipantID - }{result1} -} - -func (fake *FakePublishedTrack) 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 *FakePublishedTrack) GetAudioLevelCallCount() int { - fake.getAudioLevelMutex.RLock() - defer fake.getAudioLevelMutex.RUnlock() - return len(fake.getAudioLevelArgsForCall) -} - -func (fake *FakePublishedTrack) GetAudioLevelCalls(stub func() (uint8, bool)) { - fake.getAudioLevelMutex.Lock() - defer fake.getAudioLevelMutex.Unlock() - fake.GetAudioLevelStub = stub -} - -func (fake *FakePublishedTrack) 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 *FakePublishedTrack) 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 *FakePublishedTrack) 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 *FakePublishedTrack) GetConnectionScoreCallCount() int { - fake.getConnectionScoreMutex.RLock() - defer fake.getConnectionScoreMutex.RUnlock() - return len(fake.getConnectionScoreArgsForCall) -} - -func (fake *FakePublishedTrack) GetConnectionScoreCalls(stub func() float64) { - fake.getConnectionScoreMutex.Lock() - defer fake.getConnectionScoreMutex.Unlock() - fake.GetConnectionScoreStub = stub -} - -func (fake *FakePublishedTrack) GetConnectionScoreReturns(result1 float64) { - fake.getConnectionScoreMutex.Lock() - defer fake.getConnectionScoreMutex.Unlock() - fake.GetConnectionScoreStub = nil - fake.getConnectionScoreReturns = struct { - result1 float64 - }{result1} -} - -func (fake *FakePublishedTrack) 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 *FakePublishedTrack) GetQualityForDimension(arg1 uint32, arg2 uint32) livekit.VideoQuality { - fake.getQualityForDimensionMutex.Lock() - ret, specificReturn := fake.getQualityForDimensionReturnsOnCall[len(fake.getQualityForDimensionArgsForCall)] - fake.getQualityForDimensionArgsForCall = append(fake.getQualityForDimensionArgsForCall, struct { - arg1 uint32 - arg2 uint32 - }{arg1, arg2}) - stub := fake.GetQualityForDimensionStub - fakeReturns := fake.getQualityForDimensionReturns - fake.recordInvocation("GetQualityForDimension", []interface{}{arg1, arg2}) - fake.getQualityForDimensionMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) GetQualityForDimensionCallCount() int { - fake.getQualityForDimensionMutex.RLock() - defer fake.getQualityForDimensionMutex.RUnlock() - return len(fake.getQualityForDimensionArgsForCall) -} - -func (fake *FakePublishedTrack) GetQualityForDimensionCalls(stub func(uint32, uint32) livekit.VideoQuality) { - fake.getQualityForDimensionMutex.Lock() - defer fake.getQualityForDimensionMutex.Unlock() - fake.GetQualityForDimensionStub = stub -} - -func (fake *FakePublishedTrack) GetQualityForDimensionArgsForCall(i int) (uint32, uint32) { - fake.getQualityForDimensionMutex.RLock() - defer fake.getQualityForDimensionMutex.RUnlock() - argsForCall := fake.getQualityForDimensionArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakePublishedTrack) GetQualityForDimensionReturns(result1 livekit.VideoQuality) { - fake.getQualityForDimensionMutex.Lock() - defer fake.getQualityForDimensionMutex.Unlock() - fake.GetQualityForDimensionStub = nil - fake.getQualityForDimensionReturns = struct { - result1 livekit.VideoQuality - }{result1} -} - -func (fake *FakePublishedTrack) GetQualityForDimensionReturnsOnCall(i int, result1 livekit.VideoQuality) { - fake.getQualityForDimensionMutex.Lock() - defer fake.getQualityForDimensionMutex.Unlock() - fake.GetQualityForDimensionStub = nil - if fake.getQualityForDimensionReturnsOnCall == nil { - fake.getQualityForDimensionReturnsOnCall = make(map[int]struct { - result1 livekit.VideoQuality - }) - } - fake.getQualityForDimensionReturnsOnCall[i] = struct { - result1 livekit.VideoQuality - }{result1} -} - -func (fake *FakePublishedTrack) ID() livekit.TrackID { - fake.iDMutex.Lock() - ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] - fake.iDArgsForCall = append(fake.iDArgsForCall, struct { - }{}) - stub := fake.IDStub - fakeReturns := fake.iDReturns - fake.recordInvocation("ID", []interface{}{}) - fake.iDMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) IDCallCount() int { - fake.iDMutex.RLock() - defer fake.iDMutex.RUnlock() - return len(fake.iDArgsForCall) -} - -func (fake *FakePublishedTrack) IDCalls(stub func() livekit.TrackID) { - fake.iDMutex.Lock() - defer fake.iDMutex.Unlock() - fake.IDStub = stub -} - -func (fake *FakePublishedTrack) IDReturns(result1 livekit.TrackID) { - fake.iDMutex.Lock() - defer fake.iDMutex.Unlock() - fake.IDStub = nil - fake.iDReturns = struct { - result1 livekit.TrackID - }{result1} -} - -func (fake *FakePublishedTrack) IDReturnsOnCall(i int, result1 livekit.TrackID) { - fake.iDMutex.Lock() - defer fake.iDMutex.Unlock() - fake.IDStub = nil - if fake.iDReturnsOnCall == nil { - fake.iDReturnsOnCall = make(map[int]struct { - result1 livekit.TrackID - }) - } - fake.iDReturnsOnCall[i] = struct { - result1 livekit.TrackID - }{result1} -} - -func (fake *FakePublishedTrack) IsMuted() bool { - fake.isMutedMutex.Lock() - ret, specificReturn := fake.isMutedReturnsOnCall[len(fake.isMutedArgsForCall)] - fake.isMutedArgsForCall = append(fake.isMutedArgsForCall, struct { - }{}) - stub := fake.IsMutedStub - fakeReturns := fake.isMutedReturns - fake.recordInvocation("IsMuted", []interface{}{}) - fake.isMutedMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) IsMutedCallCount() int { - fake.isMutedMutex.RLock() - defer fake.isMutedMutex.RUnlock() - return len(fake.isMutedArgsForCall) -} - -func (fake *FakePublishedTrack) IsMutedCalls(stub func() bool) { - fake.isMutedMutex.Lock() - defer fake.isMutedMutex.Unlock() - fake.IsMutedStub = stub -} - -func (fake *FakePublishedTrack) IsMutedReturns(result1 bool) { - fake.isMutedMutex.Lock() - defer fake.isMutedMutex.Unlock() - fake.IsMutedStub = nil - fake.isMutedReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakePublishedTrack) IsMutedReturnsOnCall(i int, result1 bool) { - fake.isMutedMutex.Lock() - defer fake.isMutedMutex.Unlock() - fake.IsMutedStub = nil - if fake.isMutedReturnsOnCall == nil { - fake.isMutedReturnsOnCall = make(map[int]struct { - result1 bool - }) - } - fake.isMutedReturnsOnCall[i] = struct { - result1 bool - }{result1} -} - -func (fake *FakePublishedTrack) IsSimulcast() bool { - fake.isSimulcastMutex.Lock() - ret, specificReturn := fake.isSimulcastReturnsOnCall[len(fake.isSimulcastArgsForCall)] - fake.isSimulcastArgsForCall = append(fake.isSimulcastArgsForCall, struct { - }{}) - stub := fake.IsSimulcastStub - fakeReturns := fake.isSimulcastReturns - fake.recordInvocation("IsSimulcast", []interface{}{}) - fake.isSimulcastMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) IsSimulcastCallCount() int { - fake.isSimulcastMutex.RLock() - defer fake.isSimulcastMutex.RUnlock() - return len(fake.isSimulcastArgsForCall) -} - -func (fake *FakePublishedTrack) IsSimulcastCalls(stub func() bool) { - fake.isSimulcastMutex.Lock() - defer fake.isSimulcastMutex.Unlock() - fake.IsSimulcastStub = stub -} - -func (fake *FakePublishedTrack) IsSimulcastReturns(result1 bool) { - fake.isSimulcastMutex.Lock() - defer fake.isSimulcastMutex.Unlock() - fake.IsSimulcastStub = nil - fake.isSimulcastReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakePublishedTrack) IsSimulcastReturnsOnCall(i int, result1 bool) { - fake.isSimulcastMutex.Lock() - defer fake.isSimulcastMutex.Unlock() - fake.IsSimulcastStub = nil - if fake.isSimulcastReturnsOnCall == nil { - fake.isSimulcastReturnsOnCall = make(map[int]struct { - result1 bool - }) - } - fake.isSimulcastReturnsOnCall[i] = struct { - result1 bool - }{result1} -} - -func (fake *FakePublishedTrack) IsSubscriber(arg1 livekit.ParticipantID) bool { - fake.isSubscriberMutex.Lock() - ret, specificReturn := fake.isSubscriberReturnsOnCall[len(fake.isSubscriberArgsForCall)] - fake.isSubscriberArgsForCall = append(fake.isSubscriberArgsForCall, struct { - arg1 livekit.ParticipantID - }{arg1}) - stub := fake.IsSubscriberStub - fakeReturns := fake.isSubscriberReturns - fake.recordInvocation("IsSubscriber", []interface{}{arg1}) - fake.isSubscriberMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) IsSubscriberCallCount() int { - fake.isSubscriberMutex.RLock() - defer fake.isSubscriberMutex.RUnlock() - return len(fake.isSubscriberArgsForCall) -} - -func (fake *FakePublishedTrack) IsSubscriberCalls(stub func(livekit.ParticipantID) bool) { - fake.isSubscriberMutex.Lock() - defer fake.isSubscriberMutex.Unlock() - fake.IsSubscriberStub = stub -} - -func (fake *FakePublishedTrack) IsSubscriberArgsForCall(i int) livekit.ParticipantID { - fake.isSubscriberMutex.RLock() - defer fake.isSubscriberMutex.RUnlock() - argsForCall := fake.isSubscriberArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakePublishedTrack) IsSubscriberReturns(result1 bool) { - fake.isSubscriberMutex.Lock() - defer fake.isSubscriberMutex.Unlock() - fake.IsSubscriberStub = nil - fake.isSubscriberReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakePublishedTrack) IsSubscriberReturnsOnCall(i int, result1 bool) { - fake.isSubscriberMutex.Lock() - defer fake.isSubscriberMutex.Unlock() - fake.IsSubscriberStub = nil - if fake.isSubscriberReturnsOnCall == nil { - fake.isSubscriberReturnsOnCall = make(map[int]struct { - result1 bool - }) - } - fake.isSubscriberReturnsOnCall[i] = struct { - result1 bool - }{result1} -} - -func (fake *FakePublishedTrack) Kind() livekit.TrackType { - fake.kindMutex.Lock() - ret, specificReturn := fake.kindReturnsOnCall[len(fake.kindArgsForCall)] - fake.kindArgsForCall = append(fake.kindArgsForCall, struct { - }{}) - stub := fake.KindStub - fakeReturns := fake.kindReturns - fake.recordInvocation("Kind", []interface{}{}) - fake.kindMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) KindCallCount() int { - fake.kindMutex.RLock() - defer fake.kindMutex.RUnlock() - return len(fake.kindArgsForCall) -} - -func (fake *FakePublishedTrack) KindCalls(stub func() livekit.TrackType) { - fake.kindMutex.Lock() - defer fake.kindMutex.Unlock() - fake.KindStub = stub -} - -func (fake *FakePublishedTrack) KindReturns(result1 livekit.TrackType) { - fake.kindMutex.Lock() - defer fake.kindMutex.Unlock() - fake.KindStub = nil - fake.kindReturns = struct { - result1 livekit.TrackType - }{result1} -} - -func (fake *FakePublishedTrack) KindReturnsOnCall(i int, result1 livekit.TrackType) { - fake.kindMutex.Lock() - defer fake.kindMutex.Unlock() - fake.KindStub = nil - if fake.kindReturnsOnCall == nil { - fake.kindReturnsOnCall = make(map[int]struct { - result1 livekit.TrackType - }) - } - fake.kindReturnsOnCall[i] = struct { - result1 livekit.TrackType - }{result1} -} - -func (fake *FakePublishedTrack) Name() string { - fake.nameMutex.Lock() - ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)] - fake.nameArgsForCall = append(fake.nameArgsForCall, struct { - }{}) - stub := fake.NameStub - fakeReturns := fake.nameReturns - fake.recordInvocation("Name", []interface{}{}) - fake.nameMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) NameCallCount() int { - fake.nameMutex.RLock() - defer fake.nameMutex.RUnlock() - return len(fake.nameArgsForCall) -} - -func (fake *FakePublishedTrack) NameCalls(stub func() string) { - fake.nameMutex.Lock() - defer fake.nameMutex.Unlock() - fake.NameStub = stub -} - -func (fake *FakePublishedTrack) NameReturns(result1 string) { - fake.nameMutex.Lock() - defer fake.nameMutex.Unlock() - fake.NameStub = nil - fake.nameReturns = struct { - result1 string - }{result1} -} - -func (fake *FakePublishedTrack) NameReturnsOnCall(i int, result1 string) { - fake.nameMutex.Lock() - defer fake.nameMutex.Unlock() - fake.NameStub = nil - if fake.nameReturnsOnCall == nil { - fake.nameReturnsOnCall = make(map[int]struct { - result1 string - }) - } - fake.nameReturnsOnCall[i] = struct { - result1 string - }{result1} -} - -func (fake *FakePublishedTrack) NotifySubscriberMaxQuality(arg1 livekit.ParticipantID, arg2 livekit.VideoQuality) { - fake.notifySubscriberMaxQualityMutex.Lock() - fake.notifySubscriberMaxQualityArgsForCall = append(fake.notifySubscriberMaxQualityArgsForCall, struct { - arg1 livekit.ParticipantID - arg2 livekit.VideoQuality - }{arg1, arg2}) - stub := fake.NotifySubscriberMaxQualityStub - fake.recordInvocation("NotifySubscriberMaxQuality", []interface{}{arg1, arg2}) - fake.notifySubscriberMaxQualityMutex.Unlock() - if stub != nil { - fake.NotifySubscriberMaxQualityStub(arg1, arg2) - } -} - -func (fake *FakePublishedTrack) NotifySubscriberMaxQualityCallCount() int { - fake.notifySubscriberMaxQualityMutex.RLock() - defer fake.notifySubscriberMaxQualityMutex.RUnlock() - return len(fake.notifySubscriberMaxQualityArgsForCall) -} - -func (fake *FakePublishedTrack) NotifySubscriberMaxQualityCalls(stub func(livekit.ParticipantID, livekit.VideoQuality)) { - fake.notifySubscriberMaxQualityMutex.Lock() - defer fake.notifySubscriberMaxQualityMutex.Unlock() - fake.NotifySubscriberMaxQualityStub = stub -} - -func (fake *FakePublishedTrack) NotifySubscriberMaxQualityArgsForCall(i int) (livekit.ParticipantID, livekit.VideoQuality) { - fake.notifySubscriberMaxQualityMutex.RLock() - defer fake.notifySubscriberMaxQualityMutex.RUnlock() - argsForCall := fake.notifySubscriberMaxQualityArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakePublishedTrack) NotifySubscriberNodeMaxQuality(arg1 string, arg2 livekit.VideoQuality) { - fake.notifySubscriberNodeMaxQualityMutex.Lock() - fake.notifySubscriberNodeMaxQualityArgsForCall = append(fake.notifySubscriberNodeMaxQualityArgsForCall, struct { - arg1 string - arg2 livekit.VideoQuality - }{arg1, arg2}) - stub := fake.NotifySubscriberNodeMaxQualityStub - fake.recordInvocation("NotifySubscriberNodeMaxQuality", []interface{}{arg1, arg2}) - fake.notifySubscriberNodeMaxQualityMutex.Unlock() - if stub != nil { - fake.NotifySubscriberNodeMaxQualityStub(arg1, arg2) - } -} - -func (fake *FakePublishedTrack) NotifySubscriberNodeMaxQualityCallCount() int { - fake.notifySubscriberNodeMaxQualityMutex.RLock() - defer fake.notifySubscriberNodeMaxQualityMutex.RUnlock() - return len(fake.notifySubscriberNodeMaxQualityArgsForCall) -} - -func (fake *FakePublishedTrack) NotifySubscriberNodeMaxQualityCalls(stub func(string, livekit.VideoQuality)) { - fake.notifySubscriberNodeMaxQualityMutex.Lock() - defer fake.notifySubscriberNodeMaxQualityMutex.Unlock() - fake.NotifySubscriberNodeMaxQualityStub = stub -} - -func (fake *FakePublishedTrack) NotifySubscriberNodeMaxQualityArgsForCall(i int) (string, livekit.VideoQuality) { - fake.notifySubscriberNodeMaxQualityMutex.RLock() - defer fake.notifySubscriberNodeMaxQualityMutex.RUnlock() - argsForCall := fake.notifySubscriberNodeMaxQualityArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakePublishedTrack) 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 *FakePublishedTrack) NotifySubscriberNodeMediaLossCallCount() int { - fake.notifySubscriberNodeMediaLossMutex.RLock() - defer fake.notifySubscriberNodeMediaLossMutex.RUnlock() - return len(fake.notifySubscriberNodeMediaLossArgsForCall) -} - -func (fake *FakePublishedTrack) NotifySubscriberNodeMediaLossCalls(stub func(string, uint8)) { - fake.notifySubscriberNodeMediaLossMutex.Lock() - defer fake.notifySubscriberNodeMediaLossMutex.Unlock() - fake.NotifySubscriberNodeMediaLossStub = stub -} - -func (fake *FakePublishedTrack) NotifySubscriberNodeMediaLossArgsForCall(i int) (string, uint8) { - fake.notifySubscriberNodeMediaLossMutex.RLock() - defer fake.notifySubscriberNodeMediaLossMutex.RUnlock() - argsForCall := fake.notifySubscriberNodeMediaLossArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakePublishedTrack) OnSubscribedMaxQualityChange(arg1 func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error) { - fake.onSubscribedMaxQualityChangeMutex.Lock() - fake.onSubscribedMaxQualityChangeArgsForCall = append(fake.onSubscribedMaxQualityChangeArgsForCall, struct { - arg1 func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error - }{arg1}) - stub := fake.OnSubscribedMaxQualityChangeStub - fake.recordInvocation("OnSubscribedMaxQualityChange", []interface{}{arg1}) - fake.onSubscribedMaxQualityChangeMutex.Unlock() - if stub != nil { - fake.OnSubscribedMaxQualityChangeStub(arg1) - } -} - -func (fake *FakePublishedTrack) OnSubscribedMaxQualityChangeCallCount() int { - fake.onSubscribedMaxQualityChangeMutex.RLock() - defer fake.onSubscribedMaxQualityChangeMutex.RUnlock() - return len(fake.onSubscribedMaxQualityChangeArgsForCall) -} - -func (fake *FakePublishedTrack) OnSubscribedMaxQualityChangeCalls(stub func(func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error)) { - fake.onSubscribedMaxQualityChangeMutex.Lock() - defer fake.onSubscribedMaxQualityChangeMutex.Unlock() - fake.OnSubscribedMaxQualityChangeStub = stub -} - -func (fake *FakePublishedTrack) OnSubscribedMaxQualityChangeArgsForCall(i int) func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxQuality livekit.VideoQuality) error { - fake.onSubscribedMaxQualityChangeMutex.RLock() - defer fake.onSubscribedMaxQualityChangeMutex.RUnlock() - argsForCall := fake.onSubscribedMaxQualityChangeArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakePublishedTrack) PublisherID() livekit.ParticipantID { - fake.publisherIDMutex.Lock() - ret, specificReturn := fake.publisherIDReturnsOnCall[len(fake.publisherIDArgsForCall)] - fake.publisherIDArgsForCall = append(fake.publisherIDArgsForCall, struct { - }{}) - stub := fake.PublisherIDStub - fakeReturns := fake.publisherIDReturns - fake.recordInvocation("PublisherID", []interface{}{}) - fake.publisherIDMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) PublisherIDCallCount() int { - fake.publisherIDMutex.RLock() - defer fake.publisherIDMutex.RUnlock() - return len(fake.publisherIDArgsForCall) -} - -func (fake *FakePublishedTrack) PublisherIDCalls(stub func() livekit.ParticipantID) { - fake.publisherIDMutex.Lock() - defer fake.publisherIDMutex.Unlock() - fake.PublisherIDStub = stub -} - -func (fake *FakePublishedTrack) PublisherIDReturns(result1 livekit.ParticipantID) { - fake.publisherIDMutex.Lock() - defer fake.publisherIDMutex.Unlock() - fake.PublisherIDStub = nil - fake.publisherIDReturns = struct { - result1 livekit.ParticipantID - }{result1} -} - -func (fake *FakePublishedTrack) PublisherIDReturnsOnCall(i int, result1 livekit.ParticipantID) { - fake.publisherIDMutex.Lock() - defer fake.publisherIDMutex.Unlock() - fake.PublisherIDStub = nil - if fake.publisherIDReturnsOnCall == nil { - fake.publisherIDReturnsOnCall = make(map[int]struct { - result1 livekit.ParticipantID - }) - } - fake.publisherIDReturnsOnCall[i] = struct { - result1 livekit.ParticipantID - }{result1} -} - -func (fake *FakePublishedTrack) PublisherIdentity() livekit.ParticipantIdentity { - fake.publisherIdentityMutex.Lock() - ret, specificReturn := fake.publisherIdentityReturnsOnCall[len(fake.publisherIdentityArgsForCall)] - fake.publisherIdentityArgsForCall = append(fake.publisherIdentityArgsForCall, struct { - }{}) - stub := fake.PublisherIdentityStub - fakeReturns := fake.publisherIdentityReturns - fake.recordInvocation("PublisherIdentity", []interface{}{}) - fake.publisherIdentityMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) PublisherIdentityCallCount() int { - fake.publisherIdentityMutex.RLock() - defer fake.publisherIdentityMutex.RUnlock() - return len(fake.publisherIdentityArgsForCall) -} - -func (fake *FakePublishedTrack) PublisherIdentityCalls(stub func() livekit.ParticipantIdentity) { - fake.publisherIdentityMutex.Lock() - defer fake.publisherIdentityMutex.Unlock() - fake.PublisherIdentityStub = stub -} - -func (fake *FakePublishedTrack) PublisherIdentityReturns(result1 livekit.ParticipantIdentity) { - fake.publisherIdentityMutex.Lock() - defer fake.publisherIdentityMutex.Unlock() - fake.PublisherIdentityStub = nil - fake.publisherIdentityReturns = struct { - result1 livekit.ParticipantIdentity - }{result1} -} - -func (fake *FakePublishedTrack) PublisherIdentityReturnsOnCall(i int, result1 livekit.ParticipantIdentity) { - fake.publisherIdentityMutex.Lock() - defer fake.publisherIdentityMutex.Unlock() - fake.PublisherIdentityStub = nil - if fake.publisherIdentityReturnsOnCall == nil { - fake.publisherIdentityReturnsOnCall = make(map[int]struct { - result1 livekit.ParticipantIdentity - }) - } - fake.publisherIdentityReturnsOnCall[i] = struct { - result1 livekit.ParticipantIdentity - }{result1} -} - -func (fake *FakePublishedTrack) Receiver() sfu.TrackReceiver { - fake.receiverMutex.Lock() - ret, specificReturn := fake.receiverReturnsOnCall[len(fake.receiverArgsForCall)] - fake.receiverArgsForCall = append(fake.receiverArgsForCall, struct { - }{}) - stub := fake.ReceiverStub - fakeReturns := fake.receiverReturns - fake.recordInvocation("Receiver", []interface{}{}) - fake.receiverMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) ReceiverCallCount() int { - fake.receiverMutex.RLock() - defer fake.receiverMutex.RUnlock() - return len(fake.receiverArgsForCall) -} - -func (fake *FakePublishedTrack) ReceiverCalls(stub func() sfu.TrackReceiver) { - fake.receiverMutex.Lock() - defer fake.receiverMutex.Unlock() - fake.ReceiverStub = stub -} - -func (fake *FakePublishedTrack) ReceiverReturns(result1 sfu.TrackReceiver) { - fake.receiverMutex.Lock() - defer fake.receiverMutex.Unlock() - fake.ReceiverStub = nil - fake.receiverReturns = struct { - result1 sfu.TrackReceiver - }{result1} -} - -func (fake *FakePublishedTrack) ReceiverReturnsOnCall(i int, result1 sfu.TrackReceiver) { - fake.receiverMutex.Lock() - defer fake.receiverMutex.Unlock() - fake.ReceiverStub = nil - if fake.receiverReturnsOnCall == nil { - fake.receiverReturnsOnCall = make(map[int]struct { - result1 sfu.TrackReceiver - }) - } - fake.receiverReturnsOnCall[i] = struct { - result1 sfu.TrackReceiver - }{result1} -} - -func (fake *FakePublishedTrack) RemoveAllSubscribers() { - fake.removeAllSubscribersMutex.Lock() - fake.removeAllSubscribersArgsForCall = append(fake.removeAllSubscribersArgsForCall, struct { - }{}) - stub := fake.RemoveAllSubscribersStub - fake.recordInvocation("RemoveAllSubscribers", []interface{}{}) - fake.removeAllSubscribersMutex.Unlock() - if stub != nil { - fake.RemoveAllSubscribersStub() - } -} - -func (fake *FakePublishedTrack) RemoveAllSubscribersCallCount() int { - fake.removeAllSubscribersMutex.RLock() - defer fake.removeAllSubscribersMutex.RUnlock() - return len(fake.removeAllSubscribersArgsForCall) -} - -func (fake *FakePublishedTrack) RemoveAllSubscribersCalls(stub func()) { - fake.removeAllSubscribersMutex.Lock() - defer fake.removeAllSubscribersMutex.Unlock() - fake.RemoveAllSubscribersStub = stub -} - -func (fake *FakePublishedTrack) RemoveSubscriber(arg1 livekit.ParticipantID) { - fake.removeSubscriberMutex.Lock() - fake.removeSubscriberArgsForCall = append(fake.removeSubscriberArgsForCall, struct { - arg1 livekit.ParticipantID - }{arg1}) - stub := fake.RemoveSubscriberStub - fake.recordInvocation("RemoveSubscriber", []interface{}{arg1}) - fake.removeSubscriberMutex.Unlock() - if stub != nil { - fake.RemoveSubscriberStub(arg1) - } -} - -func (fake *FakePublishedTrack) RemoveSubscriberCallCount() int { - fake.removeSubscriberMutex.RLock() - defer fake.removeSubscriberMutex.RUnlock() - return len(fake.removeSubscriberArgsForCall) -} - -func (fake *FakePublishedTrack) RemoveSubscriberCalls(stub func(livekit.ParticipantID)) { - fake.removeSubscriberMutex.Lock() - defer fake.removeSubscriberMutex.Unlock() - fake.RemoveSubscriberStub = stub -} - -func (fake *FakePublishedTrack) RemoveSubscriberArgsForCall(i int) livekit.ParticipantID { - fake.removeSubscriberMutex.RLock() - defer fake.removeSubscriberMutex.RUnlock() - argsForCall := fake.removeSubscriberArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakePublishedTrack) RevokeDisallowedSubscribers(arg1 []livekit.ParticipantID) []livekit.ParticipantID { - var arg1Copy []livekit.ParticipantID - if arg1 != nil { - arg1Copy = make([]livekit.ParticipantID, len(arg1)) - copy(arg1Copy, arg1) - } - fake.revokeDisallowedSubscribersMutex.Lock() - ret, specificReturn := fake.revokeDisallowedSubscribersReturnsOnCall[len(fake.revokeDisallowedSubscribersArgsForCall)] - fake.revokeDisallowedSubscribersArgsForCall = append(fake.revokeDisallowedSubscribersArgsForCall, struct { - arg1 []livekit.ParticipantID - }{arg1Copy}) - stub := fake.RevokeDisallowedSubscribersStub - fakeReturns := fake.revokeDisallowedSubscribersReturns - fake.recordInvocation("RevokeDisallowedSubscribers", []interface{}{arg1Copy}) - fake.revokeDisallowedSubscribersMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) RevokeDisallowedSubscribersCallCount() int { - fake.revokeDisallowedSubscribersMutex.RLock() - defer fake.revokeDisallowedSubscribersMutex.RUnlock() - return len(fake.revokeDisallowedSubscribersArgsForCall) -} - -func (fake *FakePublishedTrack) RevokeDisallowedSubscribersCalls(stub func([]livekit.ParticipantID) []livekit.ParticipantID) { - fake.revokeDisallowedSubscribersMutex.Lock() - defer fake.revokeDisallowedSubscribersMutex.Unlock() - fake.RevokeDisallowedSubscribersStub = stub -} - -func (fake *FakePublishedTrack) RevokeDisallowedSubscribersArgsForCall(i int) []livekit.ParticipantID { - fake.revokeDisallowedSubscribersMutex.RLock() - defer fake.revokeDisallowedSubscribersMutex.RUnlock() - argsForCall := fake.revokeDisallowedSubscribersArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakePublishedTrack) RevokeDisallowedSubscribersReturns(result1 []livekit.ParticipantID) { - fake.revokeDisallowedSubscribersMutex.Lock() - defer fake.revokeDisallowedSubscribersMutex.Unlock() - fake.RevokeDisallowedSubscribersStub = nil - fake.revokeDisallowedSubscribersReturns = struct { - result1 []livekit.ParticipantID - }{result1} -} - -func (fake *FakePublishedTrack) RevokeDisallowedSubscribersReturnsOnCall(i int, result1 []livekit.ParticipantID) { - fake.revokeDisallowedSubscribersMutex.Lock() - defer fake.revokeDisallowedSubscribersMutex.Unlock() - fake.RevokeDisallowedSubscribersStub = nil - if fake.revokeDisallowedSubscribersReturnsOnCall == nil { - fake.revokeDisallowedSubscribersReturnsOnCall = make(map[int]struct { - result1 []livekit.ParticipantID - }) - } - fake.revokeDisallowedSubscribersReturnsOnCall[i] = struct { - result1 []livekit.ParticipantID - }{result1} -} - -func (fake *FakePublishedTrack) 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 *FakePublishedTrack) SdpCidCallCount() int { - fake.sdpCidMutex.RLock() - defer fake.sdpCidMutex.RUnlock() - return len(fake.sdpCidArgsForCall) -} - -func (fake *FakePublishedTrack) SdpCidCalls(stub func() string) { - fake.sdpCidMutex.Lock() - defer fake.sdpCidMutex.Unlock() - fake.SdpCidStub = stub -} - -func (fake *FakePublishedTrack) SdpCidReturns(result1 string) { - fake.sdpCidMutex.Lock() - defer fake.sdpCidMutex.Unlock() - fake.SdpCidStub = nil - fake.sdpCidReturns = struct { - result1 string - }{result1} -} - -func (fake *FakePublishedTrack) 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 *FakePublishedTrack) SetMuted(arg1 bool) { - fake.setMutedMutex.Lock() - fake.setMutedArgsForCall = append(fake.setMutedArgsForCall, struct { - arg1 bool - }{arg1}) - stub := fake.SetMutedStub - fake.recordInvocation("SetMuted", []interface{}{arg1}) - fake.setMutedMutex.Unlock() - if stub != nil { - fake.SetMutedStub(arg1) - } -} - -func (fake *FakePublishedTrack) SetMutedCallCount() int { - fake.setMutedMutex.RLock() - defer fake.setMutedMutex.RUnlock() - return len(fake.setMutedArgsForCall) -} - -func (fake *FakePublishedTrack) SetMutedCalls(stub func(bool)) { - fake.setMutedMutex.Lock() - defer fake.setMutedMutex.Unlock() - fake.SetMutedStub = stub -} - -func (fake *FakePublishedTrack) SetMutedArgsForCall(i int) bool { - fake.setMutedMutex.RLock() - defer fake.setMutedMutex.RUnlock() - argsForCall := fake.setMutedArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakePublishedTrack) 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 *FakePublishedTrack) SignalCidCallCount() int { - fake.signalCidMutex.RLock() - defer fake.signalCidMutex.RUnlock() - return len(fake.signalCidArgsForCall) -} - -func (fake *FakePublishedTrack) SignalCidCalls(stub func() string) { - fake.signalCidMutex.Lock() - defer fake.signalCidMutex.Unlock() - fake.SignalCidStub = stub -} - -func (fake *FakePublishedTrack) SignalCidReturns(result1 string) { - fake.signalCidMutex.Lock() - defer fake.signalCidMutex.Unlock() - fake.SignalCidStub = nil - fake.signalCidReturns = struct { - result1 string - }{result1} -} - -func (fake *FakePublishedTrack) 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 *FakePublishedTrack) Source() livekit.TrackSource { - fake.sourceMutex.Lock() - ret, specificReturn := fake.sourceReturnsOnCall[len(fake.sourceArgsForCall)] - fake.sourceArgsForCall = append(fake.sourceArgsForCall, struct { - }{}) - stub := fake.SourceStub - fakeReturns := fake.sourceReturns - fake.recordInvocation("Source", []interface{}{}) - fake.sourceMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) SourceCallCount() int { - fake.sourceMutex.RLock() - defer fake.sourceMutex.RUnlock() - return len(fake.sourceArgsForCall) -} - -func (fake *FakePublishedTrack) SourceCalls(stub func() livekit.TrackSource) { - fake.sourceMutex.Lock() - defer fake.sourceMutex.Unlock() - fake.SourceStub = stub -} - -func (fake *FakePublishedTrack) SourceReturns(result1 livekit.TrackSource) { - fake.sourceMutex.Lock() - defer fake.sourceMutex.Unlock() - fake.SourceStub = nil - fake.sourceReturns = struct { - result1 livekit.TrackSource - }{result1} -} - -func (fake *FakePublishedTrack) SourceReturnsOnCall(i int, result1 livekit.TrackSource) { - fake.sourceMutex.Lock() - defer fake.sourceMutex.Unlock() - fake.SourceStub = nil - if fake.sourceReturnsOnCall == nil { - fake.sourceReturnsOnCall = make(map[int]struct { - result1 livekit.TrackSource - }) - } - fake.sourceReturnsOnCall[i] = struct { - result1 livekit.TrackSource - }{result1} -} - -func (fake *FakePublishedTrack) ToProto() *livekit.TrackInfo { - fake.toProtoMutex.Lock() - ret, specificReturn := fake.toProtoReturnsOnCall[len(fake.toProtoArgsForCall)] - fake.toProtoArgsForCall = append(fake.toProtoArgsForCall, struct { - }{}) - stub := fake.ToProtoStub - fakeReturns := fake.toProtoReturns - fake.recordInvocation("ToProto", []interface{}{}) - fake.toProtoMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakePublishedTrack) ToProtoCallCount() int { - fake.toProtoMutex.RLock() - defer fake.toProtoMutex.RUnlock() - return len(fake.toProtoArgsForCall) -} - -func (fake *FakePublishedTrack) ToProtoCalls(stub func() *livekit.TrackInfo) { - fake.toProtoMutex.Lock() - defer fake.toProtoMutex.Unlock() - fake.ToProtoStub = stub -} - -func (fake *FakePublishedTrack) ToProtoReturns(result1 *livekit.TrackInfo) { - fake.toProtoMutex.Lock() - defer fake.toProtoMutex.Unlock() - fake.ToProtoStub = nil - fake.toProtoReturns = struct { - result1 *livekit.TrackInfo - }{result1} -} - -func (fake *FakePublishedTrack) ToProtoReturnsOnCall(i int, result1 *livekit.TrackInfo) { - fake.toProtoMutex.Lock() - defer fake.toProtoMutex.Unlock() - fake.ToProtoStub = nil - if fake.toProtoReturnsOnCall == nil { - fake.toProtoReturnsOnCall = make(map[int]struct { - result1 *livekit.TrackInfo - }) - } - fake.toProtoReturnsOnCall[i] = struct { - result1 *livekit.TrackInfo - }{result1} -} - -func (fake *FakePublishedTrack) UpdateVideoLayers(arg1 []*livekit.VideoLayer) { - var arg1Copy []*livekit.VideoLayer - if arg1 != nil { - arg1Copy = make([]*livekit.VideoLayer, len(arg1)) - copy(arg1Copy, arg1) - } - fake.updateVideoLayersMutex.Lock() - fake.updateVideoLayersArgsForCall = append(fake.updateVideoLayersArgsForCall, struct { - arg1 []*livekit.VideoLayer - }{arg1Copy}) - stub := fake.UpdateVideoLayersStub - fake.recordInvocation("UpdateVideoLayers", []interface{}{arg1Copy}) - fake.updateVideoLayersMutex.Unlock() - if stub != nil { - fake.UpdateVideoLayersStub(arg1) - } -} - -func (fake *FakePublishedTrack) UpdateVideoLayersCallCount() int { - fake.updateVideoLayersMutex.RLock() - defer fake.updateVideoLayersMutex.RUnlock() - return len(fake.updateVideoLayersArgsForCall) -} - -func (fake *FakePublishedTrack) UpdateVideoLayersCalls(stub func([]*livekit.VideoLayer)) { - fake.updateVideoLayersMutex.Lock() - defer fake.updateVideoLayersMutex.Unlock() - fake.UpdateVideoLayersStub = stub -} - -func (fake *FakePublishedTrack) UpdateVideoLayersArgsForCall(i int) []*livekit.VideoLayer { - fake.updateVideoLayersMutex.RLock() - defer fake.updateVideoLayersMutex.RUnlock() - argsForCall := fake.updateVideoLayersArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakePublishedTrack) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.addOnCloseMutex.RLock() - defer fake.addOnCloseMutex.RUnlock() - fake.addSubscriberMutex.RLock() - defer fake.addSubscriberMutex.RUnlock() - fake.getAllSubscriberIDsMutex.RLock() - defer fake.getAllSubscriberIDsMutex.RUnlock() - fake.getAudioLevelMutex.RLock() - defer fake.getAudioLevelMutex.RUnlock() - fake.getConnectionScoreMutex.RLock() - defer fake.getConnectionScoreMutex.RUnlock() - fake.getQualityForDimensionMutex.RLock() - defer fake.getQualityForDimensionMutex.RUnlock() - fake.iDMutex.RLock() - defer fake.iDMutex.RUnlock() - fake.isMutedMutex.RLock() - defer fake.isMutedMutex.RUnlock() - fake.isSimulcastMutex.RLock() - defer fake.isSimulcastMutex.RUnlock() - fake.isSubscriberMutex.RLock() - defer fake.isSubscriberMutex.RUnlock() - fake.kindMutex.RLock() - defer fake.kindMutex.RUnlock() - fake.nameMutex.RLock() - defer fake.nameMutex.RUnlock() - fake.notifySubscriberMaxQualityMutex.RLock() - defer fake.notifySubscriberMaxQualityMutex.RUnlock() - fake.notifySubscriberNodeMaxQualityMutex.RLock() - defer fake.notifySubscriberNodeMaxQualityMutex.RUnlock() - fake.notifySubscriberNodeMediaLossMutex.RLock() - defer fake.notifySubscriberNodeMediaLossMutex.RUnlock() - fake.onSubscribedMaxQualityChangeMutex.RLock() - defer fake.onSubscribedMaxQualityChangeMutex.RUnlock() - fake.publisherIDMutex.RLock() - defer fake.publisherIDMutex.RUnlock() - fake.publisherIdentityMutex.RLock() - defer fake.publisherIdentityMutex.RUnlock() - fake.receiverMutex.RLock() - defer fake.receiverMutex.RUnlock() - fake.removeAllSubscribersMutex.RLock() - defer fake.removeAllSubscribersMutex.RUnlock() - fake.removeSubscriberMutex.RLock() - defer fake.removeSubscriberMutex.RUnlock() - fake.revokeDisallowedSubscribersMutex.RLock() - defer fake.revokeDisallowedSubscribersMutex.RUnlock() - fake.sdpCidMutex.RLock() - defer fake.sdpCidMutex.RUnlock() - fake.setMutedMutex.RLock() - defer fake.setMutedMutex.RUnlock() - fake.signalCidMutex.RLock() - defer fake.signalCidMutex.RUnlock() - fake.sourceMutex.RLock() - defer fake.sourceMutex.RUnlock() - fake.toProtoMutex.RLock() - defer fake.toProtoMutex.RUnlock() - fake.updateVideoLayersMutex.RLock() - defer fake.updateVideoLayersMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakePublishedTrack) 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.PublishedTrack = new(FakePublishedTrack) diff --git a/pkg/rtc/types/typesfakes/fake_room.go b/pkg/rtc/types/typesfakes/fake_room.go index 5c447c890..850e18f26 100644 --- a/pkg/rtc/types/typesfakes/fake_room.go +++ b/pkg/rtc/types/typesfakes/fake_room.go @@ -19,10 +19,10 @@ type FakeRoom struct { nameReturnsOnCall map[int]struct { result1 livekit.RoomName } - SimulateScenarioStub func(types.Participant, *livekit.SimulateScenario) error + SimulateScenarioStub func(types.LocalParticipant, *livekit.SimulateScenario) error simulateScenarioMutex sync.RWMutex simulateScenarioArgsForCall []struct { - arg1 types.Participant + arg1 types.LocalParticipant arg2 *livekit.SimulateScenario } simulateScenarioReturns struct { @@ -31,10 +31,10 @@ type FakeRoom struct { simulateScenarioReturnsOnCall map[int]struct { result1 error } - SyncStateStub func(types.Participant, *livekit.SyncState) error + SyncStateStub func(types.LocalParticipant, *livekit.SyncState) error syncStateMutex sync.RWMutex syncStateArgsForCall []struct { - arg1 types.Participant + arg1 types.LocalParticipant arg2 *livekit.SyncState } syncStateReturns struct { @@ -55,10 +55,10 @@ type FakeRoom struct { updateSubscriptionPermissionsReturnsOnCall map[int]struct { result1 error } - UpdateSubscriptionsStub func(types.Participant, []livekit.TrackID, []*livekit.ParticipantTracks, bool) error + UpdateSubscriptionsStub func(types.LocalParticipant, []livekit.TrackID, []*livekit.ParticipantTracks, bool) error updateSubscriptionsMutex sync.RWMutex updateSubscriptionsArgsForCall []struct { - arg1 types.Participant + arg1 types.LocalParticipant arg2 []livekit.TrackID arg3 []*livekit.ParticipantTracks arg4 bool @@ -138,11 +138,11 @@ func (fake *FakeRoom) NameReturnsOnCall(i int, result1 livekit.RoomName) { }{result1} } -func (fake *FakeRoom) SimulateScenario(arg1 types.Participant, arg2 *livekit.SimulateScenario) error { +func (fake *FakeRoom) SimulateScenario(arg1 types.LocalParticipant, arg2 *livekit.SimulateScenario) error { fake.simulateScenarioMutex.Lock() ret, specificReturn := fake.simulateScenarioReturnsOnCall[len(fake.simulateScenarioArgsForCall)] fake.simulateScenarioArgsForCall = append(fake.simulateScenarioArgsForCall, struct { - arg1 types.Participant + arg1 types.LocalParticipant arg2 *livekit.SimulateScenario }{arg1, arg2}) stub := fake.SimulateScenarioStub @@ -164,13 +164,13 @@ func (fake *FakeRoom) SimulateScenarioCallCount() int { return len(fake.simulateScenarioArgsForCall) } -func (fake *FakeRoom) SimulateScenarioCalls(stub func(types.Participant, *livekit.SimulateScenario) error) { +func (fake *FakeRoom) SimulateScenarioCalls(stub func(types.LocalParticipant, *livekit.SimulateScenario) error) { fake.simulateScenarioMutex.Lock() defer fake.simulateScenarioMutex.Unlock() fake.SimulateScenarioStub = stub } -func (fake *FakeRoom) SimulateScenarioArgsForCall(i int) (types.Participant, *livekit.SimulateScenario) { +func (fake *FakeRoom) SimulateScenarioArgsForCall(i int) (types.LocalParticipant, *livekit.SimulateScenario) { fake.simulateScenarioMutex.RLock() defer fake.simulateScenarioMutex.RUnlock() argsForCall := fake.simulateScenarioArgsForCall[i] @@ -200,11 +200,11 @@ func (fake *FakeRoom) SimulateScenarioReturnsOnCall(i int, result1 error) { }{result1} } -func (fake *FakeRoom) SyncState(arg1 types.Participant, arg2 *livekit.SyncState) error { +func (fake *FakeRoom) SyncState(arg1 types.LocalParticipant, arg2 *livekit.SyncState) error { fake.syncStateMutex.Lock() ret, specificReturn := fake.syncStateReturnsOnCall[len(fake.syncStateArgsForCall)] fake.syncStateArgsForCall = append(fake.syncStateArgsForCall, struct { - arg1 types.Participant + arg1 types.LocalParticipant arg2 *livekit.SyncState }{arg1, arg2}) stub := fake.SyncStateStub @@ -226,13 +226,13 @@ func (fake *FakeRoom) SyncStateCallCount() int { return len(fake.syncStateArgsForCall) } -func (fake *FakeRoom) SyncStateCalls(stub func(types.Participant, *livekit.SyncState) error) { +func (fake *FakeRoom) SyncStateCalls(stub func(types.LocalParticipant, *livekit.SyncState) error) { fake.syncStateMutex.Lock() defer fake.syncStateMutex.Unlock() fake.SyncStateStub = stub } -func (fake *FakeRoom) SyncStateArgsForCall(i int) (types.Participant, *livekit.SyncState) { +func (fake *FakeRoom) SyncStateArgsForCall(i int) (types.LocalParticipant, *livekit.SyncState) { fake.syncStateMutex.RLock() defer fake.syncStateMutex.RUnlock() argsForCall := fake.syncStateArgsForCall[i] @@ -324,7 +324,7 @@ func (fake *FakeRoom) UpdateSubscriptionPermissionsReturnsOnCall(i int, result1 }{result1} } -func (fake *FakeRoom) UpdateSubscriptions(arg1 types.Participant, arg2 []livekit.TrackID, arg3 []*livekit.ParticipantTracks, arg4 bool) error { +func (fake *FakeRoom) UpdateSubscriptions(arg1 types.LocalParticipant, arg2 []livekit.TrackID, arg3 []*livekit.ParticipantTracks, arg4 bool) error { var arg2Copy []livekit.TrackID if arg2 != nil { arg2Copy = make([]livekit.TrackID, len(arg2)) @@ -338,7 +338,7 @@ func (fake *FakeRoom) UpdateSubscriptions(arg1 types.Participant, arg2 []livekit fake.updateSubscriptionsMutex.Lock() ret, specificReturn := fake.updateSubscriptionsReturnsOnCall[len(fake.updateSubscriptionsArgsForCall)] fake.updateSubscriptionsArgsForCall = append(fake.updateSubscriptionsArgsForCall, struct { - arg1 types.Participant + arg1 types.LocalParticipant arg2 []livekit.TrackID arg3 []*livekit.ParticipantTracks arg4 bool @@ -362,13 +362,13 @@ func (fake *FakeRoom) UpdateSubscriptionsCallCount() int { return len(fake.updateSubscriptionsArgsForCall) } -func (fake *FakeRoom) UpdateSubscriptionsCalls(stub func(types.Participant, []livekit.TrackID, []*livekit.ParticipantTracks, bool) error) { +func (fake *FakeRoom) UpdateSubscriptionsCalls(stub func(types.LocalParticipant, []livekit.TrackID, []*livekit.ParticipantTracks, bool) error) { fake.updateSubscriptionsMutex.Lock() defer fake.updateSubscriptionsMutex.Unlock() fake.UpdateSubscriptionsStub = stub } -func (fake *FakeRoom) UpdateSubscriptionsArgsForCall(i int) (types.Participant, []livekit.TrackID, []*livekit.ParticipantTracks, bool) { +func (fake *FakeRoom) UpdateSubscriptionsArgsForCall(i int) (types.LocalParticipant, []livekit.TrackID, []*livekit.ParticipantTracks, bool) { fake.updateSubscriptionsMutex.RLock() defer fake.updateSubscriptionsMutex.RUnlock() argsForCall := fake.updateSubscriptionsArgsForCall[i] diff --git a/pkg/rtc/uptrackmanager.go b/pkg/rtc/uptrackmanager.go index 68a3c5735..f6d893d92 100644 --- a/pkg/rtc/uptrackmanager.go +++ b/pkg/rtc/uptrackmanager.go @@ -21,7 +21,7 @@ type UptrackManager struct { closed bool // publishedTracks that participant is publishing - publishedTracks map[livekit.TrackID]types.PublishedTrack + publishedTracks map[livekit.TrackID]types.MediaTrack // keeps track of subscriptions that are awaiting permissions subscriptionPermissions map[livekit.ParticipantID]*livekit.TrackPermission // subscriberID => *livekit.TrackPermission // keeps tracks of track specific subscribers who are awaiting permission @@ -31,14 +31,14 @@ type UptrackManager struct { // callbacks & handlers onClose func() - onTrackUpdated func(track types.PublishedTrack, onlyIfReady bool) + onTrackUpdated func(track types.MediaTrack, onlyIfReady bool) onSubscribedMaxQualityChange func(trackID livekit.TrackID, subscribedQualities []*livekit.SubscribedQuality, maxSubscribedQuality livekit.VideoQuality) error } func NewUptrackManager(params UptrackManagerParams) *UptrackManager { return &UptrackManager{ params: params, - publishedTracks: make(map[livekit.TrackID]types.PublishedTrack, 0), + publishedTracks: make(map[livekit.TrackID]types.MediaTrack, 0), pendingSubscriptions: make(map[livekit.TrackID][]livekit.ParticipantID), } } @@ -79,7 +79,7 @@ func (u *UptrackManager) ToProto() []*livekit.TrackInfo { return trackInfos } -func (u *UptrackManager) OnPublishedTrackUpdated(f func(track types.PublishedTrack, onlyIfReady bool)) { +func (u *UptrackManager) OnPublishedTrackUpdated(f func(track types.MediaTrack, onlyIfReady bool)) { u.onTrackUpdated = f } @@ -88,8 +88,8 @@ func (u *UptrackManager) OnSubscribedMaxQualityChange(f func(trackID livekit.Tra } // AddSubscriber subscribes op to all publishedTracks -func (u *UptrackManager) AddSubscriber(sub types.Participant, params types.AddSubscriberParams) (int, error) { - var tracks []types.PublishedTrack +func (u *UptrackManager) AddSubscriber(sub types.LocalParticipant, params types.AddSubscriberParams) (int, error) { + var tracks []types.MediaTrack if params.AllTracks { tracks = u.GetPublishedTracks() } else { @@ -132,7 +132,7 @@ func (u *UptrackManager) AddSubscriber(sub types.Participant, params types.AddSu return n, nil } -func (u *UptrackManager) RemoveSubscriber(sub types.Participant, trackID livekit.TrackID) { +func (u *UptrackManager) RemoveSubscriber(sub types.LocalParticipant, trackID livekit.TrackID) { track := u.GetPublishedTrack(trackID) if track != nil { track.RemoveSubscriber(sub.ID()) @@ -143,7 +143,7 @@ func (u *UptrackManager) RemoveSubscriber(sub types.Participant, trackID livekit u.lock.Unlock() } -func (u *UptrackManager) SetPublishedTrackMuted(trackID livekit.TrackID, muted bool) types.PublishedTrack { +func (u *UptrackManager) SetPublishedTrackMuted(trackID livekit.TrackID, muted bool) types.MediaTrack { u.lock.RLock() track := u.publishedTracks[trackID] u.lock.RUnlock() @@ -163,18 +163,18 @@ func (u *UptrackManager) SetPublishedTrackMuted(trackID livekit.TrackID, muted b return track } -func (u *UptrackManager) GetPublishedTrack(trackID livekit.TrackID) types.PublishedTrack { +func (u *UptrackManager) GetPublishedTrack(trackID livekit.TrackID) types.MediaTrack { u.lock.RLock() defer u.lock.RUnlock() return u.getPublishedTrack(trackID) } -func (u *UptrackManager) GetPublishedTracks() []types.PublishedTrack { +func (u *UptrackManager) GetPublishedTracks() []types.MediaTrack { u.lock.RLock() defer u.lock.RUnlock() - tracks := make([]types.PublishedTrack, 0, len(u.publishedTracks)) + tracks := make([]types.MediaTrack, 0, len(u.publishedTracks)) for _, t := range u.publishedTracks { tracks = append(tracks, t) } @@ -183,7 +183,7 @@ func (u *UptrackManager) GetPublishedTracks() []types.PublishedTrack { func (u *UptrackManager) UpdateSubscriptionPermissions( permissions *livekit.UpdateSubscriptionPermissions, - resolver func(participantID livekit.ParticipantID) types.Participant, + resolver func(participantID livekit.ParticipantID) types.LocalParticipant, ) error { u.lock.Lock() defer u.lock.Unlock() @@ -207,7 +207,7 @@ func (u *UptrackManager) UpdateVideoLayers(updateVideoLayers *livekit.UpdateVide return nil } -func (u *UptrackManager) AddPublishedTrack(track types.PublishedTrack) { +func (u *UptrackManager) AddPublishedTrack(track types.MediaTrack) { track.OnSubscribedMaxQualityChange(u.onSubscribedMaxQualityChange) u.lock.Lock() @@ -242,56 +242,15 @@ func (u *UptrackManager) AddPublishedTrack(track types.PublishedTrack) { }) } -func (u *UptrackManager) RemovePublishedTrack(track types.PublishedTrack) { +func (u *UptrackManager) RemovePublishedTrack(track types.MediaTrack) { track.RemoveAllSubscribers() } // should be called with lock held -func (u *UptrackManager) getPublishedTrack(trackID livekit.TrackID) types.PublishedTrack { +func (u *UptrackManager) getPublishedTrack(trackID livekit.TrackID) types.MediaTrack { return u.publishedTracks[trackID] } -func (u *UptrackManager) GetPublishedTrackBySignalCidOrSdpCid(clientId string) types.PublishedTrack { - u.lock.RLock() - defer u.lock.RUnlock() - - track := u.getPublishedTrackBySignalCid(clientId) - if track == nil { - track = u.getPublishedTrackBySdpCid(clientId) - } - - return track -} - -// should be called with lock held -func (u *UptrackManager) getPublishedTrackBySignalCid(clientId string) types.PublishedTrack { - for _, publishedTrack := range u.publishedTracks { - if publishedTrack.SignalCid() == clientId { - return publishedTrack - } - } - - return nil -} - -func (u *UptrackManager) GetPublishedTrackBySdpCid(clientId string) types.PublishedTrack { - u.lock.RLock() - defer u.lock.RUnlock() - - return u.getPublishedTrackBySdpCid(clientId) -} - -// should be called with lock held -func (u *UptrackManager) getPublishedTrackBySdpCid(clientId string) types.PublishedTrack { - for _, publishedTrack := range u.publishedTracks { - if publishedTrack.SdpCid() == clientId { - return publishedTrack - } - } - - return nil -} - func (u *UptrackManager) updateSubscriptionPermissions(permissions *livekit.UpdateSubscriptionPermissions) { // every update overrides the existing @@ -355,7 +314,7 @@ func (u *UptrackManager) getAllowedSubscribers(trackID livekit.TrackID) []liveki return allowed } -func (u *UptrackManager) maybeAddPendingSubscription(trackID livekit.TrackID, sub types.Participant) { +func (u *UptrackManager) maybeAddPendingSubscription(trackID livekit.TrackID, sub types.LocalParticipant) { subscriberID := sub.ID() pending := u.pendingSubscriptions[trackID] @@ -370,7 +329,7 @@ func (u *UptrackManager) maybeAddPendingSubscription(trackID livekit.TrackID, su go sub.SubscriptionPermissionUpdate(u.params.SID, trackID, false) } -func (u *UptrackManager) maybeRemovePendingSubscription(trackID livekit.TrackID, sub types.Participant) { +func (u *UptrackManager) maybeRemovePendingSubscription(trackID livekit.TrackID, sub types.LocalParticipant) { subscriberID := sub.ID() pending := u.pendingSubscriptions[trackID] @@ -387,7 +346,7 @@ func (u *UptrackManager) maybeRemovePendingSubscription(trackID livekit.TrackID, } } -func (u *UptrackManager) processPendingSubscriptions(resolver func(participantID livekit.ParticipantID) types.Participant) { +func (u *UptrackManager) processPendingSubscriptions(resolver func(participantID livekit.ParticipantID) types.LocalParticipant) { updatedPendingSubscriptions := make(map[livekit.TrackID][]livekit.ParticipantID) for trackID, pending := range u.pendingSubscriptions { track := u.getPublishedTrack(trackID) @@ -397,7 +356,7 @@ func (u *UptrackManager) processPendingSubscriptions(resolver func(participantID var updatedPending []livekit.ParticipantID for _, sid := range pending { - var sub types.Participant + var sub types.LocalParticipant if resolver != nil { sub = resolver(sid) } @@ -427,7 +386,7 @@ func (u *UptrackManager) processPendingSubscriptions(resolver func(participantID u.pendingSubscriptions = updatedPendingSubscriptions } -func (u *UptrackManager) maybeRevokeSubscriptions(resolver func(participantID livekit.ParticipantID) types.Participant) { +func (u *UptrackManager) maybeRevokeSubscriptions(resolver func(participantID livekit.ParticipantID) types.LocalParticipant) { for _, track := range u.publishedTracks { trackID := track.ID() allowed := u.getAllowedSubscribers(trackID) @@ -438,7 +397,7 @@ func (u *UptrackManager) maybeRevokeSubscriptions(resolver func(participantID li revokedSubscribers := track.RevokeDisallowedSubscribers(allowed) for _, subID := range revokedSubscribers { - var sub types.Participant + var sub types.LocalParticipant if resolver != nil { sub = resolver(subID) } diff --git a/pkg/rtc/uptrackmanager_test.go b/pkg/rtc/uptrackmanager_test.go index 8d6601842..f40af8281 100644 --- a/pkg/rtc/uptrackmanager_test.go +++ b/pkg/rtc/uptrackmanager_test.go @@ -12,11 +12,11 @@ func TestUpdateSubscriptionPermissions(t *testing.T) { t.Run("updates permissions", func(t *testing.T) { um := NewUptrackManager(UptrackManagerParams{}) - tra := &typesfakes.FakePublishedTrack{} + tra := &typesfakes.FakeMediaTrack{} tra.IDReturns("audio") um.publishedTracks["audio"] = tra - trv := &typesfakes.FakePublishedTrack{} + trv := &typesfakes.FakeMediaTrack{} trv.IDReturns("video") um.publishedTracks["video"] = trv @@ -87,11 +87,11 @@ func TestPermissions(t *testing.T) { t.Run("checks permissions", func(t *testing.T) { um := NewUptrackManager(UptrackManagerParams{}) - tra := &typesfakes.FakePublishedTrack{} + tra := &typesfakes.FakeMediaTrack{} tra.IDReturns("audio") um.publishedTracks["audio"] = tra - trv := &typesfakes.FakePublishedTrack{} + trv := &typesfakes.FakeMediaTrack{} trv.IDReturns("video") um.publishedTracks["video"] = trv @@ -131,7 +131,7 @@ func TestPermissions(t *testing.T) { require.True(t, um.hasPermission("video", "p2")) // add a new track after permissions are set - trs := &typesfakes.FakePublishedTrack{} + trs := &typesfakes.FakeMediaTrack{} trs.IDReturns("screen") um.publishedTracks["screen"] = trs @@ -173,7 +173,7 @@ func TestPermissions(t *testing.T) { require.False(t, um.hasPermission("screen", "p3")) // add a new track after restrictive permissions are set - trw := &typesfakes.FakePublishedTrack{} + trw := &typesfakes.FakeMediaTrack{} trw.IDReturns("watch") um.publishedTracks["watch"] = trw diff --git a/pkg/rtc/utils.go b/pkg/rtc/utils.go index ebc2c653b..e39548b86 100644 --- a/pkg/rtc/utils.go +++ b/pkg/rtc/utils.go @@ -50,7 +50,7 @@ func FixedPointToPercent(frac uint8) uint32 { return (uint32(frac) * 100) >> 8 } -func ToProtoParticipants(participants []types.Participant) []*livekit.ParticipantInfo { +func ToProtoParticipants(participants []types.LocalParticipant) []*livekit.ParticipantInfo { infos := make([]*livekit.ParticipantInfo, 0, len(participants)) for _, op := range participants { infos = append(infos, op.ToProto()) diff --git a/pkg/service/roommanager.go b/pkg/service/roommanager.go index 7240308c3..00f252758 100644 --- a/pkg/service/roommanager.go +++ b/pkg/service/roommanager.go @@ -277,7 +277,7 @@ func (r *RoomManager) StartSession(ctx context.Context, roomName livekit.RoomNam } r.telemetry.ParticipantJoined(ctx, room.Room, participant.ToProto(), pi.Client) - participant.OnClose(func(p types.Participant, disallowedSubscriptions map[livekit.TrackID]livekit.ParticipantID) { + participant.OnClose(func(p types.LocalParticipant, disallowedSubscriptions map[livekit.TrackID]livekit.ParticipantID) { if err := r.roomStore.DeleteParticipant(ctx, roomName, p.Identity()); err != nil { pLogger.Errorw("could not delete participant", err) } @@ -329,7 +329,7 @@ func (r *RoomManager) getOrCreateRoom(ctx context.Context, roomName livekit.Room logger.Errorw("could not handle metadata update", err) } }) - room.OnParticipantChanged(func(p types.Participant) { + room.OnParticipantChanged(func(p types.LocalParticipant) { if p.State() != livekit.ParticipantInfo_DISCONNECTED { if err := r.roomStore.StoreParticipant(ctx, roomName, p.ToProto()); err != nil { logger.Errorw("could not handle participant change", err) @@ -344,7 +344,7 @@ func (r *RoomManager) getOrCreateRoom(ctx context.Context, roomName livekit.Room } // manages an RTC session for a participant, runs on the RTC node -func (r *RoomManager) rtcSessionWorker(room *rtc.Room, participant types.Participant, requestSource routing.MessageSource) { +func (r *RoomManager) rtcSessionWorker(room *rtc.Room, participant types.LocalParticipant, requestSource routing.MessageSource) { defer func() { logger.Debugw("RTC session finishing", "participant", participant.Identity(),