add convenience methods to participant

pkg/rtc/participant.go

@@ -363,6 +363,11 @@ func (p *ParticipantImpl) IsRecorder() bool {
 	return grants.GetParticipantKind() == livekit.ParticipantInfo_EGRESS || grants.Video.Recorder
 }
 
+func (p *ParticipantImpl) IsAgent() bool {
+	grants := p.grants.Load()
+	return grants.GetParticipantKind() == livekit.ParticipantInfo_AGENT || grants.Video.Agent
+}
+
 func (p *ParticipantImpl) IsDependent() bool {
 	grants := p.grants.Load()
 	switch grants.GetParticipantKind() {
@@ -608,6 +613,10 @@ func (p *ParticipantImpl) CanSkipBroadcast() bool {
 	return !p.requireBroadcast
 }
 
+func (p *ParticipantImpl) VersionNumber() uint32 {
+	return p.version.Load()
+}
+
 func (p *ParticipantImpl) ToProtoWithVersion() (*livekit.ParticipantInfo, utils.TimedVersion) {
 	if p.dirty.Load() {
 		p.lock.Lock()

pkg/rtc/types/interfaces.go

@@ -39,6 +39,7 @@ type WebsocketClient interface {
 	ReadMessage() (messageType int, p []byte, err error)
 	WriteMessage(messageType int, data []byte) error
 	WriteControl(messageType int, data []byte, deadline time.Time) error
+	SetReadDeadline(deadline time.Time) error
 	Close() error
 }
 
@@ -257,8 +258,10 @@ type Participant interface {
 	Kind() livekit.ParticipantInfo_Kind
 	IsRecorder() bool
 	IsDependent() bool
+	IsAgent() bool
 
 	CanSkipBroadcast() bool
+	VersionNumber() uint32
 	ToProto() *livekit.ParticipantInfo
 
 	IsPublisher() bool

pkg/rtc/types/typesfakes/fake_local_participant.go

@@ -497,6 +497,16 @@ type FakeLocalParticipant struct {
 	identityReturnsOnCall map[int]struct {
 		result1 livekit.ParticipantIdentity
 	}
+	IsAgentStub        func() bool
+	isAgentMutex       sync.RWMutex
+	isAgentArgsForCall []struct {
+	}
+	isAgentReturns struct {
+		result1 bool
+	}
+	isAgentReturnsOnCall map[int]struct {
+		result1 bool
+	}
 	IsClosedStub        func() bool
 	isClosedMutex       sync.RWMutex
 	isClosedArgsForCall []struct {
@@ -1067,6 +1077,16 @@ type FakeLocalParticipant struct {
 		arg1 livekit.ParticipantID
 		arg2 uint32
 	}
+	VersionNumberStub        func() uint32
+	versionNumberMutex       sync.RWMutex
+	versionNumberArgsForCall []struct {
+	}
+	versionNumberReturns struct {
+		result1 uint32
+	}
+	versionNumberReturnsOnCall map[int]struct {
+		result1 uint32
+	}
 	WaitUntilSubscribedStub        func(time.Duration) error
 	waitUntilSubscribedMutex       sync.RWMutex
 	waitUntilSubscribedArgsForCall []struct {
@@ -3603,6 +3623,59 @@ func (fake *FakeLocalParticipant) IdentityReturnsOnCall(i int, result1 livekit.P
 	}{result1}
 }
 
+func (fake *FakeLocalParticipant) IsAgent() bool {
+	fake.isAgentMutex.Lock()
+	ret, specificReturn := fake.isAgentReturnsOnCall[len(fake.isAgentArgsForCall)]
+	fake.isAgentArgsForCall = append(fake.isAgentArgsForCall, struct {
+	}{})
+	stub := fake.IsAgentStub
+	fakeReturns := fake.isAgentReturns
+	fake.recordInvocation("IsAgent", []interface{}{})
+	fake.isAgentMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeLocalParticipant) IsAgentCallCount() int {
+	fake.isAgentMutex.RLock()
+	defer fake.isAgentMutex.RUnlock()
+	return len(fake.isAgentArgsForCall)
+}
+
+func (fake *FakeLocalParticipant) IsAgentCalls(stub func() bool) {
+	fake.isAgentMutex.Lock()
+	defer fake.isAgentMutex.Unlock()
+	fake.IsAgentStub = stub
+}
+
+func (fake *FakeLocalParticipant) IsAgentReturns(result1 bool) {
+	fake.isAgentMutex.Lock()
+	defer fake.isAgentMutex.Unlock()
+	fake.IsAgentStub = nil
+	fake.isAgentReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeLocalParticipant) IsAgentReturnsOnCall(i int, result1 bool) {
+	fake.isAgentMutex.Lock()
+	defer fake.isAgentMutex.Unlock()
+	fake.IsAgentStub = nil
+	if fake.isAgentReturnsOnCall == nil {
+		fake.isAgentReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.isAgentReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
 func (fake *FakeLocalParticipant) IsClosed() bool {
 	fake.isClosedMutex.Lock()
 	ret, specificReturn := fake.isClosedReturnsOnCall[len(fake.isClosedArgsForCall)]
@@ -6783,6 +6856,59 @@ func (fake *FakeLocalParticipant) VerifySubscribeParticipantInfoArgsForCall(i in
 	return argsForCall.arg1, argsForCall.arg2
 }
 
+func (fake *FakeLocalParticipant) VersionNumber() uint32 {
+	fake.versionNumberMutex.Lock()
+	ret, specificReturn := fake.versionNumberReturnsOnCall[len(fake.versionNumberArgsForCall)]
+	fake.versionNumberArgsForCall = append(fake.versionNumberArgsForCall, struct {
+	}{})
+	stub := fake.VersionNumberStub
+	fakeReturns := fake.versionNumberReturns
+	fake.recordInvocation("VersionNumber", []interface{}{})
+	fake.versionNumberMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeLocalParticipant) VersionNumberCallCount() int {
+	fake.versionNumberMutex.RLock()
+	defer fake.versionNumberMutex.RUnlock()
+	return len(fake.versionNumberArgsForCall)
+}
+
+func (fake *FakeLocalParticipant) VersionNumberCalls(stub func() uint32) {
+	fake.versionNumberMutex.Lock()
+	defer fake.versionNumberMutex.Unlock()
+	fake.VersionNumberStub = stub
+}
+
+func (fake *FakeLocalParticipant) VersionNumberReturns(result1 uint32) {
+	fake.versionNumberMutex.Lock()
+	defer fake.versionNumberMutex.Unlock()
+	fake.VersionNumberStub = nil
+	fake.versionNumberReturns = struct {
+		result1 uint32
+	}{result1}
+}
+
+func (fake *FakeLocalParticipant) VersionNumberReturnsOnCall(i int, result1 uint32) {
+	fake.versionNumberMutex.Lock()
+	defer fake.versionNumberMutex.Unlock()
+	fake.VersionNumberStub = nil
+	if fake.versionNumberReturnsOnCall == nil {
+		fake.versionNumberReturnsOnCall = make(map[int]struct {
+			result1 uint32
+		})
+	}
+	fake.versionNumberReturnsOnCall[i] = struct {
+		result1 uint32
+	}{result1}
+}
+
 func (fake *FakeLocalParticipant) WaitUntilSubscribed(arg1 time.Duration) error {
 	fake.waitUntilSubscribedMutex.Lock()
 	ret, specificReturn := fake.waitUntilSubscribedReturnsOnCall[len(fake.waitUntilSubscribedArgsForCall)]
@@ -7011,6 +7137,8 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} {
 	defer fake.iDMutex.RUnlock()
 	fake.identityMutex.RLock()
 	defer fake.identityMutex.RUnlock()
+	fake.isAgentMutex.RLock()
+	defer fake.isAgentMutex.RUnlock()
 	fake.isClosedMutex.RLock()
 	defer fake.isClosedMutex.RUnlock()
 	fake.isDependentMutex.RLock()
@@ -7151,6 +7279,8 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} {
 	defer fake.updateVideoTrackMutex.RUnlock()
 	fake.verifySubscribeParticipantInfoMutex.RLock()
 	defer fake.verifySubscribeParticipantInfoMutex.RUnlock()
+	fake.versionNumberMutex.RLock()
+	defer fake.versionNumberMutex.RUnlock()
 	fake.waitUntilSubscribedMutex.RLock()
 	defer fake.waitUntilSubscribedMutex.RUnlock()
 	fake.writeSubscriberRTCPMutex.RLock()

pkg/rtc/types/typesfakes/fake_participant.go

@@ -128,6 +128,16 @@ type FakeParticipant struct {
 	identityReturnsOnCall map[int]struct {
 		result1 livekit.ParticipantIdentity
 	}
+	IsAgentStub        func() bool
+	isAgentMutex       sync.RWMutex
+	isAgentArgsForCall []struct {
+	}
+	isAgentReturns struct {
+		result1 bool
+	}
+	isAgentReturnsOnCall map[int]struct {
+		result1 bool
+	}
 	IsDependentStub        func() bool
 	isDependentMutex       sync.RWMutex
 	isDependentArgsForCall []struct {
@@ -220,6 +230,16 @@ type FakeParticipant struct {
 	updateSubscriptionPermissionReturnsOnCall map[int]struct {
 		result1 error
 	}
+	VersionNumberStub        func() uint32
+	versionNumberMutex       sync.RWMutex
+	versionNumberArgsForCall []struct {
+	}
+	versionNumberReturns struct {
+		result1 uint32
+	}
+	versionNumberReturnsOnCall map[int]struct {
+		result1 uint32
+	}
 	invocations      map[string][][]interface{}
 	invocationsMutex sync.RWMutex
 }
@@ -837,6 +857,59 @@ func (fake *FakeParticipant) IdentityReturnsOnCall(i int, result1 livekit.Partic
 	}{result1}
 }
 
+func (fake *FakeParticipant) IsAgent() bool {
+	fake.isAgentMutex.Lock()
+	ret, specificReturn := fake.isAgentReturnsOnCall[len(fake.isAgentArgsForCall)]
+	fake.isAgentArgsForCall = append(fake.isAgentArgsForCall, struct {
+	}{})
+	stub := fake.IsAgentStub
+	fakeReturns := fake.isAgentReturns
+	fake.recordInvocation("IsAgent", []interface{}{})
+	fake.isAgentMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeParticipant) IsAgentCallCount() int {
+	fake.isAgentMutex.RLock()
+	defer fake.isAgentMutex.RUnlock()
+	return len(fake.isAgentArgsForCall)
+}
+
+func (fake *FakeParticipant) IsAgentCalls(stub func() bool) {
+	fake.isAgentMutex.Lock()
+	defer fake.isAgentMutex.Unlock()
+	fake.IsAgentStub = stub
+}
+
+func (fake *FakeParticipant) IsAgentReturns(result1 bool) {
+	fake.isAgentMutex.Lock()
+	defer fake.isAgentMutex.Unlock()
+	fake.IsAgentStub = nil
+	fake.isAgentReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeParticipant) IsAgentReturnsOnCall(i int, result1 bool) {
+	fake.isAgentMutex.Lock()
+	defer fake.isAgentMutex.Unlock()
+	fake.IsAgentStub = nil
+	if fake.isAgentReturnsOnCall == nil {
+		fake.isAgentReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.isAgentReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
 func (fake *FakeParticipant) IsDependent() bool {
 	fake.isDependentMutex.Lock()
 	ret, specificReturn := fake.isDependentReturnsOnCall[len(fake.isDependentArgsForCall)]
@@ -1308,6 +1381,59 @@ func (fake *FakeParticipant) UpdateSubscriptionPermissionReturnsOnCall(i int, re
 	}{result1}
 }
 
+func (fake *FakeParticipant) VersionNumber() uint32 {
+	fake.versionNumberMutex.Lock()
+	ret, specificReturn := fake.versionNumberReturnsOnCall[len(fake.versionNumberArgsForCall)]
+	fake.versionNumberArgsForCall = append(fake.versionNumberArgsForCall, struct {
+	}{})
+	stub := fake.VersionNumberStub
+	fakeReturns := fake.versionNumberReturns
+	fake.recordInvocation("VersionNumber", []interface{}{})
+	fake.versionNumberMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeParticipant) VersionNumberCallCount() int {
+	fake.versionNumberMutex.RLock()
+	defer fake.versionNumberMutex.RUnlock()
+	return len(fake.versionNumberArgsForCall)
+}
+
+func (fake *FakeParticipant) VersionNumberCalls(stub func() uint32) {
+	fake.versionNumberMutex.Lock()
+	defer fake.versionNumberMutex.Unlock()
+	fake.VersionNumberStub = stub
+}
+
+func (fake *FakeParticipant) VersionNumberReturns(result1 uint32) {
+	fake.versionNumberMutex.Lock()
+	defer fake.versionNumberMutex.Unlock()
+	fake.VersionNumberStub = nil
+	fake.versionNumberReturns = struct {
+		result1 uint32
+	}{result1}
+}
+
+func (fake *FakeParticipant) VersionNumberReturnsOnCall(i int, result1 uint32) {
+	fake.versionNumberMutex.Lock()
+	defer fake.versionNumberMutex.Unlock()
+	fake.VersionNumberStub = nil
+	if fake.versionNumberReturnsOnCall == nil {
+		fake.versionNumberReturnsOnCall = make(map[int]struct {
+			result1 uint32
+		})
+	}
+	fake.versionNumberReturnsOnCall[i] = struct {
+		result1 uint32
+	}{result1}
+}
+
 func (fake *FakeParticipant) Invocations() map[string][][]interface{} {
 	fake.invocationsMutex.RLock()
 	defer fake.invocationsMutex.RUnlock()
@@ -1333,6 +1459,8 @@ func (fake *FakeParticipant) Invocations() map[string][][]interface{} {
 	defer fake.iDMutex.RUnlock()
 	fake.identityMutex.RLock()
 	defer fake.identityMutex.RUnlock()
+	fake.isAgentMutex.RLock()
+	defer fake.isAgentMutex.RUnlock()
 	fake.isDependentMutex.RLock()
 	defer fake.isDependentMutex.RUnlock()
 	fake.isPublisherMutex.RLock()
@@ -1351,6 +1479,8 @@ func (fake *FakeParticipant) Invocations() map[string][][]interface{} {
 	defer fake.toProtoMutex.RUnlock()
 	fake.updateSubscriptionPermissionMutex.RLock()
 	defer fake.updateSubscriptionPermissionMutex.RUnlock()
+	fake.versionNumberMutex.RLock()
+	defer fake.versionNumberMutex.RUnlock()
 	copiedInvocations := map[string][][]interface{}{}
 	for key, value := range fake.invocations {
 		copiedInvocations[key] = value

pkg/rtc/types/typesfakes/fake_websocket_client.go

@@ -33,6 +33,17 @@ type FakeWebsocketClient struct {
 		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 {
@@ -174,6 +185,67 @@ func (fake *FakeWebsocketClient) ReadMessageReturnsOnCall(i int, result1 int, re
 	}{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 {
@@ -316,6 +388,8 @@ func (fake *FakeWebsocketClient) Invocations() map[string][][]interface{} {
 	defer fake.closeMutex.RUnlock()
 	fake.readMessageMutex.RLock()
 	defer fake.readMessageMutex.RUnlock()
+	fake.setReadDeadlineMutex.RLock()
+	defer fake.setReadDeadlineMutex.RUnlock()
 	fake.writeControlMutex.RLock()
 	defer fake.writeControlMutex.RUnlock()
 	fake.writeMessageMutex.RLock()