snapshot of https://github.com/livekit/livekit.git @ 08c5433449c106943231037d0b892895f6e92d3b (2026-09-15)

pkg/rtc/types/ice.go

@@ -0,0 +1,414 @@
+/*
+ * Copyright 2023 LiveKit, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package types
+
+import (
+	"fmt"
+	"slices"
+	"strings"
+	"sync"
+
+	"github.com/pion/ice/v4"
+	"github.com/pion/webrtc/v4"
+
+	"github.com/livekit/protocol/livekit"
+	"github.com/livekit/protocol/logger"
+	"github.com/livekit/protocol/observability/roomobs"
+)
+
+type ICEConnectionType int
+
+const (
+	// this is in ICE priority highest -> lowest ordering
+	// WARNING: Keep this ordering as it is used to find lowest priority connection type.
+	ICEConnectionTypeUnknown ICEConnectionType = iota
+	ICEConnectionTypeUDP
+	ICEConnectionTypeTCP
+	ICEConnectionTypeTURN
+)
+
+func (i ICEConnectionType) String() string {
+	switch i {
+	case ICEConnectionTypeUnknown:
+		return "unknown"
+	case ICEConnectionTypeUDP:
+		return "udp"
+	case ICEConnectionTypeTCP:
+		return "tcp"
+	case ICEConnectionTypeTURN:
+		return "turn"
+	default:
+		return "unknown"
+	}
+}
+
+func (i ICEConnectionType) ReporterType() roomobs.ConnectionType {
+	switch i {
+	case ICEConnectionTypeUnknown:
+		return roomobs.ConnectionTypeUndefined
+	case ICEConnectionTypeUDP:
+		return roomobs.ConnectionTypeUDP
+	case ICEConnectionTypeTCP:
+		return roomobs.ConnectionTypeTCP
+	case ICEConnectionTypeTURN:
+		return roomobs.ConnectionTypeTurn
+	default:
+		return roomobs.ConnectionTypeUndefined
+	}
+}
+
+// --------------------------------------------
+
+type ICECandidateExtended struct {
+	Candidate     *webrtc.ICECandidate
+	SelectedOrder int
+	Filtered      bool
+	Trickle       bool
+}
+
+// --------------------------------------------
+
+type ICEConnectionInfo struct {
+	Local     []*ICECandidateExtended
+	Remote    []*ICECandidateExtended
+	Transport livekit.SignalTarget
+	Type      ICEConnectionType
+}
+
+func (i *ICEConnectionInfo) HasCandidates() bool {
+	return len(i.Local) > 0 || len(i.Remote) > 0
+}
+
+func ICEConnectionInfosType(infos []*ICEConnectionInfo) ICEConnectionType {
+	for _, info := range infos {
+		if info.Type != ICEConnectionTypeUnknown {
+			return info.Type
+		}
+	}
+	return ICEConnectionTypeUnknown
+}
+
+// --------------------------------------------
+
+type ICEConnectionDetails struct {
+	ICEConnectionInfo
+	lock          sync.Mutex
+	selectedCount int
+	logger        logger.Logger
+}
+
+func NewICEConnectionDetails(transport livekit.SignalTarget, l logger.Logger) *ICEConnectionDetails {
+	d := &ICEConnectionDetails{
+		ICEConnectionInfo: ICEConnectionInfo{
+			Transport: transport,
+			Type:      ICEConnectionTypeUnknown,
+		},
+		logger: l,
+	}
+	return d
+}
+
+func (d *ICEConnectionDetails) GetInfo() *ICEConnectionInfo {
+	d.lock.Lock()
+	defer d.lock.Unlock()
+	info := &ICEConnectionInfo{
+		Transport: d.Transport,
+		Type:      d.Type,
+		Local:     make([]*ICECandidateExtended, 0, len(d.Local)),
+		Remote:    make([]*ICECandidateExtended, 0, len(d.Remote)),
+	}
+	for _, c := range d.Local {
+		info.Local = append(info.Local, &ICECandidateExtended{
+			Candidate:     c.Candidate,
+			Filtered:      c.Filtered,
+			SelectedOrder: c.SelectedOrder,
+			Trickle:       c.Trickle,
+		})
+	}
+	for _, c := range d.Remote {
+		info.Remote = append(info.Remote, &ICECandidateExtended{
+			Candidate:     c.Candidate,
+			Filtered:      c.Filtered,
+			SelectedOrder: c.SelectedOrder,
+			Trickle:       c.Trickle,
+		})
+	}
+	return info
+}
+
+func (d *ICEConnectionDetails) GetConnectionType() ICEConnectionType {
+	d.lock.Lock()
+	defer d.lock.Unlock()
+
+	return d.Type
+}
+
+func (d *ICEConnectionDetails) AddLocalCandidate(c *webrtc.ICECandidate, filtered, trickle bool) {
+	d.lock.Lock()
+	defer d.lock.Unlock()
+	compFn := func(e *ICECandidateExtended) bool {
+		return isCandidateEqualTo(e.Candidate, c)
+	}
+	if slices.ContainsFunc(d.Local, compFn) {
+		return
+	}
+	d.Local = append(d.Local, &ICECandidateExtended{
+		Candidate: c,
+		Filtered:  filtered,
+		Trickle:   trickle,
+	})
+}
+
+func (d *ICEConnectionDetails) AddLocalICECandidate(c ice.Candidate, filtered, trickle bool) {
+	candidate, err := unmarshalCandidate(c)
+	if err != nil {
+		d.logger.Errorw("could not unmarshal ice candidate", err, "candidate", c)
+		return
+	}
+
+	d.AddLocalCandidate(candidate, filtered, trickle)
+}
+
+func (d *ICEConnectionDetails) AddRemoteCandidate(c webrtc.ICECandidateInit, filtered, trickle, canUpdate bool) {
+	iceCandidate, err := unmarshalICECandidate(c)
+	if err != nil {
+		d.logger.Errorw("could not unmarshal candidate", err, "candidate", c)
+		return
+	}
+	d.AddRemoteICECandidate(iceCandidate, filtered, trickle, canUpdate)
+}
+
+func (d *ICEConnectionDetails) AddRemoteICECandidate(iceCandidate ice.Candidate, filtered, trickle, canUpdate bool) {
+	if iceCandidate == nil {
+		// end-of-candidates candidate
+		return
+	}
+
+	candidate, err := unmarshalCandidate(iceCandidate)
+	if err != nil {
+		d.logger.Errorw("could not unmarshal ice candidate", err, "candidate", iceCandidate)
+		return
+	}
+
+	d.lock.Lock()
+	defer d.lock.Unlock()
+	indexFn := func(e *ICECandidateExtended) bool {
+		return isCandidateEqualTo(e.Candidate, candidate)
+	}
+	if idx := slices.IndexFunc(d.Remote, indexFn); idx != -1 {
+		if canUpdate {
+			d.Remote[idx].Filtered = filtered
+			d.Remote[idx].Trickle = trickle
+		}
+		return
+	}
+	d.Remote = append(d.Remote, &ICECandidateExtended{
+		Candidate: candidate,
+		Filtered:  filtered,
+		Trickle:   trickle,
+	})
+	d.updateConnectionTypeLocked()
+}
+
+func (d *ICEConnectionDetails) Clear() {
+	d.lock.Lock()
+	defer d.lock.Unlock()
+	d.Local = nil
+	d.Remote = nil
+	d.Type = ICEConnectionTypeUnknown
+}
+
+func (d *ICEConnectionDetails) SetSelectedPair(pair *webrtc.ICECandidatePair) {
+	d.lock.Lock()
+	defer d.lock.Unlock()
+
+	d.selectedCount++
+
+	remoteIdx := slices.IndexFunc(d.Remote, func(e *ICECandidateExtended) bool {
+		return isCandidateEqualTo(e.Candidate, pair.Remote)
+	})
+	if remoteIdx < 0 {
+		// it's possible for prflx candidates to be generated by Pion, we'll add them
+		d.Remote = append(d.Remote, &ICECandidateExtended{
+			Candidate: pair.Remote,
+			Filtered:  false,
+			Trickle:   false,
+		})
+		remoteIdx = len(d.Remote) - 1
+	}
+	d.Remote[remoteIdx].SelectedOrder = d.selectedCount
+	d.updateConnectionTypeLocked()
+
+	localIdx := slices.IndexFunc(d.Local, func(e *ICECandidateExtended) bool {
+		return isCandidateEqualTo(e.Candidate, pair.Local)
+	})
+	if localIdx < 0 {
+		d.logger.Errorw("could not match local candidate", nil, "local", pair.Local)
+		// should not happen
+		return
+	}
+	d.Local[localIdx].SelectedOrder = d.selectedCount
+}
+
+func (d *ICEConnectionDetails) updateConnectionTypeLocked() {
+	highestSelectedOrder := -1
+	var selectedRemoteCandidate *ICECandidateExtended
+	for _, remote := range d.Remote {
+		if remote.SelectedOrder == 0 {
+			continue
+		}
+
+		if remote.SelectedOrder > highestSelectedOrder {
+			highestSelectedOrder = remote.SelectedOrder
+			selectedRemoteCandidate = remote
+		}
+	}
+
+	if selectedRemoteCandidate == nil {
+		return
+	}
+
+	remoteCandidate := selectedRemoteCandidate.Candidate
+	switch remoteCandidate.Protocol {
+	case webrtc.ICEProtocolUDP:
+		d.Type = ICEConnectionTypeUDP
+
+	case webrtc.ICEProtocolTCP:
+		d.Type = ICEConnectionTypeTCP
+	}
+
+	switch remoteCandidate.Typ {
+	case webrtc.ICECandidateTypeRelay:
+		d.Type = ICEConnectionTypeTURN
+
+	case webrtc.ICECandidateTypePrflx:
+		// if the remote relay candidate pings us *before* we get a relay candidate,
+		// Pion would have created a prflx candidate with the same address as the relay candidate.
+		// to report an accurate connection type, we'll compare to see if existing relay candidates match
+		for _, other := range d.Remote {
+			or := other.Candidate
+			if or.Typ == webrtc.ICECandidateTypeRelay &&
+				remoteCandidate.Address == or.Address &&
+				// NOTE: port is not compared as relayed address  reported by TURN ALLOCATE from
+				// pion/turn server -> client and later sent from client -> server via ICE Trickle does not
+				// match port of `prflx` candidate learnt via TURN path. TODO-INVESTIGATE: how and why doesn't
+				// port match?
+				// remoteCandidate.Port == or.Port &&
+				remoteCandidate.Protocol == or.Protocol {
+				d.Type = ICEConnectionTypeTURN
+				break
+			}
+		}
+	}
+}
+
+// -------------------------------------------------------------
+
+func isCandidateEqualTo(c1, c2 *webrtc.ICECandidate) bool {
+	if c1 == nil && c2 == nil {
+		return true
+	}
+	if (c1 == nil && c2 != nil) || (c1 != nil && c2 == nil) {
+		return false
+	}
+	return c1.Typ == c2.Typ &&
+		c1.Protocol == c2.Protocol &&
+		c1.Address == c2.Address &&
+		c1.Port == c2.Port &&
+		c1.Foundation == c2.Foundation &&
+		c1.Priority == c2.Priority &&
+		c1.RelatedAddress == c2.RelatedAddress &&
+		c1.RelatedPort == c2.RelatedPort &&
+		c1.TCPType == c2.TCPType
+}
+
+func unmarshalICECandidate(c webrtc.ICECandidateInit) (ice.Candidate, error) {
+	candidateValue := strings.TrimPrefix(c.Candidate, "candidate:")
+	if candidateValue == "" {
+		return nil, nil
+	}
+
+	candidate, err := ice.UnmarshalCandidate(candidateValue)
+	if err != nil {
+		return nil, err
+	}
+
+	return candidate, nil
+}
+
+func unmarshalCandidate(i ice.Candidate) (*webrtc.ICECandidate, error) {
+	typ, err := convertTypeFromICE(i.Type())
+	if err != nil {
+		return nil, err
+	}
+
+	protocol, err := webrtc.NewICEProtocol(i.NetworkType().NetworkShort())
+	if err != nil {
+		return nil, err
+	}
+
+	c := webrtc.ICECandidate{
+		Foundation: i.Foundation(),
+		Priority:   i.Priority(),
+		Address:    i.Address(),
+		Protocol:   protocol,
+		Port:       uint16(i.Port()),
+		Component:  i.Component(),
+		Typ:        typ,
+		TCPType:    i.TCPType().String(),
+	}
+
+	if i.RelatedAddress() != nil {
+		c.RelatedAddress = i.RelatedAddress().Address
+		c.RelatedPort = uint16(i.RelatedAddress().Port)
+	}
+
+	return &c, nil
+}
+
+func convertTypeFromICE(t ice.CandidateType) (webrtc.ICECandidateType, error) {
+	switch t {
+	case ice.CandidateTypeHost:
+		return webrtc.ICECandidateTypeHost, nil
+	case ice.CandidateTypeServerReflexive:
+		return webrtc.ICECandidateTypeSrflx, nil
+	case ice.CandidateTypePeerReflexive:
+		return webrtc.ICECandidateTypePrflx, nil
+	case ice.CandidateTypeRelay:
+		return webrtc.ICECandidateTypeRelay, nil
+	default:
+		return webrtc.ICECandidateType(t), fmt.Errorf("unknown ice candidate type: %s", t)
+	}
+}
+
+func IsCandidateMDNS(candidate webrtc.ICECandidateInit) bool {
+	c, err := unmarshalICECandidate(candidate)
+	if err != nil {
+		return false
+	}
+
+	return IsICECandidateMDNS(c)
+}
+
+func IsICECandidateMDNS(candidate ice.Candidate) bool {
+	if candidate == nil {
+		// end-of-candidates candidate
+		return false
+	}
+
+	return strings.HasSuffix(candidate.Address(), ".local") || strings.HasSuffix(candidate.Address(), ".invalid")
+}

pkg/rtc/types/protocol_version.go

@@ -0,0 +1,105 @@
+// Copyright 2023 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+type ProtocolVersion int
+
+const CurrentProtocol = 17
+
+func (v ProtocolVersion) SupportsPackedStreamId() bool {
+	return v > 0
+}
+
+func (v ProtocolVersion) SupportsProtobuf() bool {
+	return v > 0
+}
+
+func (v ProtocolVersion) HandlesDataPackets() bool {
+	return v > 1
+}
+
+// SubscriberAsPrimary indicates clients initiate subscriber connection as primary
+func (v ProtocolVersion) SubscriberAsPrimary() bool {
+	return v > 2
+}
+
+// SupportsSpeakerChanged - if client handles speaker info deltas, instead of a comprehensive list
+func (v ProtocolVersion) SupportsSpeakerChanged() bool {
+	return v > 2
+}
+
+// SupportsTransceiverReuse - if transceiver reuse is supported, optimizes SDP size
+func (v ProtocolVersion) SupportsTransceiverReuse() bool {
+	return v > 3
+}
+
+// SupportsConnectionQuality - avoid sending frequent ConnectionQuality updates for lower protocol versions
+func (v ProtocolVersion) SupportsConnectionQuality() bool {
+	return v > 4
+}
+
+func (v ProtocolVersion) SupportsSessionMigrate() bool {
+	return v > 5
+}
+
+func (v ProtocolVersion) SupportsICELite() bool {
+	return v > 5
+}
+
+func (v ProtocolVersion) SupportsUnpublish() bool {
+	return v > 6
+}
+
+// SupportFastStart - if client supports fast start, server side will send media streams
+// in the first offer
+func (v ProtocolVersion) SupportFastStart() bool {
+	return v > 7
+}
+
+func (v ProtocolVersion) SupportsDisconnectedUpdate() bool {
+	return v > 8
+}
+
+func (v ProtocolVersion) SupportsSyncStreamID() bool {
+	return v > 9
+}
+
+func (v ProtocolVersion) SupportsConnectionQualityLost() bool {
+	return v > 10
+}
+
+func (v ProtocolVersion) SupportsAsyncRoomID() bool {
+	return v > 11
+}
+
+func (v ProtocolVersion) SupportsIdentityBasedReconnection() bool {
+	return v > 11
+}
+
+func (v ProtocolVersion) SupportsRegionsInLeaveRequest() bool {
+	return v > 12
+}
+
+func (v ProtocolVersion) SupportsNonErrorSignalResponse() bool {
+	return v > 14
+}
+
+func (v ProtocolVersion) SupportsMoving() bool {
+	return v > 15
+}
+
+func (v ProtocolVersion) SupportsPacketTrailer() bool {
+	return v > 16
+}

pkg/rtc/types/trafficstats.go

@@ -0,0 +1,161 @@
+// Copyright 2023 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+	"time"
+
+	"github.com/livekit/protocol/livekit"
+)
+
+type TrafficStats struct {
+	StartTime         time.Time
+	EndTime           time.Time
+	Packets           uint32
+	PacketsLost       uint32
+	PacketsPadding    uint32
+	PacketsOutOfOrder uint32
+	Bytes             uint64
+}
+
+type TrafficTypeStats struct {
+	TrackType    livekit.TrackType
+	StreamType   livekit.StreamType
+	TrafficStats *TrafficStats
+}
+
+type TrafficLoad struct {
+	TrafficTypeStats []*TrafficTypeStats
+}
+
+func RTPStatsDiffToTrafficStats(before, after *livekit.RTPStats) *TrafficStats {
+	if after == nil {
+		return nil
+	}
+
+	startTime := after.StartTime
+	if before != nil {
+		startTime = before.EndTime
+	}
+
+	getAfter := func() *TrafficStats {
+		return &TrafficStats{
+			StartTime:         startTime.AsTime(),
+			EndTime:           after.EndTime.AsTime(),
+			Packets:           after.Packets,
+			PacketsLost:       after.PacketsLost,
+			PacketsPadding:    after.PacketsPadding,
+			PacketsOutOfOrder: after.PacketsOutOfOrder,
+			Bytes:             after.Bytes + after.BytesDuplicate + after.BytesPadding,
+		}
+	}
+
+	if before == nil {
+		return getAfter()
+	}
+
+	if (after.Packets - before.Packets) > (1 << 31) {
+		// after packets < before packets, probably got reset, just return after
+		return getAfter()
+	}
+	if ((after.Bytes + after.BytesDuplicate + after.BytesPadding) - (before.Bytes + before.BytesDuplicate + before.BytesPadding)) > (1 << 63) {
+		// after bytes < before bytes, probably got reset, just return after
+		return getAfter()
+	}
+
+	packetsLost := uint32(0)
+	if after.PacketsLost >= before.PacketsLost {
+		packetsLost = after.PacketsLost - before.PacketsLost
+	}
+	return &TrafficStats{
+		StartTime:         startTime.AsTime(),
+		EndTime:           after.EndTime.AsTime(),
+		Packets:           after.Packets - before.Packets,
+		PacketsLost:       packetsLost,
+		PacketsPadding:    after.PacketsPadding - before.PacketsPadding,
+		PacketsOutOfOrder: after.PacketsOutOfOrder - before.PacketsOutOfOrder,
+		Bytes:             (after.Bytes + after.BytesDuplicate + after.BytesPadding) - (before.Bytes + before.BytesDuplicate + before.BytesPadding),
+	}
+}
+
+func AggregateTrafficStats(statsList ...*TrafficStats) *TrafficStats {
+	if len(statsList) == 0 {
+		return nil
+	}
+
+	startTime := time.Time{}
+	endTime := time.Time{}
+
+	packets := uint32(0)
+	packetsLost := uint32(0)
+	packetsPadding := uint32(0)
+	packetsOutOfOrder := uint32(0)
+	bytes := uint64(0)
+
+	for _, stats := range statsList {
+		if startTime.IsZero() || startTime.After(stats.StartTime) {
+			startTime = stats.StartTime
+		}
+
+		if endTime.IsZero() || endTime.Before(stats.EndTime) {
+			endTime = stats.EndTime
+		}
+
+		packets += stats.Packets
+		packetsLost += stats.PacketsLost
+		packetsPadding += stats.PacketsPadding
+		packetsOutOfOrder += stats.PacketsOutOfOrder
+		bytes += stats.Bytes
+	}
+
+	if endTime.IsZero() {
+		endTime = time.Now()
+	}
+	return &TrafficStats{
+		StartTime:         startTime,
+		EndTime:           endTime,
+		Packets:           packets,
+		PacketsLost:       packetsLost,
+		PacketsPadding:    packetsPadding,
+		PacketsOutOfOrder: packetsOutOfOrder,
+		Bytes:             bytes,
+	}
+}
+
+func TrafficLoadToTrafficRate(trafficLoad *TrafficLoad) (
+	packetRateIn float64,
+	byteRateIn float64,
+	packetRateOut float64,
+	byteRateOut float64,
+) {
+	if trafficLoad == nil {
+		return
+	}
+
+	for _, trafficTypeStat := range trafficLoad.TrafficTypeStats {
+		elapsed := trafficTypeStat.TrafficStats.EndTime.Sub(trafficTypeStat.TrafficStats.StartTime).Seconds()
+		packetRate := float64(trafficTypeStat.TrafficStats.Packets) / elapsed
+		byteRate := float64(trafficTypeStat.TrafficStats.Bytes) / elapsed
+		switch trafficTypeStat.StreamType {
+		case livekit.StreamType_UPSTREAM:
+			packetRateIn += packetRate
+			byteRateIn += byteRate
+		case livekit.StreamType_DOWNSTREAM:
+			packetRateOut += packetRate
+			byteRateOut += byteRate
+		}
+	}
+	return
+}

pkg/rtc/types/typesfakes/fake_data_down_track.go

@@ -0,0 +1,266 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package typesfakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/rtc/types"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeDataDownTrack struct {
+	CloseStub        func()
+	closeMutex       sync.RWMutex
+	closeArgsForCall []struct {
+	}
+	HandleStub        func() uint16
+	handleMutex       sync.RWMutex
+	handleArgsForCall []struct {
+	}
+	handleReturns struct {
+		result1 uint16
+	}
+	handleReturnsOnCall map[int]struct {
+		result1 uint16
+	}
+	OnCloseStub        func(func())
+	onCloseMutex       sync.RWMutex
+	onCloseArgsForCall []struct {
+		arg1 func()
+	}
+	PublishDataTrackStub        func() types.DataTrack
+	publishDataTrackMutex       sync.RWMutex
+	publishDataTrackArgsForCall []struct {
+	}
+	publishDataTrackReturns struct {
+		result1 types.DataTrack
+	}
+	publishDataTrackReturnsOnCall map[int]struct {
+		result1 types.DataTrack
+	}
+	UpdateSubscriptionOptionsStub        func(*livekit.DataTrackSubscriptionOptions)
+	updateSubscriptionOptionsMutex       sync.RWMutex
+	updateSubscriptionOptionsArgsForCall []struct {
+		arg1 *livekit.DataTrackSubscriptionOptions
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeDataDownTrack) Close() {
+	fake.closeMutex.Lock()
+	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
+	}{})
+	stub := fake.CloseStub
+	fake.recordInvocation("Close", []interface{}{})
+	fake.closeMutex.Unlock()
+	if stub != nil {
+		fake.CloseStub()
+	}
+}
+
+func (fake *FakeDataDownTrack) CloseCallCount() int {
+	fake.closeMutex.RLock()
+	defer fake.closeMutex.RUnlock()
+	return len(fake.closeArgsForCall)
+}
+
+func (fake *FakeDataDownTrack) CloseCalls(stub func()) {
+	fake.closeMutex.Lock()
+	defer fake.closeMutex.Unlock()
+	fake.CloseStub = stub
+}
+
+func (fake *FakeDataDownTrack) Handle() uint16 {
+	fake.handleMutex.Lock()
+	ret, specificReturn := fake.handleReturnsOnCall[len(fake.handleArgsForCall)]
+	fake.handleArgsForCall = append(fake.handleArgsForCall, struct {
+	}{})
+	stub := fake.HandleStub
+	fakeReturns := fake.handleReturns
+	fake.recordInvocation("Handle", []interface{}{})
+	fake.handleMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeDataDownTrack) HandleCallCount() int {
+	fake.handleMutex.RLock()
+	defer fake.handleMutex.RUnlock()
+	return len(fake.handleArgsForCall)
+}
+
+func (fake *FakeDataDownTrack) HandleCalls(stub func() uint16) {
+	fake.handleMutex.Lock()
+	defer fake.handleMutex.Unlock()
+	fake.HandleStub = stub
+}
+
+func (fake *FakeDataDownTrack) HandleReturns(result1 uint16) {
+	fake.handleMutex.Lock()
+	defer fake.handleMutex.Unlock()
+	fake.HandleStub = nil
+	fake.handleReturns = struct {
+		result1 uint16
+	}{result1}
+}
+
+func (fake *FakeDataDownTrack) HandleReturnsOnCall(i int, result1 uint16) {
+	fake.handleMutex.Lock()
+	defer fake.handleMutex.Unlock()
+	fake.HandleStub = nil
+	if fake.handleReturnsOnCall == nil {
+		fake.handleReturnsOnCall = make(map[int]struct {
+			result1 uint16
+		})
+	}
+	fake.handleReturnsOnCall[i] = struct {
+		result1 uint16
+	}{result1}
+}
+
+func (fake *FakeDataDownTrack) OnClose(arg1 func()) {
+	fake.onCloseMutex.Lock()
+	fake.onCloseArgsForCall = append(fake.onCloseArgsForCall, struct {
+		arg1 func()
+	}{arg1})
+	stub := fake.OnCloseStub
+	fake.recordInvocation("OnClose", []interface{}{arg1})
+	fake.onCloseMutex.Unlock()
+	if stub != nil {
+		fake.OnCloseStub(arg1)
+	}
+}
+
+func (fake *FakeDataDownTrack) OnCloseCallCount() int {
+	fake.onCloseMutex.RLock()
+	defer fake.onCloseMutex.RUnlock()
+	return len(fake.onCloseArgsForCall)
+}
+
+func (fake *FakeDataDownTrack) OnCloseCalls(stub func(func())) {
+	fake.onCloseMutex.Lock()
+	defer fake.onCloseMutex.Unlock()
+	fake.OnCloseStub = stub
+}
+
+func (fake *FakeDataDownTrack) OnCloseArgsForCall(i int) func() {
+	fake.onCloseMutex.RLock()
+	defer fake.onCloseMutex.RUnlock()
+	argsForCall := fake.onCloseArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDataDownTrack) PublishDataTrack() types.DataTrack {
+	fake.publishDataTrackMutex.Lock()
+	ret, specificReturn := fake.publishDataTrackReturnsOnCall[len(fake.publishDataTrackArgsForCall)]
+	fake.publishDataTrackArgsForCall = append(fake.publishDataTrackArgsForCall, struct {
+	}{})
+	stub := fake.PublishDataTrackStub
+	fakeReturns := fake.publishDataTrackReturns
+	fake.recordInvocation("PublishDataTrack", []interface{}{})
+	fake.publishDataTrackMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeDataDownTrack) PublishDataTrackCallCount() int {
+	fake.publishDataTrackMutex.RLock()
+	defer fake.publishDataTrackMutex.RUnlock()
+	return len(fake.publishDataTrackArgsForCall)
+}
+
+func (fake *FakeDataDownTrack) PublishDataTrackCalls(stub func() types.DataTrack) {
+	fake.publishDataTrackMutex.Lock()
+	defer fake.publishDataTrackMutex.Unlock()
+	fake.PublishDataTrackStub = stub
+}
+
+func (fake *FakeDataDownTrack) PublishDataTrackReturns(result1 types.DataTrack) {
+	fake.publishDataTrackMutex.Lock()
+	defer fake.publishDataTrackMutex.Unlock()
+	fake.PublishDataTrackStub = nil
+	fake.publishDataTrackReturns = struct {
+		result1 types.DataTrack
+	}{result1}
+}
+
+func (fake *FakeDataDownTrack) PublishDataTrackReturnsOnCall(i int, result1 types.DataTrack) {
+	fake.publishDataTrackMutex.Lock()
+	defer fake.publishDataTrackMutex.Unlock()
+	fake.PublishDataTrackStub = nil
+	if fake.publishDataTrackReturnsOnCall == nil {
+		fake.publishDataTrackReturnsOnCall = make(map[int]struct {
+			result1 types.DataTrack
+		})
+	}
+	fake.publishDataTrackReturnsOnCall[i] = struct {
+		result1 types.DataTrack
+	}{result1}
+}
+
+func (fake *FakeDataDownTrack) UpdateSubscriptionOptions(arg1 *livekit.DataTrackSubscriptionOptions) {
+	fake.updateSubscriptionOptionsMutex.Lock()
+	fake.updateSubscriptionOptionsArgsForCall = append(fake.updateSubscriptionOptionsArgsForCall, struct {
+		arg1 *livekit.DataTrackSubscriptionOptions
+	}{arg1})
+	stub := fake.UpdateSubscriptionOptionsStub
+	fake.recordInvocation("UpdateSubscriptionOptions", []interface{}{arg1})
+	fake.updateSubscriptionOptionsMutex.Unlock()
+	if stub != nil {
+		fake.UpdateSubscriptionOptionsStub(arg1)
+	}
+}
+
+func (fake *FakeDataDownTrack) UpdateSubscriptionOptionsCallCount() int {
+	fake.updateSubscriptionOptionsMutex.RLock()
+	defer fake.updateSubscriptionOptionsMutex.RUnlock()
+	return len(fake.updateSubscriptionOptionsArgsForCall)
+}
+
+func (fake *FakeDataDownTrack) UpdateSubscriptionOptionsCalls(stub func(*livekit.DataTrackSubscriptionOptions)) {
+	fake.updateSubscriptionOptionsMutex.Lock()
+	defer fake.updateSubscriptionOptionsMutex.Unlock()
+	fake.UpdateSubscriptionOptionsStub = stub
+}
+
+func (fake *FakeDataDownTrack) UpdateSubscriptionOptionsArgsForCall(i int) *livekit.DataTrackSubscriptionOptions {
+	fake.updateSubscriptionOptionsMutex.RLock()
+	defer fake.updateSubscriptionOptionsMutex.RUnlock()
+	argsForCall := fake.updateSubscriptionOptionsArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDataDownTrack) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeDataDownTrack) 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.DataDownTrack = new(FakeDataDownTrack)

pkg/rtc/types/typesfakes/fake_data_track.go

@@ -0,0 +1,863 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package typesfakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/rtc/types"
+	"github.com/livekit/protocol/datatrack"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeDataTrack struct {
+	AddDataDownTrackStub        func(types.DataTrackSender) error
+	addDataDownTrackMutex       sync.RWMutex
+	addDataDownTrackArgsForCall []struct {
+		arg1 types.DataTrackSender
+	}
+	addDataDownTrackReturns struct {
+		result1 error
+	}
+	addDataDownTrackReturnsOnCall map[int]struct {
+		result1 error
+	}
+	AddSubscriberStub        func(types.LocalParticipant) (types.DataDownTrack, error)
+	addSubscriberMutex       sync.RWMutex
+	addSubscriberArgsForCall []struct {
+		arg1 types.LocalParticipant
+	}
+	addSubscriberReturns struct {
+		result1 types.DataDownTrack
+		result2 error
+	}
+	addSubscriberReturnsOnCall map[int]struct {
+		result1 types.DataDownTrack
+		result2 error
+	}
+	CloseStub        func()
+	closeMutex       sync.RWMutex
+	closeArgsForCall []struct {
+	}
+	DeleteDataDownTrackStub        func(livekit.ParticipantID)
+	deleteDataDownTrackMutex       sync.RWMutex
+	deleteDataDownTrackArgsForCall []struct {
+		arg1 livekit.ParticipantID
+	}
+	HandlePacketStub        func([]byte, *datatrack.Packet, int64)
+	handlePacketMutex       sync.RWMutex
+	handlePacketArgsForCall []struct {
+		arg1 []byte
+		arg2 *datatrack.Packet
+		arg3 int64
+	}
+	IDStub        func() livekit.TrackID
+	iDMutex       sync.RWMutex
+	iDArgsForCall []struct {
+	}
+	iDReturns struct {
+		result1 livekit.TrackID
+	}
+	iDReturnsOnCall map[int]struct {
+		result1 livekit.TrackID
+	}
+	IsSubscriberStub        func(livekit.ParticipantID) bool
+	isSubscriberMutex       sync.RWMutex
+	isSubscriberArgsForCall []struct {
+		arg1 livekit.ParticipantID
+	}
+	isSubscriberReturns struct {
+		result1 bool
+	}
+	isSubscriberReturnsOnCall map[int]struct {
+		result1 bool
+	}
+	NameStub        func() string
+	nameMutex       sync.RWMutex
+	nameArgsForCall []struct {
+	}
+	nameReturns struct {
+		result1 string
+	}
+	nameReturnsOnCall map[int]struct {
+		result1 string
+	}
+	PubHandleStub        func() uint16
+	pubHandleMutex       sync.RWMutex
+	pubHandleArgsForCall []struct {
+	}
+	pubHandleReturns struct {
+		result1 uint16
+	}
+	pubHandleReturnsOnCall map[int]struct {
+		result1 uint16
+	}
+	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
+	}
+	RemoveSubscriberStub        func(livekit.ParticipantID)
+	removeSubscriberMutex       sync.RWMutex
+	removeSubscriberArgsForCall []struct {
+		arg1 livekit.ParticipantID
+	}
+	RevokeDisallowedSubscribersStub        func([]livekit.ParticipantIdentity) []livekit.ParticipantIdentity
+	revokeDisallowedSubscribersMutex       sync.RWMutex
+	revokeDisallowedSubscribersArgsForCall []struct {
+		arg1 []livekit.ParticipantIdentity
+	}
+	revokeDisallowedSubscribersReturns struct {
+		result1 []livekit.ParticipantIdentity
+	}
+	revokeDisallowedSubscribersReturnsOnCall map[int]struct {
+		result1 []livekit.ParticipantIdentity
+	}
+	ToProtoStub        func() *livekit.DataTrackInfo
+	toProtoMutex       sync.RWMutex
+	toProtoArgsForCall []struct {
+	}
+	toProtoReturns struct {
+		result1 *livekit.DataTrackInfo
+	}
+	toProtoReturnsOnCall map[int]struct {
+		result1 *livekit.DataTrackInfo
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeDataTrack) AddDataDownTrack(arg1 types.DataTrackSender) error {
+	fake.addDataDownTrackMutex.Lock()
+	ret, specificReturn := fake.addDataDownTrackReturnsOnCall[len(fake.addDataDownTrackArgsForCall)]
+	fake.addDataDownTrackArgsForCall = append(fake.addDataDownTrackArgsForCall, struct {
+		arg1 types.DataTrackSender
+	}{arg1})
+	stub := fake.AddDataDownTrackStub
+	fakeReturns := fake.addDataDownTrackReturns
+	fake.recordInvocation("AddDataDownTrack", []interface{}{arg1})
+	fake.addDataDownTrackMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeDataTrack) AddDataDownTrackCallCount() int {
+	fake.addDataDownTrackMutex.RLock()
+	defer fake.addDataDownTrackMutex.RUnlock()
+	return len(fake.addDataDownTrackArgsForCall)
+}
+
+func (fake *FakeDataTrack) AddDataDownTrackCalls(stub func(types.DataTrackSender) error) {
+	fake.addDataDownTrackMutex.Lock()
+	defer fake.addDataDownTrackMutex.Unlock()
+	fake.AddDataDownTrackStub = stub
+}
+
+func (fake *FakeDataTrack) AddDataDownTrackArgsForCall(i int) types.DataTrackSender {
+	fake.addDataDownTrackMutex.RLock()
+	defer fake.addDataDownTrackMutex.RUnlock()
+	argsForCall := fake.addDataDownTrackArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDataTrack) AddDataDownTrackReturns(result1 error) {
+	fake.addDataDownTrackMutex.Lock()
+	defer fake.addDataDownTrackMutex.Unlock()
+	fake.AddDataDownTrackStub = nil
+	fake.addDataDownTrackReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeDataTrack) AddDataDownTrackReturnsOnCall(i int, result1 error) {
+	fake.addDataDownTrackMutex.Lock()
+	defer fake.addDataDownTrackMutex.Unlock()
+	fake.AddDataDownTrackStub = nil
+	if fake.addDataDownTrackReturnsOnCall == nil {
+		fake.addDataDownTrackReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.addDataDownTrackReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeDataTrack) AddSubscriber(arg1 types.LocalParticipant) (types.DataDownTrack, 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, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeDataTrack) AddSubscriberCallCount() int {
+	fake.addSubscriberMutex.RLock()
+	defer fake.addSubscriberMutex.RUnlock()
+	return len(fake.addSubscriberArgsForCall)
+}
+
+func (fake *FakeDataTrack) AddSubscriberCalls(stub func(types.LocalParticipant) (types.DataDownTrack, error)) {
+	fake.addSubscriberMutex.Lock()
+	defer fake.addSubscriberMutex.Unlock()
+	fake.AddSubscriberStub = stub
+}
+
+func (fake *FakeDataTrack) AddSubscriberArgsForCall(i int) types.LocalParticipant {
+	fake.addSubscriberMutex.RLock()
+	defer fake.addSubscriberMutex.RUnlock()
+	argsForCall := fake.addSubscriberArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDataTrack) AddSubscriberReturns(result1 types.DataDownTrack, result2 error) {
+	fake.addSubscriberMutex.Lock()
+	defer fake.addSubscriberMutex.Unlock()
+	fake.AddSubscriberStub = nil
+	fake.addSubscriberReturns = struct {
+		result1 types.DataDownTrack
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeDataTrack) AddSubscriberReturnsOnCall(i int, result1 types.DataDownTrack, result2 error) {
+	fake.addSubscriberMutex.Lock()
+	defer fake.addSubscriberMutex.Unlock()
+	fake.AddSubscriberStub = nil
+	if fake.addSubscriberReturnsOnCall == nil {
+		fake.addSubscriberReturnsOnCall = make(map[int]struct {
+			result1 types.DataDownTrack
+			result2 error
+		})
+	}
+	fake.addSubscriberReturnsOnCall[i] = struct {
+		result1 types.DataDownTrack
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeDataTrack) Close() {
+	fake.closeMutex.Lock()
+	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
+	}{})
+	stub := fake.CloseStub
+	fake.recordInvocation("Close", []interface{}{})
+	fake.closeMutex.Unlock()
+	if stub != nil {
+		fake.CloseStub()
+	}
+}
+
+func (fake *FakeDataTrack) CloseCallCount() int {
+	fake.closeMutex.RLock()
+	defer fake.closeMutex.RUnlock()
+	return len(fake.closeArgsForCall)
+}
+
+func (fake *FakeDataTrack) CloseCalls(stub func()) {
+	fake.closeMutex.Lock()
+	defer fake.closeMutex.Unlock()
+	fake.CloseStub = stub
+}
+
+func (fake *FakeDataTrack) DeleteDataDownTrack(arg1 livekit.ParticipantID) {
+	fake.deleteDataDownTrackMutex.Lock()
+	fake.deleteDataDownTrackArgsForCall = append(fake.deleteDataDownTrackArgsForCall, struct {
+		arg1 livekit.ParticipantID
+	}{arg1})
+	stub := fake.DeleteDataDownTrackStub
+	fake.recordInvocation("DeleteDataDownTrack", []interface{}{arg1})
+	fake.deleteDataDownTrackMutex.Unlock()
+	if stub != nil {
+		fake.DeleteDataDownTrackStub(arg1)
+	}
+}
+
+func (fake *FakeDataTrack) DeleteDataDownTrackCallCount() int {
+	fake.deleteDataDownTrackMutex.RLock()
+	defer fake.deleteDataDownTrackMutex.RUnlock()
+	return len(fake.deleteDataDownTrackArgsForCall)
+}
+
+func (fake *FakeDataTrack) DeleteDataDownTrackCalls(stub func(livekit.ParticipantID)) {
+	fake.deleteDataDownTrackMutex.Lock()
+	defer fake.deleteDataDownTrackMutex.Unlock()
+	fake.DeleteDataDownTrackStub = stub
+}
+
+func (fake *FakeDataTrack) DeleteDataDownTrackArgsForCall(i int) livekit.ParticipantID {
+	fake.deleteDataDownTrackMutex.RLock()
+	defer fake.deleteDataDownTrackMutex.RUnlock()
+	argsForCall := fake.deleteDataDownTrackArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDataTrack) HandlePacket(arg1 []byte, arg2 *datatrack.Packet, arg3 int64) {
+	var arg1Copy []byte
+	if arg1 != nil {
+		arg1Copy = make([]byte, len(arg1))
+		copy(arg1Copy, arg1)
+	}
+	fake.handlePacketMutex.Lock()
+	fake.handlePacketArgsForCall = append(fake.handlePacketArgsForCall, struct {
+		arg1 []byte
+		arg2 *datatrack.Packet
+		arg3 int64
+	}{arg1Copy, arg2, arg3})
+	stub := fake.HandlePacketStub
+	fake.recordInvocation("HandlePacket", []interface{}{arg1Copy, arg2, arg3})
+	fake.handlePacketMutex.Unlock()
+	if stub != nil {
+		fake.HandlePacketStub(arg1, arg2, arg3)
+	}
+}
+
+func (fake *FakeDataTrack) HandlePacketCallCount() int {
+	fake.handlePacketMutex.RLock()
+	defer fake.handlePacketMutex.RUnlock()
+	return len(fake.handlePacketArgsForCall)
+}
+
+func (fake *FakeDataTrack) HandlePacketCalls(stub func([]byte, *datatrack.Packet, int64)) {
+	fake.handlePacketMutex.Lock()
+	defer fake.handlePacketMutex.Unlock()
+	fake.HandlePacketStub = stub
+}
+
+func (fake *FakeDataTrack) HandlePacketArgsForCall(i int) ([]byte, *datatrack.Packet, int64) {
+	fake.handlePacketMutex.RLock()
+	defer fake.handlePacketMutex.RUnlock()
+	argsForCall := fake.handlePacketArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeDataTrack) 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 *FakeDataTrack) IDCallCount() int {
+	fake.iDMutex.RLock()
+	defer fake.iDMutex.RUnlock()
+	return len(fake.iDArgsForCall)
+}
+
+func (fake *FakeDataTrack) IDCalls(stub func() livekit.TrackID) {
+	fake.iDMutex.Lock()
+	defer fake.iDMutex.Unlock()
+	fake.IDStub = stub
+}
+
+func (fake *FakeDataTrack) IDReturns(result1 livekit.TrackID) {
+	fake.iDMutex.Lock()
+	defer fake.iDMutex.Unlock()
+	fake.IDStub = nil
+	fake.iDReturns = struct {
+		result1 livekit.TrackID
+	}{result1}
+}
+
+func (fake *FakeDataTrack) 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 *FakeDataTrack) 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 *FakeDataTrack) IsSubscriberCallCount() int {
+	fake.isSubscriberMutex.RLock()
+	defer fake.isSubscriberMutex.RUnlock()
+	return len(fake.isSubscriberArgsForCall)
+}
+
+func (fake *FakeDataTrack) IsSubscriberCalls(stub func(livekit.ParticipantID) bool) {
+	fake.isSubscriberMutex.Lock()
+	defer fake.isSubscriberMutex.Unlock()
+	fake.IsSubscriberStub = stub
+}
+
+func (fake *FakeDataTrack) IsSubscriberArgsForCall(i int) livekit.ParticipantID {
+	fake.isSubscriberMutex.RLock()
+	defer fake.isSubscriberMutex.RUnlock()
+	argsForCall := fake.isSubscriberArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDataTrack) IsSubscriberReturns(result1 bool) {
+	fake.isSubscriberMutex.Lock()
+	defer fake.isSubscriberMutex.Unlock()
+	fake.IsSubscriberStub = nil
+	fake.isSubscriberReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeDataTrack) 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 *FakeDataTrack) 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 *FakeDataTrack) NameCallCount() int {
+	fake.nameMutex.RLock()
+	defer fake.nameMutex.RUnlock()
+	return len(fake.nameArgsForCall)
+}
+
+func (fake *FakeDataTrack) NameCalls(stub func() string) {
+	fake.nameMutex.Lock()
+	defer fake.nameMutex.Unlock()
+	fake.NameStub = stub
+}
+
+func (fake *FakeDataTrack) NameReturns(result1 string) {
+	fake.nameMutex.Lock()
+	defer fake.nameMutex.Unlock()
+	fake.NameStub = nil
+	fake.nameReturns = struct {
+		result1 string
+	}{result1}
+}
+
+func (fake *FakeDataTrack) 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 *FakeDataTrack) PubHandle() uint16 {
+	fake.pubHandleMutex.Lock()
+	ret, specificReturn := fake.pubHandleReturnsOnCall[len(fake.pubHandleArgsForCall)]
+	fake.pubHandleArgsForCall = append(fake.pubHandleArgsForCall, struct {
+	}{})
+	stub := fake.PubHandleStub
+	fakeReturns := fake.pubHandleReturns
+	fake.recordInvocation("PubHandle", []interface{}{})
+	fake.pubHandleMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeDataTrack) PubHandleCallCount() int {
+	fake.pubHandleMutex.RLock()
+	defer fake.pubHandleMutex.RUnlock()
+	return len(fake.pubHandleArgsForCall)
+}
+
+func (fake *FakeDataTrack) PubHandleCalls(stub func() uint16) {
+	fake.pubHandleMutex.Lock()
+	defer fake.pubHandleMutex.Unlock()
+	fake.PubHandleStub = stub
+}
+
+func (fake *FakeDataTrack) PubHandleReturns(result1 uint16) {
+	fake.pubHandleMutex.Lock()
+	defer fake.pubHandleMutex.Unlock()
+	fake.PubHandleStub = nil
+	fake.pubHandleReturns = struct {
+		result1 uint16
+	}{result1}
+}
+
+func (fake *FakeDataTrack) PubHandleReturnsOnCall(i int, result1 uint16) {
+	fake.pubHandleMutex.Lock()
+	defer fake.pubHandleMutex.Unlock()
+	fake.PubHandleStub = nil
+	if fake.pubHandleReturnsOnCall == nil {
+		fake.pubHandleReturnsOnCall = make(map[int]struct {
+			result1 uint16
+		})
+	}
+	fake.pubHandleReturnsOnCall[i] = struct {
+		result1 uint16
+	}{result1}
+}
+
+func (fake *FakeDataTrack) 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 *FakeDataTrack) PublisherIDCallCount() int {
+	fake.publisherIDMutex.RLock()
+	defer fake.publisherIDMutex.RUnlock()
+	return len(fake.publisherIDArgsForCall)
+}
+
+func (fake *FakeDataTrack) PublisherIDCalls(stub func() livekit.ParticipantID) {
+	fake.publisherIDMutex.Lock()
+	defer fake.publisherIDMutex.Unlock()
+	fake.PublisherIDStub = stub
+}
+
+func (fake *FakeDataTrack) PublisherIDReturns(result1 livekit.ParticipantID) {
+	fake.publisherIDMutex.Lock()
+	defer fake.publisherIDMutex.Unlock()
+	fake.PublisherIDStub = nil
+	fake.publisherIDReturns = struct {
+		result1 livekit.ParticipantID
+	}{result1}
+}
+
+func (fake *FakeDataTrack) 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 *FakeDataTrack) 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 *FakeDataTrack) PublisherIdentityCallCount() int {
+	fake.publisherIdentityMutex.RLock()
+	defer fake.publisherIdentityMutex.RUnlock()
+	return len(fake.publisherIdentityArgsForCall)
+}
+
+func (fake *FakeDataTrack) PublisherIdentityCalls(stub func() livekit.ParticipantIdentity) {
+	fake.publisherIdentityMutex.Lock()
+	defer fake.publisherIdentityMutex.Unlock()
+	fake.PublisherIdentityStub = stub
+}
+
+func (fake *FakeDataTrack) PublisherIdentityReturns(result1 livekit.ParticipantIdentity) {
+	fake.publisherIdentityMutex.Lock()
+	defer fake.publisherIdentityMutex.Unlock()
+	fake.PublisherIdentityStub = nil
+	fake.publisherIdentityReturns = struct {
+		result1 livekit.ParticipantIdentity
+	}{result1}
+}
+
+func (fake *FakeDataTrack) 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 *FakeDataTrack) 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 *FakeDataTrack) RemoveSubscriberCallCount() int {
+	fake.removeSubscriberMutex.RLock()
+	defer fake.removeSubscriberMutex.RUnlock()
+	return len(fake.removeSubscriberArgsForCall)
+}
+
+func (fake *FakeDataTrack) RemoveSubscriberCalls(stub func(livekit.ParticipantID)) {
+	fake.removeSubscriberMutex.Lock()
+	defer fake.removeSubscriberMutex.Unlock()
+	fake.RemoveSubscriberStub = stub
+}
+
+func (fake *FakeDataTrack) RemoveSubscriberArgsForCall(i int) livekit.ParticipantID {
+	fake.removeSubscriberMutex.RLock()
+	defer fake.removeSubscriberMutex.RUnlock()
+	argsForCall := fake.removeSubscriberArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDataTrack) RevokeDisallowedSubscribers(arg1 []livekit.ParticipantIdentity) []livekit.ParticipantIdentity {
+	var arg1Copy []livekit.ParticipantIdentity
+	if arg1 != nil {
+		arg1Copy = make([]livekit.ParticipantIdentity, len(arg1))
+		copy(arg1Copy, arg1)
+	}
+	fake.revokeDisallowedSubscribersMutex.Lock()
+	ret, specificReturn := fake.revokeDisallowedSubscribersReturnsOnCall[len(fake.revokeDisallowedSubscribersArgsForCall)]
+	fake.revokeDisallowedSubscribersArgsForCall = append(fake.revokeDisallowedSubscribersArgsForCall, struct {
+		arg1 []livekit.ParticipantIdentity
+	}{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 *FakeDataTrack) RevokeDisallowedSubscribersCallCount() int {
+	fake.revokeDisallowedSubscribersMutex.RLock()
+	defer fake.revokeDisallowedSubscribersMutex.RUnlock()
+	return len(fake.revokeDisallowedSubscribersArgsForCall)
+}
+
+func (fake *FakeDataTrack) RevokeDisallowedSubscribersCalls(stub func([]livekit.ParticipantIdentity) []livekit.ParticipantIdentity) {
+	fake.revokeDisallowedSubscribersMutex.Lock()
+	defer fake.revokeDisallowedSubscribersMutex.Unlock()
+	fake.RevokeDisallowedSubscribersStub = stub
+}
+
+func (fake *FakeDataTrack) RevokeDisallowedSubscribersArgsForCall(i int) []livekit.ParticipantIdentity {
+	fake.revokeDisallowedSubscribersMutex.RLock()
+	defer fake.revokeDisallowedSubscribersMutex.RUnlock()
+	argsForCall := fake.revokeDisallowedSubscribersArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDataTrack) RevokeDisallowedSubscribersReturns(result1 []livekit.ParticipantIdentity) {
+	fake.revokeDisallowedSubscribersMutex.Lock()
+	defer fake.revokeDisallowedSubscribersMutex.Unlock()
+	fake.RevokeDisallowedSubscribersStub = nil
+	fake.revokeDisallowedSubscribersReturns = struct {
+		result1 []livekit.ParticipantIdentity
+	}{result1}
+}
+
+func (fake *FakeDataTrack) RevokeDisallowedSubscribersReturnsOnCall(i int, result1 []livekit.ParticipantIdentity) {
+	fake.revokeDisallowedSubscribersMutex.Lock()
+	defer fake.revokeDisallowedSubscribersMutex.Unlock()
+	fake.RevokeDisallowedSubscribersStub = nil
+	if fake.revokeDisallowedSubscribersReturnsOnCall == nil {
+		fake.revokeDisallowedSubscribersReturnsOnCall = make(map[int]struct {
+			result1 []livekit.ParticipantIdentity
+		})
+	}
+	fake.revokeDisallowedSubscribersReturnsOnCall[i] = struct {
+		result1 []livekit.ParticipantIdentity
+	}{result1}
+}
+
+func (fake *FakeDataTrack) ToProto() *livekit.DataTrackInfo {
+	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 *FakeDataTrack) ToProtoCallCount() int {
+	fake.toProtoMutex.RLock()
+	defer fake.toProtoMutex.RUnlock()
+	return len(fake.toProtoArgsForCall)
+}
+
+func (fake *FakeDataTrack) ToProtoCalls(stub func() *livekit.DataTrackInfo) {
+	fake.toProtoMutex.Lock()
+	defer fake.toProtoMutex.Unlock()
+	fake.ToProtoStub = stub
+}
+
+func (fake *FakeDataTrack) ToProtoReturns(result1 *livekit.DataTrackInfo) {
+	fake.toProtoMutex.Lock()
+	defer fake.toProtoMutex.Unlock()
+	fake.ToProtoStub = nil
+	fake.toProtoReturns = struct {
+		result1 *livekit.DataTrackInfo
+	}{result1}
+}
+
+func (fake *FakeDataTrack) ToProtoReturnsOnCall(i int, result1 *livekit.DataTrackInfo) {
+	fake.toProtoMutex.Lock()
+	defer fake.toProtoMutex.Unlock()
+	fake.ToProtoStub = nil
+	if fake.toProtoReturnsOnCall == nil {
+		fake.toProtoReturnsOnCall = make(map[int]struct {
+			result1 *livekit.DataTrackInfo
+		})
+	}
+	fake.toProtoReturnsOnCall[i] = struct {
+		result1 *livekit.DataTrackInfo
+	}{result1}
+}
+
+func (fake *FakeDataTrack) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeDataTrack) 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.DataTrack = new(FakeDataTrack)

pkg/rtc/types/typesfakes/fake_data_track_sender.go

@@ -0,0 +1,148 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package typesfakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/rtc/types"
+	"github.com/livekit/protocol/datatrack"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeDataTrackSender struct {
+	SubscriberIDStub        func() livekit.ParticipantID
+	subscriberIDMutex       sync.RWMutex
+	subscriberIDArgsForCall []struct {
+	}
+	subscriberIDReturns struct {
+		result1 livekit.ParticipantID
+	}
+	subscriberIDReturnsOnCall map[int]struct {
+		result1 livekit.ParticipantID
+	}
+	WritePacketStub        func([]byte, *datatrack.Packet, int64)
+	writePacketMutex       sync.RWMutex
+	writePacketArgsForCall []struct {
+		arg1 []byte
+		arg2 *datatrack.Packet
+		arg3 int64
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeDataTrackSender) SubscriberID() livekit.ParticipantID {
+	fake.subscriberIDMutex.Lock()
+	ret, specificReturn := fake.subscriberIDReturnsOnCall[len(fake.subscriberIDArgsForCall)]
+	fake.subscriberIDArgsForCall = append(fake.subscriberIDArgsForCall, struct {
+	}{})
+	stub := fake.SubscriberIDStub
+	fakeReturns := fake.subscriberIDReturns
+	fake.recordInvocation("SubscriberID", []interface{}{})
+	fake.subscriberIDMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeDataTrackSender) SubscriberIDCallCount() int {
+	fake.subscriberIDMutex.RLock()
+	defer fake.subscriberIDMutex.RUnlock()
+	return len(fake.subscriberIDArgsForCall)
+}
+
+func (fake *FakeDataTrackSender) SubscriberIDCalls(stub func() livekit.ParticipantID) {
+	fake.subscriberIDMutex.Lock()
+	defer fake.subscriberIDMutex.Unlock()
+	fake.SubscriberIDStub = stub
+}
+
+func (fake *FakeDataTrackSender) SubscriberIDReturns(result1 livekit.ParticipantID) {
+	fake.subscriberIDMutex.Lock()
+	defer fake.subscriberIDMutex.Unlock()
+	fake.SubscriberIDStub = nil
+	fake.subscriberIDReturns = struct {
+		result1 livekit.ParticipantID
+	}{result1}
+}
+
+func (fake *FakeDataTrackSender) SubscriberIDReturnsOnCall(i int, result1 livekit.ParticipantID) {
+	fake.subscriberIDMutex.Lock()
+	defer fake.subscriberIDMutex.Unlock()
+	fake.SubscriberIDStub = nil
+	if fake.subscriberIDReturnsOnCall == nil {
+		fake.subscriberIDReturnsOnCall = make(map[int]struct {
+			result1 livekit.ParticipantID
+		})
+	}
+	fake.subscriberIDReturnsOnCall[i] = struct {
+		result1 livekit.ParticipantID
+	}{result1}
+}
+
+func (fake *FakeDataTrackSender) WritePacket(arg1 []byte, arg2 *datatrack.Packet, arg3 int64) {
+	var arg1Copy []byte
+	if arg1 != nil {
+		arg1Copy = make([]byte, len(arg1))
+		copy(arg1Copy, arg1)
+	}
+	fake.writePacketMutex.Lock()
+	fake.writePacketArgsForCall = append(fake.writePacketArgsForCall, struct {
+		arg1 []byte
+		arg2 *datatrack.Packet
+		arg3 int64
+	}{arg1Copy, arg2, arg3})
+	stub := fake.WritePacketStub
+	fake.recordInvocation("WritePacket", []interface{}{arg1Copy, arg2, arg3})
+	fake.writePacketMutex.Unlock()
+	if stub != nil {
+		fake.WritePacketStub(arg1, arg2, arg3)
+	}
+}
+
+func (fake *FakeDataTrackSender) WritePacketCallCount() int {
+	fake.writePacketMutex.RLock()
+	defer fake.writePacketMutex.RUnlock()
+	return len(fake.writePacketArgsForCall)
+}
+
+func (fake *FakeDataTrackSender) WritePacketCalls(stub func([]byte, *datatrack.Packet, int64)) {
+	fake.writePacketMutex.Lock()
+	defer fake.writePacketMutex.Unlock()
+	fake.WritePacketStub = stub
+}
+
+func (fake *FakeDataTrackSender) WritePacketArgsForCall(i int) ([]byte, *datatrack.Packet, int64) {
+	fake.writePacketMutex.RLock()
+	defer fake.writePacketMutex.RUnlock()
+	argsForCall := fake.writePacketArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeDataTrackSender) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeDataTrackSender) 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.DataTrackSender = new(FakeDataTrackSender)

pkg/rtc/types/typesfakes/fake_data_track_transport.go

@@ -0,0 +1,114 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package typesfakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/rtc/types"
+)
+
+type FakeDataTrackTransport struct {
+	SendDataTrackMessageStub        func([]byte) error
+	sendDataTrackMessageMutex       sync.RWMutex
+	sendDataTrackMessageArgsForCall []struct {
+		arg1 []byte
+	}
+	sendDataTrackMessageReturns struct {
+		result1 error
+	}
+	sendDataTrackMessageReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeDataTrackTransport) SendDataTrackMessage(arg1 []byte) error {
+	var arg1Copy []byte
+	if arg1 != nil {
+		arg1Copy = make([]byte, len(arg1))
+		copy(arg1Copy, arg1)
+	}
+	fake.sendDataTrackMessageMutex.Lock()
+	ret, specificReturn := fake.sendDataTrackMessageReturnsOnCall[len(fake.sendDataTrackMessageArgsForCall)]
+	fake.sendDataTrackMessageArgsForCall = append(fake.sendDataTrackMessageArgsForCall, struct {
+		arg1 []byte
+	}{arg1Copy})
+	stub := fake.SendDataTrackMessageStub
+	fakeReturns := fake.sendDataTrackMessageReturns
+	fake.recordInvocation("SendDataTrackMessage", []interface{}{arg1Copy})
+	fake.sendDataTrackMessageMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeDataTrackTransport) SendDataTrackMessageCallCount() int {
+	fake.sendDataTrackMessageMutex.RLock()
+	defer fake.sendDataTrackMessageMutex.RUnlock()
+	return len(fake.sendDataTrackMessageArgsForCall)
+}
+
+func (fake *FakeDataTrackTransport) SendDataTrackMessageCalls(stub func([]byte) error) {
+	fake.sendDataTrackMessageMutex.Lock()
+	defer fake.sendDataTrackMessageMutex.Unlock()
+	fake.SendDataTrackMessageStub = stub
+}
+
+func (fake *FakeDataTrackTransport) SendDataTrackMessageArgsForCall(i int) []byte {
+	fake.sendDataTrackMessageMutex.RLock()
+	defer fake.sendDataTrackMessageMutex.RUnlock()
+	argsForCall := fake.sendDataTrackMessageArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDataTrackTransport) SendDataTrackMessageReturns(result1 error) {
+	fake.sendDataTrackMessageMutex.Lock()
+	defer fake.sendDataTrackMessageMutex.Unlock()
+	fake.SendDataTrackMessageStub = nil
+	fake.sendDataTrackMessageReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeDataTrackTransport) SendDataTrackMessageReturnsOnCall(i int, result1 error) {
+	fake.sendDataTrackMessageMutex.Lock()
+	defer fake.sendDataTrackMessageMutex.Unlock()
+	fake.SendDataTrackMessageStub = nil
+	if fake.sendDataTrackMessageReturnsOnCall == nil {
+		fake.sendDataTrackMessageReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.sendDataTrackMessageReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeDataTrackTransport) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeDataTrackTransport) 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.DataTrackTransport = new(FakeDataTrackTransport)

pkg/rtc/types/typesfakes/fake_local_participant_helper.go

@@ -0,0 +1,542 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package typesfakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/rtc/types"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeLocalParticipantHelper struct {
+	GetCachedReliableDataMessageStub        func(map[livekit.ParticipantID]uint32) []*types.DataMessageCache
+	getCachedReliableDataMessageMutex       sync.RWMutex
+	getCachedReliableDataMessageArgsForCall []struct {
+		arg1 map[livekit.ParticipantID]uint32
+	}
+	getCachedReliableDataMessageReturns struct {
+		result1 []*types.DataMessageCache
+	}
+	getCachedReliableDataMessageReturnsOnCall map[int]struct {
+		result1 []*types.DataMessageCache
+	}
+	GetParticipantInfoStub        func(livekit.ParticipantID) *livekit.ParticipantInfo
+	getParticipantInfoMutex       sync.RWMutex
+	getParticipantInfoArgsForCall []struct {
+		arg1 livekit.ParticipantID
+	}
+	getParticipantInfoReturns struct {
+		result1 *livekit.ParticipantInfo
+	}
+	getParticipantInfoReturnsOnCall map[int]struct {
+		result1 *livekit.ParticipantInfo
+	}
+	GetRegionSettingsStub        func(string) *livekit.RegionSettings
+	getRegionSettingsMutex       sync.RWMutex
+	getRegionSettingsArgsForCall []struct {
+		arg1 string
+	}
+	getRegionSettingsReturns struct {
+		result1 *livekit.RegionSettings
+	}
+	getRegionSettingsReturnsOnCall map[int]struct {
+		result1 *livekit.RegionSettings
+	}
+	GetSubscriberForwarderStateStub        func(types.LocalParticipant) (map[livekit.TrackID]*livekit.RTPForwarderState, error)
+	getSubscriberForwarderStateMutex       sync.RWMutex
+	getSubscriberForwarderStateArgsForCall []struct {
+		arg1 types.LocalParticipant
+	}
+	getSubscriberForwarderStateReturns struct {
+		result1 map[livekit.TrackID]*livekit.RTPForwarderState
+		result2 error
+	}
+	getSubscriberForwarderStateReturnsOnCall map[int]struct {
+		result1 map[livekit.TrackID]*livekit.RTPForwarderState
+		result2 error
+	}
+	ResolveDataTrackStub        func(types.LocalParticipant, livekit.TrackID) types.DataResolverResult
+	resolveDataTrackMutex       sync.RWMutex
+	resolveDataTrackArgsForCall []struct {
+		arg1 types.LocalParticipant
+		arg2 livekit.TrackID
+	}
+	resolveDataTrackReturns struct {
+		result1 types.DataResolverResult
+	}
+	resolveDataTrackReturnsOnCall map[int]struct {
+		result1 types.DataResolverResult
+	}
+	ResolveMediaTrackStub        func(types.LocalParticipant, livekit.TrackID) types.MediaResolverResult
+	resolveMediaTrackMutex       sync.RWMutex
+	resolveMediaTrackArgsForCall []struct {
+		arg1 types.LocalParticipant
+		arg2 livekit.TrackID
+	}
+	resolveMediaTrackReturns struct {
+		result1 types.MediaResolverResult
+	}
+	resolveMediaTrackReturnsOnCall map[int]struct {
+		result1 types.MediaResolverResult
+	}
+	ShouldRegressCodecStub        func() bool
+	shouldRegressCodecMutex       sync.RWMutex
+	shouldRegressCodecArgsForCall []struct {
+	}
+	shouldRegressCodecReturns struct {
+		result1 bool
+	}
+	shouldRegressCodecReturnsOnCall map[int]struct {
+		result1 bool
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeLocalParticipantHelper) GetCachedReliableDataMessage(arg1 map[livekit.ParticipantID]uint32) []*types.DataMessageCache {
+	fake.getCachedReliableDataMessageMutex.Lock()
+	ret, specificReturn := fake.getCachedReliableDataMessageReturnsOnCall[len(fake.getCachedReliableDataMessageArgsForCall)]
+	fake.getCachedReliableDataMessageArgsForCall = append(fake.getCachedReliableDataMessageArgsForCall, struct {
+		arg1 map[livekit.ParticipantID]uint32
+	}{arg1})
+	stub := fake.GetCachedReliableDataMessageStub
+	fakeReturns := fake.getCachedReliableDataMessageReturns
+	fake.recordInvocation("GetCachedReliableDataMessage", []interface{}{arg1})
+	fake.getCachedReliableDataMessageMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeLocalParticipantHelper) GetCachedReliableDataMessageCallCount() int {
+	fake.getCachedReliableDataMessageMutex.RLock()
+	defer fake.getCachedReliableDataMessageMutex.RUnlock()
+	return len(fake.getCachedReliableDataMessageArgsForCall)
+}
+
+func (fake *FakeLocalParticipantHelper) GetCachedReliableDataMessageCalls(stub func(map[livekit.ParticipantID]uint32) []*types.DataMessageCache) {
+	fake.getCachedReliableDataMessageMutex.Lock()
+	defer fake.getCachedReliableDataMessageMutex.Unlock()
+	fake.GetCachedReliableDataMessageStub = stub
+}
+
+func (fake *FakeLocalParticipantHelper) GetCachedReliableDataMessageArgsForCall(i int) map[livekit.ParticipantID]uint32 {
+	fake.getCachedReliableDataMessageMutex.RLock()
+	defer fake.getCachedReliableDataMessageMutex.RUnlock()
+	argsForCall := fake.getCachedReliableDataMessageArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeLocalParticipantHelper) GetCachedReliableDataMessageReturns(result1 []*types.DataMessageCache) {
+	fake.getCachedReliableDataMessageMutex.Lock()
+	defer fake.getCachedReliableDataMessageMutex.Unlock()
+	fake.GetCachedReliableDataMessageStub = nil
+	fake.getCachedReliableDataMessageReturns = struct {
+		result1 []*types.DataMessageCache
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) GetCachedReliableDataMessageReturnsOnCall(i int, result1 []*types.DataMessageCache) {
+	fake.getCachedReliableDataMessageMutex.Lock()
+	defer fake.getCachedReliableDataMessageMutex.Unlock()
+	fake.GetCachedReliableDataMessageStub = nil
+	if fake.getCachedReliableDataMessageReturnsOnCall == nil {
+		fake.getCachedReliableDataMessageReturnsOnCall = make(map[int]struct {
+			result1 []*types.DataMessageCache
+		})
+	}
+	fake.getCachedReliableDataMessageReturnsOnCall[i] = struct {
+		result1 []*types.DataMessageCache
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) GetParticipantInfo(arg1 livekit.ParticipantID) *livekit.ParticipantInfo {
+	fake.getParticipantInfoMutex.Lock()
+	ret, specificReturn := fake.getParticipantInfoReturnsOnCall[len(fake.getParticipantInfoArgsForCall)]
+	fake.getParticipantInfoArgsForCall = append(fake.getParticipantInfoArgsForCall, struct {
+		arg1 livekit.ParticipantID
+	}{arg1})
+	stub := fake.GetParticipantInfoStub
+	fakeReturns := fake.getParticipantInfoReturns
+	fake.recordInvocation("GetParticipantInfo", []interface{}{arg1})
+	fake.getParticipantInfoMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeLocalParticipantHelper) GetParticipantInfoCallCount() int {
+	fake.getParticipantInfoMutex.RLock()
+	defer fake.getParticipantInfoMutex.RUnlock()
+	return len(fake.getParticipantInfoArgsForCall)
+}
+
+func (fake *FakeLocalParticipantHelper) GetParticipantInfoCalls(stub func(livekit.ParticipantID) *livekit.ParticipantInfo) {
+	fake.getParticipantInfoMutex.Lock()
+	defer fake.getParticipantInfoMutex.Unlock()
+	fake.GetParticipantInfoStub = stub
+}
+
+func (fake *FakeLocalParticipantHelper) GetParticipantInfoArgsForCall(i int) livekit.ParticipantID {
+	fake.getParticipantInfoMutex.RLock()
+	defer fake.getParticipantInfoMutex.RUnlock()
+	argsForCall := fake.getParticipantInfoArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeLocalParticipantHelper) GetParticipantInfoReturns(result1 *livekit.ParticipantInfo) {
+	fake.getParticipantInfoMutex.Lock()
+	defer fake.getParticipantInfoMutex.Unlock()
+	fake.GetParticipantInfoStub = nil
+	fake.getParticipantInfoReturns = struct {
+		result1 *livekit.ParticipantInfo
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) GetParticipantInfoReturnsOnCall(i int, result1 *livekit.ParticipantInfo) {
+	fake.getParticipantInfoMutex.Lock()
+	defer fake.getParticipantInfoMutex.Unlock()
+	fake.GetParticipantInfoStub = nil
+	if fake.getParticipantInfoReturnsOnCall == nil {
+		fake.getParticipantInfoReturnsOnCall = make(map[int]struct {
+			result1 *livekit.ParticipantInfo
+		})
+	}
+	fake.getParticipantInfoReturnsOnCall[i] = struct {
+		result1 *livekit.ParticipantInfo
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) GetRegionSettings(arg1 string) *livekit.RegionSettings {
+	fake.getRegionSettingsMutex.Lock()
+	ret, specificReturn := fake.getRegionSettingsReturnsOnCall[len(fake.getRegionSettingsArgsForCall)]
+	fake.getRegionSettingsArgsForCall = append(fake.getRegionSettingsArgsForCall, struct {
+		arg1 string
+	}{arg1})
+	stub := fake.GetRegionSettingsStub
+	fakeReturns := fake.getRegionSettingsReturns
+	fake.recordInvocation("GetRegionSettings", []interface{}{arg1})
+	fake.getRegionSettingsMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeLocalParticipantHelper) GetRegionSettingsCallCount() int {
+	fake.getRegionSettingsMutex.RLock()
+	defer fake.getRegionSettingsMutex.RUnlock()
+	return len(fake.getRegionSettingsArgsForCall)
+}
+
+func (fake *FakeLocalParticipantHelper) GetRegionSettingsCalls(stub func(string) *livekit.RegionSettings) {
+	fake.getRegionSettingsMutex.Lock()
+	defer fake.getRegionSettingsMutex.Unlock()
+	fake.GetRegionSettingsStub = stub
+}
+
+func (fake *FakeLocalParticipantHelper) GetRegionSettingsArgsForCall(i int) string {
+	fake.getRegionSettingsMutex.RLock()
+	defer fake.getRegionSettingsMutex.RUnlock()
+	argsForCall := fake.getRegionSettingsArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeLocalParticipantHelper) GetRegionSettingsReturns(result1 *livekit.RegionSettings) {
+	fake.getRegionSettingsMutex.Lock()
+	defer fake.getRegionSettingsMutex.Unlock()
+	fake.GetRegionSettingsStub = nil
+	fake.getRegionSettingsReturns = struct {
+		result1 *livekit.RegionSettings
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) GetRegionSettingsReturnsOnCall(i int, result1 *livekit.RegionSettings) {
+	fake.getRegionSettingsMutex.Lock()
+	defer fake.getRegionSettingsMutex.Unlock()
+	fake.GetRegionSettingsStub = nil
+	if fake.getRegionSettingsReturnsOnCall == nil {
+		fake.getRegionSettingsReturnsOnCall = make(map[int]struct {
+			result1 *livekit.RegionSettings
+		})
+	}
+	fake.getRegionSettingsReturnsOnCall[i] = struct {
+		result1 *livekit.RegionSettings
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) GetSubscriberForwarderState(arg1 types.LocalParticipant) (map[livekit.TrackID]*livekit.RTPForwarderState, error) {
+	fake.getSubscriberForwarderStateMutex.Lock()
+	ret, specificReturn := fake.getSubscriberForwarderStateReturnsOnCall[len(fake.getSubscriberForwarderStateArgsForCall)]
+	fake.getSubscriberForwarderStateArgsForCall = append(fake.getSubscriberForwarderStateArgsForCall, struct {
+		arg1 types.LocalParticipant
+	}{arg1})
+	stub := fake.GetSubscriberForwarderStateStub
+	fakeReturns := fake.getSubscriberForwarderStateReturns
+	fake.recordInvocation("GetSubscriberForwarderState", []interface{}{arg1})
+	fake.getSubscriberForwarderStateMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeLocalParticipantHelper) GetSubscriberForwarderStateCallCount() int {
+	fake.getSubscriberForwarderStateMutex.RLock()
+	defer fake.getSubscriberForwarderStateMutex.RUnlock()
+	return len(fake.getSubscriberForwarderStateArgsForCall)
+}
+
+func (fake *FakeLocalParticipantHelper) GetSubscriberForwarderStateCalls(stub func(types.LocalParticipant) (map[livekit.TrackID]*livekit.RTPForwarderState, error)) {
+	fake.getSubscriberForwarderStateMutex.Lock()
+	defer fake.getSubscriberForwarderStateMutex.Unlock()
+	fake.GetSubscriberForwarderStateStub = stub
+}
+
+func (fake *FakeLocalParticipantHelper) GetSubscriberForwarderStateArgsForCall(i int) types.LocalParticipant {
+	fake.getSubscriberForwarderStateMutex.RLock()
+	defer fake.getSubscriberForwarderStateMutex.RUnlock()
+	argsForCall := fake.getSubscriberForwarderStateArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeLocalParticipantHelper) GetSubscriberForwarderStateReturns(result1 map[livekit.TrackID]*livekit.RTPForwarderState, result2 error) {
+	fake.getSubscriberForwarderStateMutex.Lock()
+	defer fake.getSubscriberForwarderStateMutex.Unlock()
+	fake.GetSubscriberForwarderStateStub = nil
+	fake.getSubscriberForwarderStateReturns = struct {
+		result1 map[livekit.TrackID]*livekit.RTPForwarderState
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeLocalParticipantHelper) GetSubscriberForwarderStateReturnsOnCall(i int, result1 map[livekit.TrackID]*livekit.RTPForwarderState, result2 error) {
+	fake.getSubscriberForwarderStateMutex.Lock()
+	defer fake.getSubscriberForwarderStateMutex.Unlock()
+	fake.GetSubscriberForwarderStateStub = nil
+	if fake.getSubscriberForwarderStateReturnsOnCall == nil {
+		fake.getSubscriberForwarderStateReturnsOnCall = make(map[int]struct {
+			result1 map[livekit.TrackID]*livekit.RTPForwarderState
+			result2 error
+		})
+	}
+	fake.getSubscriberForwarderStateReturnsOnCall[i] = struct {
+		result1 map[livekit.TrackID]*livekit.RTPForwarderState
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveDataTrack(arg1 types.LocalParticipant, arg2 livekit.TrackID) types.DataResolverResult {
+	fake.resolveDataTrackMutex.Lock()
+	ret, specificReturn := fake.resolveDataTrackReturnsOnCall[len(fake.resolveDataTrackArgsForCall)]
+	fake.resolveDataTrackArgsForCall = append(fake.resolveDataTrackArgsForCall, struct {
+		arg1 types.LocalParticipant
+		arg2 livekit.TrackID
+	}{arg1, arg2})
+	stub := fake.ResolveDataTrackStub
+	fakeReturns := fake.resolveDataTrackReturns
+	fake.recordInvocation("ResolveDataTrack", []interface{}{arg1, arg2})
+	fake.resolveDataTrackMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveDataTrackCallCount() int {
+	fake.resolveDataTrackMutex.RLock()
+	defer fake.resolveDataTrackMutex.RUnlock()
+	return len(fake.resolveDataTrackArgsForCall)
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveDataTrackCalls(stub func(types.LocalParticipant, livekit.TrackID) types.DataResolverResult) {
+	fake.resolveDataTrackMutex.Lock()
+	defer fake.resolveDataTrackMutex.Unlock()
+	fake.ResolveDataTrackStub = stub
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveDataTrackArgsForCall(i int) (types.LocalParticipant, livekit.TrackID) {
+	fake.resolveDataTrackMutex.RLock()
+	defer fake.resolveDataTrackMutex.RUnlock()
+	argsForCall := fake.resolveDataTrackArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveDataTrackReturns(result1 types.DataResolverResult) {
+	fake.resolveDataTrackMutex.Lock()
+	defer fake.resolveDataTrackMutex.Unlock()
+	fake.ResolveDataTrackStub = nil
+	fake.resolveDataTrackReturns = struct {
+		result1 types.DataResolverResult
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveDataTrackReturnsOnCall(i int, result1 types.DataResolverResult) {
+	fake.resolveDataTrackMutex.Lock()
+	defer fake.resolveDataTrackMutex.Unlock()
+	fake.ResolveDataTrackStub = nil
+	if fake.resolveDataTrackReturnsOnCall == nil {
+		fake.resolveDataTrackReturnsOnCall = make(map[int]struct {
+			result1 types.DataResolverResult
+		})
+	}
+	fake.resolveDataTrackReturnsOnCall[i] = struct {
+		result1 types.DataResolverResult
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveMediaTrack(arg1 types.LocalParticipant, arg2 livekit.TrackID) types.MediaResolverResult {
+	fake.resolveMediaTrackMutex.Lock()
+	ret, specificReturn := fake.resolveMediaTrackReturnsOnCall[len(fake.resolveMediaTrackArgsForCall)]
+	fake.resolveMediaTrackArgsForCall = append(fake.resolveMediaTrackArgsForCall, struct {
+		arg1 types.LocalParticipant
+		arg2 livekit.TrackID
+	}{arg1, arg2})
+	stub := fake.ResolveMediaTrackStub
+	fakeReturns := fake.resolveMediaTrackReturns
+	fake.recordInvocation("ResolveMediaTrack", []interface{}{arg1, arg2})
+	fake.resolveMediaTrackMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveMediaTrackCallCount() int {
+	fake.resolveMediaTrackMutex.RLock()
+	defer fake.resolveMediaTrackMutex.RUnlock()
+	return len(fake.resolveMediaTrackArgsForCall)
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveMediaTrackCalls(stub func(types.LocalParticipant, livekit.TrackID) types.MediaResolverResult) {
+	fake.resolveMediaTrackMutex.Lock()
+	defer fake.resolveMediaTrackMutex.Unlock()
+	fake.ResolveMediaTrackStub = stub
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveMediaTrackArgsForCall(i int) (types.LocalParticipant, livekit.TrackID) {
+	fake.resolveMediaTrackMutex.RLock()
+	defer fake.resolveMediaTrackMutex.RUnlock()
+	argsForCall := fake.resolveMediaTrackArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveMediaTrackReturns(result1 types.MediaResolverResult) {
+	fake.resolveMediaTrackMutex.Lock()
+	defer fake.resolveMediaTrackMutex.Unlock()
+	fake.ResolveMediaTrackStub = nil
+	fake.resolveMediaTrackReturns = struct {
+		result1 types.MediaResolverResult
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) ResolveMediaTrackReturnsOnCall(i int, result1 types.MediaResolverResult) {
+	fake.resolveMediaTrackMutex.Lock()
+	defer fake.resolveMediaTrackMutex.Unlock()
+	fake.ResolveMediaTrackStub = nil
+	if fake.resolveMediaTrackReturnsOnCall == nil {
+		fake.resolveMediaTrackReturnsOnCall = make(map[int]struct {
+			result1 types.MediaResolverResult
+		})
+	}
+	fake.resolveMediaTrackReturnsOnCall[i] = struct {
+		result1 types.MediaResolverResult
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) ShouldRegressCodec() bool {
+	fake.shouldRegressCodecMutex.Lock()
+	ret, specificReturn := fake.shouldRegressCodecReturnsOnCall[len(fake.shouldRegressCodecArgsForCall)]
+	fake.shouldRegressCodecArgsForCall = append(fake.shouldRegressCodecArgsForCall, struct {
+	}{})
+	stub := fake.ShouldRegressCodecStub
+	fakeReturns := fake.shouldRegressCodecReturns
+	fake.recordInvocation("ShouldRegressCodec", []interface{}{})
+	fake.shouldRegressCodecMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeLocalParticipantHelper) ShouldRegressCodecCallCount() int {
+	fake.shouldRegressCodecMutex.RLock()
+	defer fake.shouldRegressCodecMutex.RUnlock()
+	return len(fake.shouldRegressCodecArgsForCall)
+}
+
+func (fake *FakeLocalParticipantHelper) ShouldRegressCodecCalls(stub func() bool) {
+	fake.shouldRegressCodecMutex.Lock()
+	defer fake.shouldRegressCodecMutex.Unlock()
+	fake.ShouldRegressCodecStub = stub
+}
+
+func (fake *FakeLocalParticipantHelper) ShouldRegressCodecReturns(result1 bool) {
+	fake.shouldRegressCodecMutex.Lock()
+	defer fake.shouldRegressCodecMutex.Unlock()
+	fake.ShouldRegressCodecStub = nil
+	fake.shouldRegressCodecReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) ShouldRegressCodecReturnsOnCall(i int, result1 bool) {
+	fake.shouldRegressCodecMutex.Lock()
+	defer fake.shouldRegressCodecMutex.Unlock()
+	fake.ShouldRegressCodecStub = nil
+	if fake.shouldRegressCodecReturnsOnCall == nil {
+		fake.shouldRegressCodecReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.shouldRegressCodecReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeLocalParticipantHelper) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeLocalParticipantHelper) 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.LocalParticipantHelper = new(FakeLocalParticipantHelper)

pkg/rtc/types/typesfakes/fake_participant_listener.go

@@ -0,0 +1,356 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package typesfakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/rtc/types"
+	"github.com/livekit/protocol/datatrack"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeParticipantListener struct {
+	OnDataTrackMessageStub        func(types.Participant, []byte, *datatrack.Packet)
+	onDataTrackMessageMutex       sync.RWMutex
+	onDataTrackMessageArgsForCall []struct {
+		arg1 types.Participant
+		arg2 []byte
+		arg3 *datatrack.Packet
+	}
+	OnDataTrackPublishedStub        func(types.Participant, types.DataTrack)
+	onDataTrackPublishedMutex       sync.RWMutex
+	onDataTrackPublishedArgsForCall []struct {
+		arg1 types.Participant
+		arg2 types.DataTrack
+	}
+	OnDataTrackUnpublishedStub        func(types.Participant, types.DataTrack)
+	onDataTrackUnpublishedMutex       sync.RWMutex
+	onDataTrackUnpublishedArgsForCall []struct {
+		arg1 types.Participant
+		arg2 types.DataTrack
+	}
+	OnMetricsStub        func(types.Participant, *livekit.DataPacket)
+	onMetricsMutex       sync.RWMutex
+	onMetricsArgsForCall []struct {
+		arg1 types.Participant
+		arg2 *livekit.DataPacket
+	}
+	OnParticipantUpdateStub        func(types.Participant)
+	onParticipantUpdateMutex       sync.RWMutex
+	onParticipantUpdateArgsForCall []struct {
+		arg1 types.Participant
+	}
+	OnTrackPublishedStub        func(types.Participant, types.MediaTrack)
+	onTrackPublishedMutex       sync.RWMutex
+	onTrackPublishedArgsForCall []struct {
+		arg1 types.Participant
+		arg2 types.MediaTrack
+	}
+	OnTrackUnpublishedStub        func(types.Participant, types.MediaTrack)
+	onTrackUnpublishedMutex       sync.RWMutex
+	onTrackUnpublishedArgsForCall []struct {
+		arg1 types.Participant
+		arg2 types.MediaTrack
+	}
+	OnTrackUpdatedStub        func(types.Participant, types.MediaTrack)
+	onTrackUpdatedMutex       sync.RWMutex
+	onTrackUpdatedArgsForCall []struct {
+		arg1 types.Participant
+		arg2 types.MediaTrack
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeParticipantListener) OnDataTrackMessage(arg1 types.Participant, arg2 []byte, arg3 *datatrack.Packet) {
+	var arg2Copy []byte
+	if arg2 != nil {
+		arg2Copy = make([]byte, len(arg2))
+		copy(arg2Copy, arg2)
+	}
+	fake.onDataTrackMessageMutex.Lock()
+	fake.onDataTrackMessageArgsForCall = append(fake.onDataTrackMessageArgsForCall, struct {
+		arg1 types.Participant
+		arg2 []byte
+		arg3 *datatrack.Packet
+	}{arg1, arg2Copy, arg3})
+	stub := fake.OnDataTrackMessageStub
+	fake.recordInvocation("OnDataTrackMessage", []interface{}{arg1, arg2Copy, arg3})
+	fake.onDataTrackMessageMutex.Unlock()
+	if stub != nil {
+		fake.OnDataTrackMessageStub(arg1, arg2, arg3)
+	}
+}
+
+func (fake *FakeParticipantListener) OnDataTrackMessageCallCount() int {
+	fake.onDataTrackMessageMutex.RLock()
+	defer fake.onDataTrackMessageMutex.RUnlock()
+	return len(fake.onDataTrackMessageArgsForCall)
+}
+
+func (fake *FakeParticipantListener) OnDataTrackMessageCalls(stub func(types.Participant, []byte, *datatrack.Packet)) {
+	fake.onDataTrackMessageMutex.Lock()
+	defer fake.onDataTrackMessageMutex.Unlock()
+	fake.OnDataTrackMessageStub = stub
+}
+
+func (fake *FakeParticipantListener) OnDataTrackMessageArgsForCall(i int) (types.Participant, []byte, *datatrack.Packet) {
+	fake.onDataTrackMessageMutex.RLock()
+	defer fake.onDataTrackMessageMutex.RUnlock()
+	argsForCall := fake.onDataTrackMessageArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeParticipantListener) OnDataTrackPublished(arg1 types.Participant, arg2 types.DataTrack) {
+	fake.onDataTrackPublishedMutex.Lock()
+	fake.onDataTrackPublishedArgsForCall = append(fake.onDataTrackPublishedArgsForCall, struct {
+		arg1 types.Participant
+		arg2 types.DataTrack
+	}{arg1, arg2})
+	stub := fake.OnDataTrackPublishedStub
+	fake.recordInvocation("OnDataTrackPublished", []interface{}{arg1, arg2})
+	fake.onDataTrackPublishedMutex.Unlock()
+	if stub != nil {
+		fake.OnDataTrackPublishedStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantListener) OnDataTrackPublishedCallCount() int {
+	fake.onDataTrackPublishedMutex.RLock()
+	defer fake.onDataTrackPublishedMutex.RUnlock()
+	return len(fake.onDataTrackPublishedArgsForCall)
+}
+
+func (fake *FakeParticipantListener) OnDataTrackPublishedCalls(stub func(types.Participant, types.DataTrack)) {
+	fake.onDataTrackPublishedMutex.Lock()
+	defer fake.onDataTrackPublishedMutex.Unlock()
+	fake.OnDataTrackPublishedStub = stub
+}
+
+func (fake *FakeParticipantListener) OnDataTrackPublishedArgsForCall(i int) (types.Participant, types.DataTrack) {
+	fake.onDataTrackPublishedMutex.RLock()
+	defer fake.onDataTrackPublishedMutex.RUnlock()
+	argsForCall := fake.onDataTrackPublishedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantListener) OnDataTrackUnpublished(arg1 types.Participant, arg2 types.DataTrack) {
+	fake.onDataTrackUnpublishedMutex.Lock()
+	fake.onDataTrackUnpublishedArgsForCall = append(fake.onDataTrackUnpublishedArgsForCall, struct {
+		arg1 types.Participant
+		arg2 types.DataTrack
+	}{arg1, arg2})
+	stub := fake.OnDataTrackUnpublishedStub
+	fake.recordInvocation("OnDataTrackUnpublished", []interface{}{arg1, arg2})
+	fake.onDataTrackUnpublishedMutex.Unlock()
+	if stub != nil {
+		fake.OnDataTrackUnpublishedStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantListener) OnDataTrackUnpublishedCallCount() int {
+	fake.onDataTrackUnpublishedMutex.RLock()
+	defer fake.onDataTrackUnpublishedMutex.RUnlock()
+	return len(fake.onDataTrackUnpublishedArgsForCall)
+}
+
+func (fake *FakeParticipantListener) OnDataTrackUnpublishedCalls(stub func(types.Participant, types.DataTrack)) {
+	fake.onDataTrackUnpublishedMutex.Lock()
+	defer fake.onDataTrackUnpublishedMutex.Unlock()
+	fake.OnDataTrackUnpublishedStub = stub
+}
+
+func (fake *FakeParticipantListener) OnDataTrackUnpublishedArgsForCall(i int) (types.Participant, types.DataTrack) {
+	fake.onDataTrackUnpublishedMutex.RLock()
+	defer fake.onDataTrackUnpublishedMutex.RUnlock()
+	argsForCall := fake.onDataTrackUnpublishedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantListener) OnMetrics(arg1 types.Participant, arg2 *livekit.DataPacket) {
+	fake.onMetricsMutex.Lock()
+	fake.onMetricsArgsForCall = append(fake.onMetricsArgsForCall, struct {
+		arg1 types.Participant
+		arg2 *livekit.DataPacket
+	}{arg1, arg2})
+	stub := fake.OnMetricsStub
+	fake.recordInvocation("OnMetrics", []interface{}{arg1, arg2})
+	fake.onMetricsMutex.Unlock()
+	if stub != nil {
+		fake.OnMetricsStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantListener) OnMetricsCallCount() int {
+	fake.onMetricsMutex.RLock()
+	defer fake.onMetricsMutex.RUnlock()
+	return len(fake.onMetricsArgsForCall)
+}
+
+func (fake *FakeParticipantListener) OnMetricsCalls(stub func(types.Participant, *livekit.DataPacket)) {
+	fake.onMetricsMutex.Lock()
+	defer fake.onMetricsMutex.Unlock()
+	fake.OnMetricsStub = stub
+}
+
+func (fake *FakeParticipantListener) OnMetricsArgsForCall(i int) (types.Participant, *livekit.DataPacket) {
+	fake.onMetricsMutex.RLock()
+	defer fake.onMetricsMutex.RUnlock()
+	argsForCall := fake.onMetricsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantListener) OnParticipantUpdate(arg1 types.Participant) {
+	fake.onParticipantUpdateMutex.Lock()
+	fake.onParticipantUpdateArgsForCall = append(fake.onParticipantUpdateArgsForCall, struct {
+		arg1 types.Participant
+	}{arg1})
+	stub := fake.OnParticipantUpdateStub
+	fake.recordInvocation("OnParticipantUpdate", []interface{}{arg1})
+	fake.onParticipantUpdateMutex.Unlock()
+	if stub != nil {
+		fake.OnParticipantUpdateStub(arg1)
+	}
+}
+
+func (fake *FakeParticipantListener) OnParticipantUpdateCallCount() int {
+	fake.onParticipantUpdateMutex.RLock()
+	defer fake.onParticipantUpdateMutex.RUnlock()
+	return len(fake.onParticipantUpdateArgsForCall)
+}
+
+func (fake *FakeParticipantListener) OnParticipantUpdateCalls(stub func(types.Participant)) {
+	fake.onParticipantUpdateMutex.Lock()
+	defer fake.onParticipantUpdateMutex.Unlock()
+	fake.OnParticipantUpdateStub = stub
+}
+
+func (fake *FakeParticipantListener) OnParticipantUpdateArgsForCall(i int) types.Participant {
+	fake.onParticipantUpdateMutex.RLock()
+	defer fake.onParticipantUpdateMutex.RUnlock()
+	argsForCall := fake.onParticipantUpdateArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeParticipantListener) OnTrackPublished(arg1 types.Participant, arg2 types.MediaTrack) {
+	fake.onTrackPublishedMutex.Lock()
+	fake.onTrackPublishedArgsForCall = append(fake.onTrackPublishedArgsForCall, struct {
+		arg1 types.Participant
+		arg2 types.MediaTrack
+	}{arg1, arg2})
+	stub := fake.OnTrackPublishedStub
+	fake.recordInvocation("OnTrackPublished", []interface{}{arg1, arg2})
+	fake.onTrackPublishedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackPublishedStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantListener) OnTrackPublishedCallCount() int {
+	fake.onTrackPublishedMutex.RLock()
+	defer fake.onTrackPublishedMutex.RUnlock()
+	return len(fake.onTrackPublishedArgsForCall)
+}
+
+func (fake *FakeParticipantListener) OnTrackPublishedCalls(stub func(types.Participant, types.MediaTrack)) {
+	fake.onTrackPublishedMutex.Lock()
+	defer fake.onTrackPublishedMutex.Unlock()
+	fake.OnTrackPublishedStub = stub
+}
+
+func (fake *FakeParticipantListener) OnTrackPublishedArgsForCall(i int) (types.Participant, types.MediaTrack) {
+	fake.onTrackPublishedMutex.RLock()
+	defer fake.onTrackPublishedMutex.RUnlock()
+	argsForCall := fake.onTrackPublishedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantListener) OnTrackUnpublished(arg1 types.Participant, arg2 types.MediaTrack) {
+	fake.onTrackUnpublishedMutex.Lock()
+	fake.onTrackUnpublishedArgsForCall = append(fake.onTrackUnpublishedArgsForCall, struct {
+		arg1 types.Participant
+		arg2 types.MediaTrack
+	}{arg1, arg2})
+	stub := fake.OnTrackUnpublishedStub
+	fake.recordInvocation("OnTrackUnpublished", []interface{}{arg1, arg2})
+	fake.onTrackUnpublishedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackUnpublishedStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantListener) OnTrackUnpublishedCallCount() int {
+	fake.onTrackUnpublishedMutex.RLock()
+	defer fake.onTrackUnpublishedMutex.RUnlock()
+	return len(fake.onTrackUnpublishedArgsForCall)
+}
+
+func (fake *FakeParticipantListener) OnTrackUnpublishedCalls(stub func(types.Participant, types.MediaTrack)) {
+	fake.onTrackUnpublishedMutex.Lock()
+	defer fake.onTrackUnpublishedMutex.Unlock()
+	fake.OnTrackUnpublishedStub = stub
+}
+
+func (fake *FakeParticipantListener) OnTrackUnpublishedArgsForCall(i int) (types.Participant, types.MediaTrack) {
+	fake.onTrackUnpublishedMutex.RLock()
+	defer fake.onTrackUnpublishedMutex.RUnlock()
+	argsForCall := fake.onTrackUnpublishedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantListener) OnTrackUpdated(arg1 types.Participant, arg2 types.MediaTrack) {
+	fake.onTrackUpdatedMutex.Lock()
+	fake.onTrackUpdatedArgsForCall = append(fake.onTrackUpdatedArgsForCall, struct {
+		arg1 types.Participant
+		arg2 types.MediaTrack
+	}{arg1, arg2})
+	stub := fake.OnTrackUpdatedStub
+	fake.recordInvocation("OnTrackUpdated", []interface{}{arg1, arg2})
+	fake.onTrackUpdatedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackUpdatedStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantListener) OnTrackUpdatedCallCount() int {
+	fake.onTrackUpdatedMutex.RLock()
+	defer fake.onTrackUpdatedMutex.RUnlock()
+	return len(fake.onTrackUpdatedArgsForCall)
+}
+
+func (fake *FakeParticipantListener) OnTrackUpdatedCalls(stub func(types.Participant, types.MediaTrack)) {
+	fake.onTrackUpdatedMutex.Lock()
+	defer fake.onTrackUpdatedMutex.Unlock()
+	fake.OnTrackUpdatedStub = stub
+}
+
+func (fake *FakeParticipantListener) OnTrackUpdatedArgsForCall(i int) (types.Participant, types.MediaTrack) {
+	fake.onTrackUpdatedMutex.RLock()
+	defer fake.onTrackUpdatedMutex.RUnlock()
+	argsForCall := fake.onTrackUpdatedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantListener) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeParticipantListener) 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.ParticipantListener = new(FakeParticipantListener)

pkg/rtc/types/typesfakes/fake_participant_telemetry_listener.go

@@ -0,0 +1,666 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package typesfakes
+
+import (
+	"sync"
+	"time"
+
+	"github.com/livekit/livekit-server/pkg/rtc/types"
+	"github.com/livekit/livekit-server/pkg/telemetry"
+	"github.com/livekit/protocol/codecs/mime"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeParticipantTelemetryListener struct {
+	OnTrackMaxSubscribedVideoQualityStub        func(livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality)
+	onTrackMaxSubscribedVideoQualityMutex       sync.RWMutex
+	onTrackMaxSubscribedVideoQualityArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+		arg3 mime.MimeType
+		arg4 livekit.VideoQuality
+	}
+	OnTrackMutedStub        func(livekit.ParticipantID, *livekit.TrackInfo)
+	onTrackMutedMutex       sync.RWMutex
+	onTrackMutedArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+	}
+	OnTrackPublishRTPStatsStub        func(livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats)
+	onTrackPublishRTPStatsMutex       sync.RWMutex
+	onTrackPublishRTPStatsArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.TrackID
+		arg3 mime.MimeType
+		arg4 int
+		arg5 *livekit.RTPStats
+	}
+	OnTrackPublishRequestedStub        func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool)
+	onTrackPublishRequestedMutex       sync.RWMutex
+	onTrackPublishRequestedArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.ParticipantIdentity
+		arg3 *livekit.TrackInfo
+		arg4 bool
+	}
+	OnTrackPublishedStub        func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool)
+	onTrackPublishedMutex       sync.RWMutex
+	onTrackPublishedArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.ParticipantIdentity
+		arg3 *livekit.TrackInfo
+		arg4 bool
+	}
+	OnTrackPublishedUpdateStub        func(livekit.ParticipantID, *livekit.TrackInfo)
+	onTrackPublishedUpdateMutex       sync.RWMutex
+	onTrackPublishedUpdateArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+	}
+	OnTrackStatsStub        func(telemetry.StatsKey, *livekit.AnalyticsStat)
+	onTrackStatsMutex       sync.RWMutex
+	onTrackStatsArgsForCall []struct {
+		arg1 telemetry.StatsKey
+		arg2 *livekit.AnalyticsStat
+	}
+	OnTrackSubscribeFailedStub        func(livekit.ParticipantID, livekit.TrackID, error, bool)
+	onTrackSubscribeFailedMutex       sync.RWMutex
+	onTrackSubscribeFailedArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.TrackID
+		arg3 error
+		arg4 bool
+	}
+	OnTrackSubscribeRTPStatsStub        func(livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats)
+	onTrackSubscribeRTPStatsMutex       sync.RWMutex
+	onTrackSubscribeRTPStatsArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.TrackID
+		arg3 mime.MimeType
+		arg4 *livekit.RTPStats
+	}
+	OnTrackSubscribeRequestedStub        func(livekit.ParticipantID, *livekit.TrackInfo)
+	onTrackSubscribeRequestedMutex       sync.RWMutex
+	onTrackSubscribeRequestedArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+	}
+	OnTrackSubscribeStreamStartedStub        func(livekit.ParticipantID, *livekit.TrackInfo, time.Duration)
+	onTrackSubscribeStreamStartedMutex       sync.RWMutex
+	onTrackSubscribeStreamStartedArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+		arg3 time.Duration
+	}
+	OnTrackSubscribedStub        func(livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool)
+	onTrackSubscribedMutex       sync.RWMutex
+	onTrackSubscribedArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+		arg3 *livekit.ParticipantInfo
+		arg4 bool
+	}
+	OnTrackUnmutedStub        func(livekit.ParticipantID, *livekit.TrackInfo)
+	onTrackUnmutedMutex       sync.RWMutex
+	onTrackUnmutedArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+	}
+	OnTrackUnpublishedStub        func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool, bool)
+	onTrackUnpublishedMutex       sync.RWMutex
+	onTrackUnpublishedArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.ParticipantIdentity
+		arg3 *livekit.TrackInfo
+		arg4 bool
+		arg5 bool
+	}
+	OnTrackUnsubscribedStub        func(livekit.ParticipantID, *livekit.TrackInfo, bool)
+	onTrackUnsubscribedMutex       sync.RWMutex
+	onTrackUnsubscribedArgsForCall []struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+		arg3 bool
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackMaxSubscribedVideoQuality(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo, arg3 mime.MimeType, arg4 livekit.VideoQuality) {
+	fake.onTrackMaxSubscribedVideoQualityMutex.Lock()
+	fake.onTrackMaxSubscribedVideoQualityArgsForCall = append(fake.onTrackMaxSubscribedVideoQualityArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+		arg3 mime.MimeType
+		arg4 livekit.VideoQuality
+	}{arg1, arg2, arg3, arg4})
+	stub := fake.OnTrackMaxSubscribedVideoQualityStub
+	fake.recordInvocation("OnTrackMaxSubscribedVideoQuality", []interface{}{arg1, arg2, arg3, arg4})
+	fake.onTrackMaxSubscribedVideoQualityMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackMaxSubscribedVideoQualityStub(arg1, arg2, arg3, arg4)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackMaxSubscribedVideoQualityCallCount() int {
+	fake.onTrackMaxSubscribedVideoQualityMutex.RLock()
+	defer fake.onTrackMaxSubscribedVideoQualityMutex.RUnlock()
+	return len(fake.onTrackMaxSubscribedVideoQualityArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackMaxSubscribedVideoQualityCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality)) {
+	fake.onTrackMaxSubscribedVideoQualityMutex.Lock()
+	defer fake.onTrackMaxSubscribedVideoQualityMutex.Unlock()
+	fake.OnTrackMaxSubscribedVideoQualityStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackMaxSubscribedVideoQualityArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality) {
+	fake.onTrackMaxSubscribedVideoQualityMutex.RLock()
+	defer fake.onTrackMaxSubscribedVideoQualityMutex.RUnlock()
+	argsForCall := fake.onTrackMaxSubscribedVideoQualityArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackMuted(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo) {
+	fake.onTrackMutedMutex.Lock()
+	fake.onTrackMutedArgsForCall = append(fake.onTrackMutedArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+	}{arg1, arg2})
+	stub := fake.OnTrackMutedStub
+	fake.recordInvocation("OnTrackMuted", []interface{}{arg1, arg2})
+	fake.onTrackMutedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackMutedStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackMutedCallCount() int {
+	fake.onTrackMutedMutex.RLock()
+	defer fake.onTrackMutedMutex.RUnlock()
+	return len(fake.onTrackMutedArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackMutedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo)) {
+	fake.onTrackMutedMutex.Lock()
+	defer fake.onTrackMutedMutex.Unlock()
+	fake.OnTrackMutedStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackMutedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo) {
+	fake.onTrackMutedMutex.RLock()
+	defer fake.onTrackMutedMutex.RUnlock()
+	argsForCall := fake.onTrackMutedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishRTPStats(arg1 livekit.ParticipantID, arg2 livekit.TrackID, arg3 mime.MimeType, arg4 int, arg5 *livekit.RTPStats) {
+	fake.onTrackPublishRTPStatsMutex.Lock()
+	fake.onTrackPublishRTPStatsArgsForCall = append(fake.onTrackPublishRTPStatsArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.TrackID
+		arg3 mime.MimeType
+		arg4 int
+		arg5 *livekit.RTPStats
+	}{arg1, arg2, arg3, arg4, arg5})
+	stub := fake.OnTrackPublishRTPStatsStub
+	fake.recordInvocation("OnTrackPublishRTPStats", []interface{}{arg1, arg2, arg3, arg4, arg5})
+	fake.onTrackPublishRTPStatsMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackPublishRTPStatsStub(arg1, arg2, arg3, arg4, arg5)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishRTPStatsCallCount() int {
+	fake.onTrackPublishRTPStatsMutex.RLock()
+	defer fake.onTrackPublishRTPStatsMutex.RUnlock()
+	return len(fake.onTrackPublishRTPStatsArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishRTPStatsCalls(stub func(livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats)) {
+	fake.onTrackPublishRTPStatsMutex.Lock()
+	defer fake.onTrackPublishRTPStatsMutex.Unlock()
+	fake.OnTrackPublishRTPStatsStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishRTPStatsArgsForCall(i int) (livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats) {
+	fake.onTrackPublishRTPStatsMutex.RLock()
+	defer fake.onTrackPublishRTPStatsMutex.RUnlock()
+	argsForCall := fake.onTrackPublishRTPStatsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishRequested(arg1 livekit.ParticipantID, arg2 livekit.ParticipantIdentity, arg3 *livekit.TrackInfo, arg4 bool) {
+	fake.onTrackPublishRequestedMutex.Lock()
+	fake.onTrackPublishRequestedArgsForCall = append(fake.onTrackPublishRequestedArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.ParticipantIdentity
+		arg3 *livekit.TrackInfo
+		arg4 bool
+	}{arg1, arg2, arg3, arg4})
+	stub := fake.OnTrackPublishRequestedStub
+	fake.recordInvocation("OnTrackPublishRequested", []interface{}{arg1, arg2, arg3, arg4})
+	fake.onTrackPublishRequestedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackPublishRequestedStub(arg1, arg2, arg3, arg4)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishRequestedCallCount() int {
+	fake.onTrackPublishRequestedMutex.RLock()
+	defer fake.onTrackPublishRequestedMutex.RUnlock()
+	return len(fake.onTrackPublishRequestedArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishRequestedCalls(stub func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool)) {
+	fake.onTrackPublishRequestedMutex.Lock()
+	defer fake.onTrackPublishRequestedMutex.Unlock()
+	fake.OnTrackPublishRequestedStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishRequestedArgsForCall(i int) (livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) {
+	fake.onTrackPublishRequestedMutex.RLock()
+	defer fake.onTrackPublishRequestedMutex.RUnlock()
+	argsForCall := fake.onTrackPublishRequestedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublished(arg1 livekit.ParticipantID, arg2 livekit.ParticipantIdentity, arg3 *livekit.TrackInfo, arg4 bool) {
+	fake.onTrackPublishedMutex.Lock()
+	fake.onTrackPublishedArgsForCall = append(fake.onTrackPublishedArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.ParticipantIdentity
+		arg3 *livekit.TrackInfo
+		arg4 bool
+	}{arg1, arg2, arg3, arg4})
+	stub := fake.OnTrackPublishedStub
+	fake.recordInvocation("OnTrackPublished", []interface{}{arg1, arg2, arg3, arg4})
+	fake.onTrackPublishedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackPublishedStub(arg1, arg2, arg3, arg4)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishedCallCount() int {
+	fake.onTrackPublishedMutex.RLock()
+	defer fake.onTrackPublishedMutex.RUnlock()
+	return len(fake.onTrackPublishedArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishedCalls(stub func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool)) {
+	fake.onTrackPublishedMutex.Lock()
+	defer fake.onTrackPublishedMutex.Unlock()
+	fake.OnTrackPublishedStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishedArgsForCall(i int) (livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) {
+	fake.onTrackPublishedMutex.RLock()
+	defer fake.onTrackPublishedMutex.RUnlock()
+	argsForCall := fake.onTrackPublishedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishedUpdate(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo) {
+	fake.onTrackPublishedUpdateMutex.Lock()
+	fake.onTrackPublishedUpdateArgsForCall = append(fake.onTrackPublishedUpdateArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+	}{arg1, arg2})
+	stub := fake.OnTrackPublishedUpdateStub
+	fake.recordInvocation("OnTrackPublishedUpdate", []interface{}{arg1, arg2})
+	fake.onTrackPublishedUpdateMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackPublishedUpdateStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishedUpdateCallCount() int {
+	fake.onTrackPublishedUpdateMutex.RLock()
+	defer fake.onTrackPublishedUpdateMutex.RUnlock()
+	return len(fake.onTrackPublishedUpdateArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishedUpdateCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo)) {
+	fake.onTrackPublishedUpdateMutex.Lock()
+	defer fake.onTrackPublishedUpdateMutex.Unlock()
+	fake.OnTrackPublishedUpdateStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackPublishedUpdateArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo) {
+	fake.onTrackPublishedUpdateMutex.RLock()
+	defer fake.onTrackPublishedUpdateMutex.RUnlock()
+	argsForCall := fake.onTrackPublishedUpdateArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackStats(arg1 telemetry.StatsKey, arg2 *livekit.AnalyticsStat) {
+	fake.onTrackStatsMutex.Lock()
+	fake.onTrackStatsArgsForCall = append(fake.onTrackStatsArgsForCall, struct {
+		arg1 telemetry.StatsKey
+		arg2 *livekit.AnalyticsStat
+	}{arg1, arg2})
+	stub := fake.OnTrackStatsStub
+	fake.recordInvocation("OnTrackStats", []interface{}{arg1, arg2})
+	fake.onTrackStatsMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackStatsStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackStatsCallCount() int {
+	fake.onTrackStatsMutex.RLock()
+	defer fake.onTrackStatsMutex.RUnlock()
+	return len(fake.onTrackStatsArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackStatsCalls(stub func(telemetry.StatsKey, *livekit.AnalyticsStat)) {
+	fake.onTrackStatsMutex.Lock()
+	defer fake.onTrackStatsMutex.Unlock()
+	fake.OnTrackStatsStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackStatsArgsForCall(i int) (telemetry.StatsKey, *livekit.AnalyticsStat) {
+	fake.onTrackStatsMutex.RLock()
+	defer fake.onTrackStatsMutex.RUnlock()
+	argsForCall := fake.onTrackStatsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeFailed(arg1 livekit.ParticipantID, arg2 livekit.TrackID, arg3 error, arg4 bool) {
+	fake.onTrackSubscribeFailedMutex.Lock()
+	fake.onTrackSubscribeFailedArgsForCall = append(fake.onTrackSubscribeFailedArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.TrackID
+		arg3 error
+		arg4 bool
+	}{arg1, arg2, arg3, arg4})
+	stub := fake.OnTrackSubscribeFailedStub
+	fake.recordInvocation("OnTrackSubscribeFailed", []interface{}{arg1, arg2, arg3, arg4})
+	fake.onTrackSubscribeFailedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackSubscribeFailedStub(arg1, arg2, arg3, arg4)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeFailedCallCount() int {
+	fake.onTrackSubscribeFailedMutex.RLock()
+	defer fake.onTrackSubscribeFailedMutex.RUnlock()
+	return len(fake.onTrackSubscribeFailedArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeFailedCalls(stub func(livekit.ParticipantID, livekit.TrackID, error, bool)) {
+	fake.onTrackSubscribeFailedMutex.Lock()
+	defer fake.onTrackSubscribeFailedMutex.Unlock()
+	fake.OnTrackSubscribeFailedStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeFailedArgsForCall(i int) (livekit.ParticipantID, livekit.TrackID, error, bool) {
+	fake.onTrackSubscribeFailedMutex.RLock()
+	defer fake.onTrackSubscribeFailedMutex.RUnlock()
+	argsForCall := fake.onTrackSubscribeFailedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRTPStats(arg1 livekit.ParticipantID, arg2 livekit.TrackID, arg3 mime.MimeType, arg4 *livekit.RTPStats) {
+	fake.onTrackSubscribeRTPStatsMutex.Lock()
+	fake.onTrackSubscribeRTPStatsArgsForCall = append(fake.onTrackSubscribeRTPStatsArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.TrackID
+		arg3 mime.MimeType
+		arg4 *livekit.RTPStats
+	}{arg1, arg2, arg3, arg4})
+	stub := fake.OnTrackSubscribeRTPStatsStub
+	fake.recordInvocation("OnTrackSubscribeRTPStats", []interface{}{arg1, arg2, arg3, arg4})
+	fake.onTrackSubscribeRTPStatsMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackSubscribeRTPStatsStub(arg1, arg2, arg3, arg4)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRTPStatsCallCount() int {
+	fake.onTrackSubscribeRTPStatsMutex.RLock()
+	defer fake.onTrackSubscribeRTPStatsMutex.RUnlock()
+	return len(fake.onTrackSubscribeRTPStatsArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRTPStatsCalls(stub func(livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats)) {
+	fake.onTrackSubscribeRTPStatsMutex.Lock()
+	defer fake.onTrackSubscribeRTPStatsMutex.Unlock()
+	fake.OnTrackSubscribeRTPStatsStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRTPStatsArgsForCall(i int) (livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats) {
+	fake.onTrackSubscribeRTPStatsMutex.RLock()
+	defer fake.onTrackSubscribeRTPStatsMutex.RUnlock()
+	argsForCall := fake.onTrackSubscribeRTPStatsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRequested(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo) {
+	fake.onTrackSubscribeRequestedMutex.Lock()
+	fake.onTrackSubscribeRequestedArgsForCall = append(fake.onTrackSubscribeRequestedArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+	}{arg1, arg2})
+	stub := fake.OnTrackSubscribeRequestedStub
+	fake.recordInvocation("OnTrackSubscribeRequested", []interface{}{arg1, arg2})
+	fake.onTrackSubscribeRequestedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackSubscribeRequestedStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRequestedCallCount() int {
+	fake.onTrackSubscribeRequestedMutex.RLock()
+	defer fake.onTrackSubscribeRequestedMutex.RUnlock()
+	return len(fake.onTrackSubscribeRequestedArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRequestedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo)) {
+	fake.onTrackSubscribeRequestedMutex.Lock()
+	defer fake.onTrackSubscribeRequestedMutex.Unlock()
+	fake.OnTrackSubscribeRequestedStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRequestedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo) {
+	fake.onTrackSubscribeRequestedMutex.RLock()
+	defer fake.onTrackSubscribeRequestedMutex.RUnlock()
+	argsForCall := fake.onTrackSubscribeRequestedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeStreamStarted(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo, arg3 time.Duration) {
+	fake.onTrackSubscribeStreamStartedMutex.Lock()
+	fake.onTrackSubscribeStreamStartedArgsForCall = append(fake.onTrackSubscribeStreamStartedArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+		arg3 time.Duration
+	}{arg1, arg2, arg3})
+	stub := fake.OnTrackSubscribeStreamStartedStub
+	fake.recordInvocation("OnTrackSubscribeStreamStarted", []interface{}{arg1, arg2, arg3})
+	fake.onTrackSubscribeStreamStartedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackSubscribeStreamStartedStub(arg1, arg2, arg3)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeStreamStartedCallCount() int {
+	fake.onTrackSubscribeStreamStartedMutex.RLock()
+	defer fake.onTrackSubscribeStreamStartedMutex.RUnlock()
+	return len(fake.onTrackSubscribeStreamStartedArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeStreamStartedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo, time.Duration)) {
+	fake.onTrackSubscribeStreamStartedMutex.Lock()
+	defer fake.onTrackSubscribeStreamStartedMutex.Unlock()
+	fake.OnTrackSubscribeStreamStartedStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeStreamStartedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo, time.Duration) {
+	fake.onTrackSubscribeStreamStartedMutex.RLock()
+	defer fake.onTrackSubscribeStreamStartedMutex.RUnlock()
+	argsForCall := fake.onTrackSubscribeStreamStartedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribed(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo, arg3 *livekit.ParticipantInfo, arg4 bool) {
+	fake.onTrackSubscribedMutex.Lock()
+	fake.onTrackSubscribedArgsForCall = append(fake.onTrackSubscribedArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+		arg3 *livekit.ParticipantInfo
+		arg4 bool
+	}{arg1, arg2, arg3, arg4})
+	stub := fake.OnTrackSubscribedStub
+	fake.recordInvocation("OnTrackSubscribed", []interface{}{arg1, arg2, arg3, arg4})
+	fake.onTrackSubscribedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackSubscribedStub(arg1, arg2, arg3, arg4)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribedCallCount() int {
+	fake.onTrackSubscribedMutex.RLock()
+	defer fake.onTrackSubscribedMutex.RUnlock()
+	return len(fake.onTrackSubscribedArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool)) {
+	fake.onTrackSubscribedMutex.Lock()
+	defer fake.onTrackSubscribedMutex.Unlock()
+	fake.OnTrackSubscribedStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackSubscribedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool) {
+	fake.onTrackSubscribedMutex.RLock()
+	defer fake.onTrackSubscribedMutex.RUnlock()
+	argsForCall := fake.onTrackSubscribedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnmuted(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo) {
+	fake.onTrackUnmutedMutex.Lock()
+	fake.onTrackUnmutedArgsForCall = append(fake.onTrackUnmutedArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+	}{arg1, arg2})
+	stub := fake.OnTrackUnmutedStub
+	fake.recordInvocation("OnTrackUnmuted", []interface{}{arg1, arg2})
+	fake.onTrackUnmutedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackUnmutedStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnmutedCallCount() int {
+	fake.onTrackUnmutedMutex.RLock()
+	defer fake.onTrackUnmutedMutex.RUnlock()
+	return len(fake.onTrackUnmutedArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnmutedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo)) {
+	fake.onTrackUnmutedMutex.Lock()
+	defer fake.onTrackUnmutedMutex.Unlock()
+	fake.OnTrackUnmutedStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnmutedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo) {
+	fake.onTrackUnmutedMutex.RLock()
+	defer fake.onTrackUnmutedMutex.RUnlock()
+	argsForCall := fake.onTrackUnmutedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnpublished(arg1 livekit.ParticipantID, arg2 livekit.ParticipantIdentity, arg3 *livekit.TrackInfo, arg4 bool, arg5 bool) {
+	fake.onTrackUnpublishedMutex.Lock()
+	fake.onTrackUnpublishedArgsForCall = append(fake.onTrackUnpublishedArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 livekit.ParticipantIdentity
+		arg3 *livekit.TrackInfo
+		arg4 bool
+		arg5 bool
+	}{arg1, arg2, arg3, arg4, arg5})
+	stub := fake.OnTrackUnpublishedStub
+	fake.recordInvocation("OnTrackUnpublished", []interface{}{arg1, arg2, arg3, arg4, arg5})
+	fake.onTrackUnpublishedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackUnpublishedStub(arg1, arg2, arg3, arg4, arg5)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnpublishedCallCount() int {
+	fake.onTrackUnpublishedMutex.RLock()
+	defer fake.onTrackUnpublishedMutex.RUnlock()
+	return len(fake.onTrackUnpublishedArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnpublishedCalls(stub func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool, bool)) {
+	fake.onTrackUnpublishedMutex.Lock()
+	defer fake.onTrackUnpublishedMutex.Unlock()
+	fake.OnTrackUnpublishedStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnpublishedArgsForCall(i int) (livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool, bool) {
+	fake.onTrackUnpublishedMutex.RLock()
+	defer fake.onTrackUnpublishedMutex.RUnlock()
+	argsForCall := fake.onTrackUnpublishedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnsubscribed(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo, arg3 bool) {
+	fake.onTrackUnsubscribedMutex.Lock()
+	fake.onTrackUnsubscribedArgsForCall = append(fake.onTrackUnsubscribedArgsForCall, struct {
+		arg1 livekit.ParticipantID
+		arg2 *livekit.TrackInfo
+		arg3 bool
+	}{arg1, arg2, arg3})
+	stub := fake.OnTrackUnsubscribedStub
+	fake.recordInvocation("OnTrackUnsubscribed", []interface{}{arg1, arg2, arg3})
+	fake.onTrackUnsubscribedMutex.Unlock()
+	if stub != nil {
+		fake.OnTrackUnsubscribedStub(arg1, arg2, arg3)
+	}
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnsubscribedCallCount() int {
+	fake.onTrackUnsubscribedMutex.RLock()
+	defer fake.onTrackUnsubscribedMutex.RUnlock()
+	return len(fake.onTrackUnsubscribedArgsForCall)
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnsubscribedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo, bool)) {
+	fake.onTrackUnsubscribedMutex.Lock()
+	defer fake.onTrackUnsubscribedMutex.Unlock()
+	fake.OnTrackUnsubscribedStub = stub
+}
+
+func (fake *FakeParticipantTelemetryListener) OnTrackUnsubscribedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo, bool) {
+	fake.onTrackUnsubscribedMutex.RLock()
+	defer fake.onTrackUnsubscribedMutex.RUnlock()
+	argsForCall := fake.onTrackUnsubscribedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeParticipantTelemetryListener) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeParticipantTelemetryListener) 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.ParticipantTelemetryListener = new(FakeParticipantTelemetryListener)

pkg/rtc/types/typesfakes/fake_room.go

@@ -0,0 +1,541 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package typesfakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/rtc/types"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeRoom struct {
+	GetLocalParticipantsStub        func() []types.LocalParticipant
+	getLocalParticipantsMutex       sync.RWMutex
+	getLocalParticipantsArgsForCall []struct {
+	}
+	getLocalParticipantsReturns struct {
+		result1 []types.LocalParticipant
+	}
+	getLocalParticipantsReturnsOnCall map[int]struct {
+		result1 []types.LocalParticipant
+	}
+	IDStub        func() livekit.RoomID
+	iDMutex       sync.RWMutex
+	iDArgsForCall []struct {
+	}
+	iDReturns struct {
+		result1 livekit.RoomID
+	}
+	iDReturnsOnCall map[int]struct {
+		result1 livekit.RoomID
+	}
+	IsDataMessageUserPacketDuplicateStub        func(*livekit.UserPacket) bool
+	isDataMessageUserPacketDuplicateMutex       sync.RWMutex
+	isDataMessageUserPacketDuplicateArgsForCall []struct {
+		arg1 *livekit.UserPacket
+	}
+	isDataMessageUserPacketDuplicateReturns struct {
+		result1 bool
+	}
+	isDataMessageUserPacketDuplicateReturnsOnCall map[int]struct {
+		result1 bool
+	}
+	NameStub        func() livekit.RoomName
+	nameMutex       sync.RWMutex
+	nameArgsForCall []struct {
+	}
+	nameReturns struct {
+		result1 livekit.RoomName
+	}
+	nameReturnsOnCall map[int]struct {
+		result1 livekit.RoomName
+	}
+	RemoveParticipantStub        func(livekit.ParticipantIdentity, livekit.ParticipantID, types.ParticipantCloseReason)
+	removeParticipantMutex       sync.RWMutex
+	removeParticipantArgsForCall []struct {
+		arg1 livekit.ParticipantIdentity
+		arg2 livekit.ParticipantID
+		arg3 types.ParticipantCloseReason
+	}
+	ResolveDataTrackForSubscriberStub        func(types.LocalParticipant, livekit.TrackID) types.DataResolverResult
+	resolveDataTrackForSubscriberMutex       sync.RWMutex
+	resolveDataTrackForSubscriberArgsForCall []struct {
+		arg1 types.LocalParticipant
+		arg2 livekit.TrackID
+	}
+	resolveDataTrackForSubscriberReturns struct {
+		result1 types.DataResolverResult
+	}
+	resolveDataTrackForSubscriberReturnsOnCall map[int]struct {
+		result1 types.DataResolverResult
+	}
+	ResolveMediaTrackForSubscriberStub        func(types.LocalParticipant, livekit.TrackID) types.MediaResolverResult
+	resolveMediaTrackForSubscriberMutex       sync.RWMutex
+	resolveMediaTrackForSubscriberArgsForCall []struct {
+		arg1 types.LocalParticipant
+		arg2 livekit.TrackID
+	}
+	resolveMediaTrackForSubscriberReturns struct {
+		result1 types.MediaResolverResult
+	}
+	resolveMediaTrackForSubscriberReturnsOnCall map[int]struct {
+		result1 types.MediaResolverResult
+	}
+	UpdateSubscriptionsStub        func(types.LocalParticipant, []livekit.TrackID, []*livekit.ParticipantTracks, bool)
+	updateSubscriptionsMutex       sync.RWMutex
+	updateSubscriptionsArgsForCall []struct {
+		arg1 types.LocalParticipant
+		arg2 []livekit.TrackID
+		arg3 []*livekit.ParticipantTracks
+		arg4 bool
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeRoom) GetLocalParticipants() []types.LocalParticipant {
+	fake.getLocalParticipantsMutex.Lock()
+	ret, specificReturn := fake.getLocalParticipantsReturnsOnCall[len(fake.getLocalParticipantsArgsForCall)]
+	fake.getLocalParticipantsArgsForCall = append(fake.getLocalParticipantsArgsForCall, struct {
+	}{})
+	stub := fake.GetLocalParticipantsStub
+	fakeReturns := fake.getLocalParticipantsReturns
+	fake.recordInvocation("GetLocalParticipants", []interface{}{})
+	fake.getLocalParticipantsMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRoom) GetLocalParticipantsCallCount() int {
+	fake.getLocalParticipantsMutex.RLock()
+	defer fake.getLocalParticipantsMutex.RUnlock()
+	return len(fake.getLocalParticipantsArgsForCall)
+}
+
+func (fake *FakeRoom) GetLocalParticipantsCalls(stub func() []types.LocalParticipant) {
+	fake.getLocalParticipantsMutex.Lock()
+	defer fake.getLocalParticipantsMutex.Unlock()
+	fake.GetLocalParticipantsStub = stub
+}
+
+func (fake *FakeRoom) GetLocalParticipantsReturns(result1 []types.LocalParticipant) {
+	fake.getLocalParticipantsMutex.Lock()
+	defer fake.getLocalParticipantsMutex.Unlock()
+	fake.GetLocalParticipantsStub = nil
+	fake.getLocalParticipantsReturns = struct {
+		result1 []types.LocalParticipant
+	}{result1}
+}
+
+func (fake *FakeRoom) GetLocalParticipantsReturnsOnCall(i int, result1 []types.LocalParticipant) {
+	fake.getLocalParticipantsMutex.Lock()
+	defer fake.getLocalParticipantsMutex.Unlock()
+	fake.GetLocalParticipantsStub = nil
+	if fake.getLocalParticipantsReturnsOnCall == nil {
+		fake.getLocalParticipantsReturnsOnCall = make(map[int]struct {
+			result1 []types.LocalParticipant
+		})
+	}
+	fake.getLocalParticipantsReturnsOnCall[i] = struct {
+		result1 []types.LocalParticipant
+	}{result1}
+}
+
+func (fake *FakeRoom) ID() livekit.RoomID {
+	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 *FakeRoom) IDCallCount() int {
+	fake.iDMutex.RLock()
+	defer fake.iDMutex.RUnlock()
+	return len(fake.iDArgsForCall)
+}
+
+func (fake *FakeRoom) IDCalls(stub func() livekit.RoomID) {
+	fake.iDMutex.Lock()
+	defer fake.iDMutex.Unlock()
+	fake.IDStub = stub
+}
+
+func (fake *FakeRoom) IDReturns(result1 livekit.RoomID) {
+	fake.iDMutex.Lock()
+	defer fake.iDMutex.Unlock()
+	fake.IDStub = nil
+	fake.iDReturns = struct {
+		result1 livekit.RoomID
+	}{result1}
+}
+
+func (fake *FakeRoom) IDReturnsOnCall(i int, result1 livekit.RoomID) {
+	fake.iDMutex.Lock()
+	defer fake.iDMutex.Unlock()
+	fake.IDStub = nil
+	if fake.iDReturnsOnCall == nil {
+		fake.iDReturnsOnCall = make(map[int]struct {
+			result1 livekit.RoomID
+		})
+	}
+	fake.iDReturnsOnCall[i] = struct {
+		result1 livekit.RoomID
+	}{result1}
+}
+
+func (fake *FakeRoom) IsDataMessageUserPacketDuplicate(arg1 *livekit.UserPacket) bool {
+	fake.isDataMessageUserPacketDuplicateMutex.Lock()
+	ret, specificReturn := fake.isDataMessageUserPacketDuplicateReturnsOnCall[len(fake.isDataMessageUserPacketDuplicateArgsForCall)]
+	fake.isDataMessageUserPacketDuplicateArgsForCall = append(fake.isDataMessageUserPacketDuplicateArgsForCall, struct {
+		arg1 *livekit.UserPacket
+	}{arg1})
+	stub := fake.IsDataMessageUserPacketDuplicateStub
+	fakeReturns := fake.isDataMessageUserPacketDuplicateReturns
+	fake.recordInvocation("IsDataMessageUserPacketDuplicate", []interface{}{arg1})
+	fake.isDataMessageUserPacketDuplicateMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRoom) IsDataMessageUserPacketDuplicateCallCount() int {
+	fake.isDataMessageUserPacketDuplicateMutex.RLock()
+	defer fake.isDataMessageUserPacketDuplicateMutex.RUnlock()
+	return len(fake.isDataMessageUserPacketDuplicateArgsForCall)
+}
+
+func (fake *FakeRoom) IsDataMessageUserPacketDuplicateCalls(stub func(*livekit.UserPacket) bool) {
+	fake.isDataMessageUserPacketDuplicateMutex.Lock()
+	defer fake.isDataMessageUserPacketDuplicateMutex.Unlock()
+	fake.IsDataMessageUserPacketDuplicateStub = stub
+}
+
+func (fake *FakeRoom) IsDataMessageUserPacketDuplicateArgsForCall(i int) *livekit.UserPacket {
+	fake.isDataMessageUserPacketDuplicateMutex.RLock()
+	defer fake.isDataMessageUserPacketDuplicateMutex.RUnlock()
+	argsForCall := fake.isDataMessageUserPacketDuplicateArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeRoom) IsDataMessageUserPacketDuplicateReturns(result1 bool) {
+	fake.isDataMessageUserPacketDuplicateMutex.Lock()
+	defer fake.isDataMessageUserPacketDuplicateMutex.Unlock()
+	fake.IsDataMessageUserPacketDuplicateStub = nil
+	fake.isDataMessageUserPacketDuplicateReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeRoom) IsDataMessageUserPacketDuplicateReturnsOnCall(i int, result1 bool) {
+	fake.isDataMessageUserPacketDuplicateMutex.Lock()
+	defer fake.isDataMessageUserPacketDuplicateMutex.Unlock()
+	fake.IsDataMessageUserPacketDuplicateStub = nil
+	if fake.isDataMessageUserPacketDuplicateReturnsOnCall == nil {
+		fake.isDataMessageUserPacketDuplicateReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.isDataMessageUserPacketDuplicateReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeRoom) Name() livekit.RoomName {
+	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 *FakeRoom) NameCallCount() int {
+	fake.nameMutex.RLock()
+	defer fake.nameMutex.RUnlock()
+	return len(fake.nameArgsForCall)
+}
+
+func (fake *FakeRoom) NameCalls(stub func() livekit.RoomName) {
+	fake.nameMutex.Lock()
+	defer fake.nameMutex.Unlock()
+	fake.NameStub = stub
+}
+
+func (fake *FakeRoom) NameReturns(result1 livekit.RoomName) {
+	fake.nameMutex.Lock()
+	defer fake.nameMutex.Unlock()
+	fake.NameStub = nil
+	fake.nameReturns = struct {
+		result1 livekit.RoomName
+	}{result1}
+}
+
+func (fake *FakeRoom) NameReturnsOnCall(i int, result1 livekit.RoomName) {
+	fake.nameMutex.Lock()
+	defer fake.nameMutex.Unlock()
+	fake.NameStub = nil
+	if fake.nameReturnsOnCall == nil {
+		fake.nameReturnsOnCall = make(map[int]struct {
+			result1 livekit.RoomName
+		})
+	}
+	fake.nameReturnsOnCall[i] = struct {
+		result1 livekit.RoomName
+	}{result1}
+}
+
+func (fake *FakeRoom) RemoveParticipant(arg1 livekit.ParticipantIdentity, arg2 livekit.ParticipantID, arg3 types.ParticipantCloseReason) {
+	fake.removeParticipantMutex.Lock()
+	fake.removeParticipantArgsForCall = append(fake.removeParticipantArgsForCall, struct {
+		arg1 livekit.ParticipantIdentity
+		arg2 livekit.ParticipantID
+		arg3 types.ParticipantCloseReason
+	}{arg1, arg2, arg3})
+	stub := fake.RemoveParticipantStub
+	fake.recordInvocation("RemoveParticipant", []interface{}{arg1, arg2, arg3})
+	fake.removeParticipantMutex.Unlock()
+	if stub != nil {
+		fake.RemoveParticipantStub(arg1, arg2, arg3)
+	}
+}
+
+func (fake *FakeRoom) RemoveParticipantCallCount() int {
+	fake.removeParticipantMutex.RLock()
+	defer fake.removeParticipantMutex.RUnlock()
+	return len(fake.removeParticipantArgsForCall)
+}
+
+func (fake *FakeRoom) RemoveParticipantCalls(stub func(livekit.ParticipantIdentity, livekit.ParticipantID, types.ParticipantCloseReason)) {
+	fake.removeParticipantMutex.Lock()
+	defer fake.removeParticipantMutex.Unlock()
+	fake.RemoveParticipantStub = stub
+}
+
+func (fake *FakeRoom) RemoveParticipantArgsForCall(i int) (livekit.ParticipantIdentity, livekit.ParticipantID, types.ParticipantCloseReason) {
+	fake.removeParticipantMutex.RLock()
+	defer fake.removeParticipantMutex.RUnlock()
+	argsForCall := fake.removeParticipantArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeRoom) ResolveDataTrackForSubscriber(arg1 types.LocalParticipant, arg2 livekit.TrackID) types.DataResolverResult {
+	fake.resolveDataTrackForSubscriberMutex.Lock()
+	ret, specificReturn := fake.resolveDataTrackForSubscriberReturnsOnCall[len(fake.resolveDataTrackForSubscriberArgsForCall)]
+	fake.resolveDataTrackForSubscriberArgsForCall = append(fake.resolveDataTrackForSubscriberArgsForCall, struct {
+		arg1 types.LocalParticipant
+		arg2 livekit.TrackID
+	}{arg1, arg2})
+	stub := fake.ResolveDataTrackForSubscriberStub
+	fakeReturns := fake.resolveDataTrackForSubscriberReturns
+	fake.recordInvocation("ResolveDataTrackForSubscriber", []interface{}{arg1, arg2})
+	fake.resolveDataTrackForSubscriberMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRoom) ResolveDataTrackForSubscriberCallCount() int {
+	fake.resolveDataTrackForSubscriberMutex.RLock()
+	defer fake.resolveDataTrackForSubscriberMutex.RUnlock()
+	return len(fake.resolveDataTrackForSubscriberArgsForCall)
+}
+
+func (fake *FakeRoom) ResolveDataTrackForSubscriberCalls(stub func(types.LocalParticipant, livekit.TrackID) types.DataResolverResult) {
+	fake.resolveDataTrackForSubscriberMutex.Lock()
+	defer fake.resolveDataTrackForSubscriberMutex.Unlock()
+	fake.ResolveDataTrackForSubscriberStub = stub
+}
+
+func (fake *FakeRoom) ResolveDataTrackForSubscriberArgsForCall(i int) (types.LocalParticipant, livekit.TrackID) {
+	fake.resolveDataTrackForSubscriberMutex.RLock()
+	defer fake.resolveDataTrackForSubscriberMutex.RUnlock()
+	argsForCall := fake.resolveDataTrackForSubscriberArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeRoom) ResolveDataTrackForSubscriberReturns(result1 types.DataResolverResult) {
+	fake.resolveDataTrackForSubscriberMutex.Lock()
+	defer fake.resolveDataTrackForSubscriberMutex.Unlock()
+	fake.ResolveDataTrackForSubscriberStub = nil
+	fake.resolveDataTrackForSubscriberReturns = struct {
+		result1 types.DataResolverResult
+	}{result1}
+}
+
+func (fake *FakeRoom) ResolveDataTrackForSubscriberReturnsOnCall(i int, result1 types.DataResolverResult) {
+	fake.resolveDataTrackForSubscriberMutex.Lock()
+	defer fake.resolveDataTrackForSubscriberMutex.Unlock()
+	fake.ResolveDataTrackForSubscriberStub = nil
+	if fake.resolveDataTrackForSubscriberReturnsOnCall == nil {
+		fake.resolveDataTrackForSubscriberReturnsOnCall = make(map[int]struct {
+			result1 types.DataResolverResult
+		})
+	}
+	fake.resolveDataTrackForSubscriberReturnsOnCall[i] = struct {
+		result1 types.DataResolverResult
+	}{result1}
+}
+
+func (fake *FakeRoom) ResolveMediaTrackForSubscriber(arg1 types.LocalParticipant, arg2 livekit.TrackID) types.MediaResolverResult {
+	fake.resolveMediaTrackForSubscriberMutex.Lock()
+	ret, specificReturn := fake.resolveMediaTrackForSubscriberReturnsOnCall[len(fake.resolveMediaTrackForSubscriberArgsForCall)]
+	fake.resolveMediaTrackForSubscriberArgsForCall = append(fake.resolveMediaTrackForSubscriberArgsForCall, struct {
+		arg1 types.LocalParticipant
+		arg2 livekit.TrackID
+	}{arg1, arg2})
+	stub := fake.ResolveMediaTrackForSubscriberStub
+	fakeReturns := fake.resolveMediaTrackForSubscriberReturns
+	fake.recordInvocation("ResolveMediaTrackForSubscriber", []interface{}{arg1, arg2})
+	fake.resolveMediaTrackForSubscriberMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRoom) ResolveMediaTrackForSubscriberCallCount() int {
+	fake.resolveMediaTrackForSubscriberMutex.RLock()
+	defer fake.resolveMediaTrackForSubscriberMutex.RUnlock()
+	return len(fake.resolveMediaTrackForSubscriberArgsForCall)
+}
+
+func (fake *FakeRoom) ResolveMediaTrackForSubscriberCalls(stub func(types.LocalParticipant, livekit.TrackID) types.MediaResolverResult) {
+	fake.resolveMediaTrackForSubscriberMutex.Lock()
+	defer fake.resolveMediaTrackForSubscriberMutex.Unlock()
+	fake.ResolveMediaTrackForSubscriberStub = stub
+}
+
+func (fake *FakeRoom) ResolveMediaTrackForSubscriberArgsForCall(i int) (types.LocalParticipant, livekit.TrackID) {
+	fake.resolveMediaTrackForSubscriberMutex.RLock()
+	defer fake.resolveMediaTrackForSubscriberMutex.RUnlock()
+	argsForCall := fake.resolveMediaTrackForSubscriberArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeRoom) ResolveMediaTrackForSubscriberReturns(result1 types.MediaResolverResult) {
+	fake.resolveMediaTrackForSubscriberMutex.Lock()
+	defer fake.resolveMediaTrackForSubscriberMutex.Unlock()
+	fake.ResolveMediaTrackForSubscriberStub = nil
+	fake.resolveMediaTrackForSubscriberReturns = struct {
+		result1 types.MediaResolverResult
+	}{result1}
+}
+
+func (fake *FakeRoom) ResolveMediaTrackForSubscriberReturnsOnCall(i int, result1 types.MediaResolverResult) {
+	fake.resolveMediaTrackForSubscriberMutex.Lock()
+	defer fake.resolveMediaTrackForSubscriberMutex.Unlock()
+	fake.ResolveMediaTrackForSubscriberStub = nil
+	if fake.resolveMediaTrackForSubscriberReturnsOnCall == nil {
+		fake.resolveMediaTrackForSubscriberReturnsOnCall = make(map[int]struct {
+			result1 types.MediaResolverResult
+		})
+	}
+	fake.resolveMediaTrackForSubscriberReturnsOnCall[i] = struct {
+		result1 types.MediaResolverResult
+	}{result1}
+}
+
+func (fake *FakeRoom) UpdateSubscriptions(arg1 types.LocalParticipant, arg2 []livekit.TrackID, arg3 []*livekit.ParticipantTracks, arg4 bool) {
+	var arg2Copy []livekit.TrackID
+	if arg2 != nil {
+		arg2Copy = make([]livekit.TrackID, len(arg2))
+		copy(arg2Copy, arg2)
+	}
+	var arg3Copy []*livekit.ParticipantTracks
+	if arg3 != nil {
+		arg3Copy = make([]*livekit.ParticipantTracks, len(arg3))
+		copy(arg3Copy, arg3)
+	}
+	fake.updateSubscriptionsMutex.Lock()
+	fake.updateSubscriptionsArgsForCall = append(fake.updateSubscriptionsArgsForCall, struct {
+		arg1 types.LocalParticipant
+		arg2 []livekit.TrackID
+		arg3 []*livekit.ParticipantTracks
+		arg4 bool
+	}{arg1, arg2Copy, arg3Copy, arg4})
+	stub := fake.UpdateSubscriptionsStub
+	fake.recordInvocation("UpdateSubscriptions", []interface{}{arg1, arg2Copy, arg3Copy, arg4})
+	fake.updateSubscriptionsMutex.Unlock()
+	if stub != nil {
+		fake.UpdateSubscriptionsStub(arg1, arg2, arg3, arg4)
+	}
+}
+
+func (fake *FakeRoom) UpdateSubscriptionsCallCount() int {
+	fake.updateSubscriptionsMutex.RLock()
+	defer fake.updateSubscriptionsMutex.RUnlock()
+	return len(fake.updateSubscriptionsArgsForCall)
+}
+
+func (fake *FakeRoom) UpdateSubscriptionsCalls(stub func(types.LocalParticipant, []livekit.TrackID, []*livekit.ParticipantTracks, bool)) {
+	fake.updateSubscriptionsMutex.Lock()
+	defer fake.updateSubscriptionsMutex.Unlock()
+	fake.UpdateSubscriptionsStub = stub
+}
+
+func (fake *FakeRoom) UpdateSubscriptionsArgsForCall(i int) (types.LocalParticipant, []livekit.TrackID, []*livekit.ParticipantTracks, bool) {
+	fake.updateSubscriptionsMutex.RLock()
+	defer fake.updateSubscriptionsMutex.RUnlock()
+	argsForCall := fake.updateSubscriptionsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeRoom) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeRoom) 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.Room = new(FakeRoom)

pkg/rtc/types/typesfakes/fake_websocket_client.go

@@ -0,0 +1,480 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package typesfakes
+
+import (
+	"io"
+	"sync"
+	"time"
+
+	"github.com/livekit/livekit-server/pkg/rtc/types"
+)
+
+type FakeWebsocketClient struct {
+	CloseStub        func() error
+	closeMutex       sync.RWMutex
+	closeArgsForCall []struct {
+	}
+	closeReturns struct {
+		result1 error
+	}
+	closeReturnsOnCall map[int]struct {
+		result1 error
+	}
+	NextReaderStub        func() (int, io.Reader, error)
+	nextReaderMutex       sync.RWMutex
+	nextReaderArgsForCall []struct {
+	}
+	nextReaderReturns struct {
+		result1 int
+		result2 io.Reader
+		result3 error
+	}
+	nextReaderReturnsOnCall map[int]struct {
+		result1 int
+		result2 io.Reader
+		result3 error
+	}
+	ReadMessageStub        func() (int, []byte, error)
+	readMessageMutex       sync.RWMutex
+	readMessageArgsForCall []struct {
+	}
+	readMessageReturns struct {
+		result1 int
+		result2 []byte
+		result3 error
+	}
+	readMessageReturnsOnCall map[int]struct {
+		result1 int
+		result2 []byte
+		result3 error
+	}
+	SetReadDeadlineStub        func(time.Time) error
+	setReadDeadlineMutex       sync.RWMutex
+	setReadDeadlineArgsForCall []struct {
+		arg1 time.Time
+	}
+	setReadDeadlineReturns struct {
+		result1 error
+	}
+	setReadDeadlineReturnsOnCall map[int]struct {
+		result1 error
+	}
+	WriteControlStub        func(int, []byte, time.Time) error
+	writeControlMutex       sync.RWMutex
+	writeControlArgsForCall []struct {
+		arg1 int
+		arg2 []byte
+		arg3 time.Time
+	}
+	writeControlReturns struct {
+		result1 error
+	}
+	writeControlReturnsOnCall map[int]struct {
+		result1 error
+	}
+	WriteMessageStub        func(int, []byte) error
+	writeMessageMutex       sync.RWMutex
+	writeMessageArgsForCall []struct {
+		arg1 int
+		arg2 []byte
+	}
+	writeMessageReturns struct {
+		result1 error
+	}
+	writeMessageReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeWebsocketClient) Close() error {
+	fake.closeMutex.Lock()
+	ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)]
+	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
+	}{})
+	stub := fake.CloseStub
+	fakeReturns := fake.closeReturns
+	fake.recordInvocation("Close", []interface{}{})
+	fake.closeMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeWebsocketClient) CloseCallCount() int {
+	fake.closeMutex.RLock()
+	defer fake.closeMutex.RUnlock()
+	return len(fake.closeArgsForCall)
+}
+
+func (fake *FakeWebsocketClient) CloseCalls(stub func() error) {
+	fake.closeMutex.Lock()
+	defer fake.closeMutex.Unlock()
+	fake.CloseStub = stub
+}
+
+func (fake *FakeWebsocketClient) CloseReturns(result1 error) {
+	fake.closeMutex.Lock()
+	defer fake.closeMutex.Unlock()
+	fake.CloseStub = nil
+	fake.closeReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeWebsocketClient) 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 *FakeWebsocketClient) NextReader() (int, io.Reader, error) {
+	fake.nextReaderMutex.Lock()
+	ret, specificReturn := fake.nextReaderReturnsOnCall[len(fake.nextReaderArgsForCall)]
+	fake.nextReaderArgsForCall = append(fake.nextReaderArgsForCall, struct {
+	}{})
+	stub := fake.NextReaderStub
+	fakeReturns := fake.nextReaderReturns
+	fake.recordInvocation("NextReader", []interface{}{})
+	fake.nextReaderMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1, ret.result2, ret.result3
+	}
+	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
+}
+
+func (fake *FakeWebsocketClient) NextReaderCallCount() int {
+	fake.nextReaderMutex.RLock()
+	defer fake.nextReaderMutex.RUnlock()
+	return len(fake.nextReaderArgsForCall)
+}
+
+func (fake *FakeWebsocketClient) NextReaderCalls(stub func() (int, io.Reader, error)) {
+	fake.nextReaderMutex.Lock()
+	defer fake.nextReaderMutex.Unlock()
+	fake.NextReaderStub = stub
+}
+
+func (fake *FakeWebsocketClient) NextReaderReturns(result1 int, result2 io.Reader, result3 error) {
+	fake.nextReaderMutex.Lock()
+	defer fake.nextReaderMutex.Unlock()
+	fake.NextReaderStub = nil
+	fake.nextReaderReturns = struct {
+		result1 int
+		result2 io.Reader
+		result3 error
+	}{result1, result2, result3}
+}
+
+func (fake *FakeWebsocketClient) NextReaderReturnsOnCall(i int, result1 int, result2 io.Reader, result3 error) {
+	fake.nextReaderMutex.Lock()
+	defer fake.nextReaderMutex.Unlock()
+	fake.NextReaderStub = nil
+	if fake.nextReaderReturnsOnCall == nil {
+		fake.nextReaderReturnsOnCall = make(map[int]struct {
+			result1 int
+			result2 io.Reader
+			result3 error
+		})
+	}
+	fake.nextReaderReturnsOnCall[i] = struct {
+		result1 int
+		result2 io.Reader
+		result3 error
+	}{result1, result2, result3}
+}
+
+func (fake *FakeWebsocketClient) ReadMessage() (int, []byte, error) {
+	fake.readMessageMutex.Lock()
+	ret, specificReturn := fake.readMessageReturnsOnCall[len(fake.readMessageArgsForCall)]
+	fake.readMessageArgsForCall = append(fake.readMessageArgsForCall, struct {
+	}{})
+	stub := fake.ReadMessageStub
+	fakeReturns := fake.readMessageReturns
+	fake.recordInvocation("ReadMessage", []interface{}{})
+	fake.readMessageMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1, ret.result2, ret.result3
+	}
+	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
+}
+
+func (fake *FakeWebsocketClient) ReadMessageCallCount() int {
+	fake.readMessageMutex.RLock()
+	defer fake.readMessageMutex.RUnlock()
+	return len(fake.readMessageArgsForCall)
+}
+
+func (fake *FakeWebsocketClient) ReadMessageCalls(stub func() (int, []byte, error)) {
+	fake.readMessageMutex.Lock()
+	defer fake.readMessageMutex.Unlock()
+	fake.ReadMessageStub = stub
+}
+
+func (fake *FakeWebsocketClient) ReadMessageReturns(result1 int, result2 []byte, result3 error) {
+	fake.readMessageMutex.Lock()
+	defer fake.readMessageMutex.Unlock()
+	fake.ReadMessageStub = nil
+	fake.readMessageReturns = struct {
+		result1 int
+		result2 []byte
+		result3 error
+	}{result1, result2, result3}
+}
+
+func (fake *FakeWebsocketClient) ReadMessageReturnsOnCall(i int, result1 int, result2 []byte, result3 error) {
+	fake.readMessageMutex.Lock()
+	defer fake.readMessageMutex.Unlock()
+	fake.ReadMessageStub = nil
+	if fake.readMessageReturnsOnCall == nil {
+		fake.readMessageReturnsOnCall = make(map[int]struct {
+			result1 int
+			result2 []byte
+			result3 error
+		})
+	}
+	fake.readMessageReturnsOnCall[i] = struct {
+		result1 int
+		result2 []byte
+		result3 error
+	}{result1, result2, result3}
+}
+
+func (fake *FakeWebsocketClient) SetReadDeadline(arg1 time.Time) error {
+	fake.setReadDeadlineMutex.Lock()
+	ret, specificReturn := fake.setReadDeadlineReturnsOnCall[len(fake.setReadDeadlineArgsForCall)]
+	fake.setReadDeadlineArgsForCall = append(fake.setReadDeadlineArgsForCall, struct {
+		arg1 time.Time
+	}{arg1})
+	stub := fake.SetReadDeadlineStub
+	fakeReturns := fake.setReadDeadlineReturns
+	fake.recordInvocation("SetReadDeadline", []interface{}{arg1})
+	fake.setReadDeadlineMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeWebsocketClient) SetReadDeadlineCallCount() int {
+	fake.setReadDeadlineMutex.RLock()
+	defer fake.setReadDeadlineMutex.RUnlock()
+	return len(fake.setReadDeadlineArgsForCall)
+}
+
+func (fake *FakeWebsocketClient) SetReadDeadlineCalls(stub func(time.Time) error) {
+	fake.setReadDeadlineMutex.Lock()
+	defer fake.setReadDeadlineMutex.Unlock()
+	fake.SetReadDeadlineStub = stub
+}
+
+func (fake *FakeWebsocketClient) SetReadDeadlineArgsForCall(i int) time.Time {
+	fake.setReadDeadlineMutex.RLock()
+	defer fake.setReadDeadlineMutex.RUnlock()
+	argsForCall := fake.setReadDeadlineArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeWebsocketClient) SetReadDeadlineReturns(result1 error) {
+	fake.setReadDeadlineMutex.Lock()
+	defer fake.setReadDeadlineMutex.Unlock()
+	fake.SetReadDeadlineStub = nil
+	fake.setReadDeadlineReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeWebsocketClient) SetReadDeadlineReturnsOnCall(i int, result1 error) {
+	fake.setReadDeadlineMutex.Lock()
+	defer fake.setReadDeadlineMutex.Unlock()
+	fake.SetReadDeadlineStub = nil
+	if fake.setReadDeadlineReturnsOnCall == nil {
+		fake.setReadDeadlineReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.setReadDeadlineReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeWebsocketClient) WriteControl(arg1 int, arg2 []byte, arg3 time.Time) error {
+	var arg2Copy []byte
+	if arg2 != nil {
+		arg2Copy = make([]byte, len(arg2))
+		copy(arg2Copy, arg2)
+	}
+	fake.writeControlMutex.Lock()
+	ret, specificReturn := fake.writeControlReturnsOnCall[len(fake.writeControlArgsForCall)]
+	fake.writeControlArgsForCall = append(fake.writeControlArgsForCall, struct {
+		arg1 int
+		arg2 []byte
+		arg3 time.Time
+	}{arg1, arg2Copy, arg3})
+	stub := fake.WriteControlStub
+	fakeReturns := fake.writeControlReturns
+	fake.recordInvocation("WriteControl", []interface{}{arg1, arg2Copy, arg3})
+	fake.writeControlMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeWebsocketClient) WriteControlCallCount() int {
+	fake.writeControlMutex.RLock()
+	defer fake.writeControlMutex.RUnlock()
+	return len(fake.writeControlArgsForCall)
+}
+
+func (fake *FakeWebsocketClient) WriteControlCalls(stub func(int, []byte, time.Time) error) {
+	fake.writeControlMutex.Lock()
+	defer fake.writeControlMutex.Unlock()
+	fake.WriteControlStub = stub
+}
+
+func (fake *FakeWebsocketClient) WriteControlArgsForCall(i int) (int, []byte, time.Time) {
+	fake.writeControlMutex.RLock()
+	defer fake.writeControlMutex.RUnlock()
+	argsForCall := fake.writeControlArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeWebsocketClient) WriteControlReturns(result1 error) {
+	fake.writeControlMutex.Lock()
+	defer fake.writeControlMutex.Unlock()
+	fake.WriteControlStub = nil
+	fake.writeControlReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeWebsocketClient) WriteControlReturnsOnCall(i int, result1 error) {
+	fake.writeControlMutex.Lock()
+	defer fake.writeControlMutex.Unlock()
+	fake.WriteControlStub = nil
+	if fake.writeControlReturnsOnCall == nil {
+		fake.writeControlReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.writeControlReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeWebsocketClient) WriteMessage(arg1 int, arg2 []byte) error {
+	var arg2Copy []byte
+	if arg2 != nil {
+		arg2Copy = make([]byte, len(arg2))
+		copy(arg2Copy, arg2)
+	}
+	fake.writeMessageMutex.Lock()
+	ret, specificReturn := fake.writeMessageReturnsOnCall[len(fake.writeMessageArgsForCall)]
+	fake.writeMessageArgsForCall = append(fake.writeMessageArgsForCall, struct {
+		arg1 int
+		arg2 []byte
+	}{arg1, arg2Copy})
+	stub := fake.WriteMessageStub
+	fakeReturns := fake.writeMessageReturns
+	fake.recordInvocation("WriteMessage", []interface{}{arg1, arg2Copy})
+	fake.writeMessageMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeWebsocketClient) WriteMessageCallCount() int {
+	fake.writeMessageMutex.RLock()
+	defer fake.writeMessageMutex.RUnlock()
+	return len(fake.writeMessageArgsForCall)
+}
+
+func (fake *FakeWebsocketClient) WriteMessageCalls(stub func(int, []byte) error) {
+	fake.writeMessageMutex.Lock()
+	defer fake.writeMessageMutex.Unlock()
+	fake.WriteMessageStub = stub
+}
+
+func (fake *FakeWebsocketClient) WriteMessageArgsForCall(i int) (int, []byte) {
+	fake.writeMessageMutex.RLock()
+	defer fake.writeMessageMutex.RUnlock()
+	argsForCall := fake.writeMessageArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeWebsocketClient) WriteMessageReturns(result1 error) {
+	fake.writeMessageMutex.Lock()
+	defer fake.writeMessageMutex.Unlock()
+	fake.WriteMessageStub = nil
+	fake.writeMessageReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeWebsocketClient) WriteMessageReturnsOnCall(i int, result1 error) {
+	fake.writeMessageMutex.Lock()
+	defer fake.writeMessageMutex.Unlock()
+	fake.WriteMessageStub = nil
+	if fake.writeMessageReturnsOnCall == nil {
+		fake.writeMessageReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.writeMessageReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeWebsocketClient) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeWebsocketClient) 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.WebsocketClient = new(FakeWebsocketClient)