livekit-protocol 0.7.5

Livekit protocol and utilities for the Rust SDK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

package utils

import (
	"fmt"
	"time"

	"github.com/livekit/psrpc"
)

type DataChannelRpcErrorCode uint32

const (
	DataChannelRpcApplicationError DataChannelRpcErrorCode = 1500 + iota
	DataChannelRpcConnectionTimeout
	DataChannelRpcResponseTimeout
	DataChannelRpcRecipientDisconnected
	DataChannelRpcResponsePayloadTooLarge
	DataChannelRpcSendFailed
)

const (
	DataChannelRpcUnsupportedMethod DataChannelRpcErrorCode = 1400 + iota
	DataChannelRpcRecipientNotFound
	DataChannelRpcRequestPayloadTooLarge
	DataChannelRpcUnsupportedServer
	DataChannelRpcUnsupportedVersion
)

const (
	DataChannelRpcMaxRoundTripLatency    = 2000 * time.Millisecond
	DataChannelRpcMaxMessageBytes        = 256
	DataChannelRpcMaxDataBytes           = 15360 // 15KiB
	DataChannelRpcMaxPayloadBytes        = 15360 // 15KiB
	DataChannelRpcDefaultResponseTimeout = 10000 * time.Millisecond
)

var dataChannelRpcErrorMessages = map[DataChannelRpcErrorCode]string{
	DataChannelRpcApplicationError:        "Application error in method handler",
	DataChannelRpcConnectionTimeout:       "Connection timeout",
	DataChannelRpcResponseTimeout:         "Response timeout",
	DataChannelRpcRecipientDisconnected:   "Recipient disconnected",
	DataChannelRpcResponsePayloadTooLarge: "Response payload too large",
	DataChannelRpcSendFailed:              "Failed to send",

	DataChannelRpcUnsupportedMethod:      "Method not supported at destination",
	DataChannelRpcRecipientNotFound:      "Recipient not found",
	DataChannelRpcRequestPayloadTooLarge: "Request payload too large",
	DataChannelRpcUnsupportedServer:      "RPC not supported by server",
	DataChannelRpcUnsupportedVersion:     "Unsupported RPC version",
}

type DataChannelRpcError struct {
	Code    DataChannelRpcErrorCode
	Message string
	Data    string
}

func (e *DataChannelRpcError) Error() string {
	if e.Data != "" {
		return fmt.Sprintf("RpcError %d: %s: %s", e.Code, e.Message, e.Data)
	}
	return fmt.Sprintf("RpcError %d: %s", e.Code, e.Message)
}

func (e *DataChannelRpcError) PsrpcError() psrpc.Error {
	switch e.Code {
	case DataChannelRpcApplicationError:
		return psrpc.NewError(psrpc.Internal, e)
	case DataChannelRpcConnectionTimeout:
		return psrpc.NewError(psrpc.Canceled, e)
	case DataChannelRpcResponseTimeout:
		return psrpc.NewError(psrpc.Canceled, e)
	case DataChannelRpcRecipientDisconnected:
		return psrpc.NewError(psrpc.Unavailable, e)
	case DataChannelRpcResponsePayloadTooLarge:
		return psrpc.NewError(psrpc.MalformedResponse, e)
	case DataChannelRpcSendFailed:
		return psrpc.NewError(psrpc.Internal, e)
	case DataChannelRpcUnsupportedMethod:
		return psrpc.NewError(psrpc.InvalidArgument, e)
	case DataChannelRpcRecipientNotFound:
		return psrpc.NewError(psrpc.NotFound, e)
	case DataChannelRpcRequestPayloadTooLarge:
		return psrpc.NewError(psrpc.MalformedRequest, e)
	case DataChannelRpcUnsupportedServer:
		return psrpc.NewError(psrpc.Unimplemented, e)
	case DataChannelRpcUnsupportedVersion:
		return psrpc.NewError(psrpc.Unimplemented, e)
	default:
		return psrpc.NewError(psrpc.Internal, e)
	}
}

func DataChannelRpcErrorFromBuiltInCodes(code DataChannelRpcErrorCode, data string) *DataChannelRpcError {
	return &DataChannelRpcError{Code: code, Message: dataChannelRpcErrorMessages[code], Data: data}
}

type DataChannelRpcPendingAckHandler struct {
	Resolve             func()
	ParticipantIdentity string
}

type DataChannelRpcPendingResponseHandler struct {
	Resolve             func(payload string, err *DataChannelRpcError)
	ParticipantIdentity string
}