neko/internal/websocket/handler/signal.go

163 lines
3.4 KiB
Go
Raw Permalink Normal View History

2020-11-02 04:09:48 +13:00
package handler
import (
2021-09-02 09:10:18 +12:00
"errors"
"github.com/demodesk/neko/pkg/types"
"github.com/demodesk/neko/pkg/types/event"
"github.com/demodesk/neko/pkg/types/message"
2023-04-17 09:34:02 +12:00
"github.com/pion/webrtc/v3"
)
func (h *MessageHandlerCtx) signalRequest(session types.Session, payload *message.SignalRequest) error {
2021-03-14 12:45:51 +13:00
if !session.Profile().CanWatch {
2021-09-02 09:10:18 +12:00
return errors.New("not allowed to watch")
2020-12-07 06:49:20 +13:00
}
offer, peer, err := h.webrtc.CreatePeer(session)
if err != nil {
return err
}
// set webrtc as paused if session has private mode enabled
if session.PrivateModeEnabled() {
peer.SetPaused(true)
}
video := payload.Video
// use default first video, if not provided
if video.Selector == nil {
videos := h.capture.Video().IDs()
video.Selector = &types.StreamSelector{
ID: videos[0],
Type: types.StreamSelectorTypeExact,
}
}
// TODO: Remove, used for compatibility with old clients.
if video.Auto == nil {
video.Auto = &payload.Auto
}
// set video stream
err = peer.SetVideo(video)
if err != nil {
return err
}
audio := payload.Audio
// enable by default if not requested otherwise
if audio.Disabled == nil {
disabled := false
audio.Disabled = &disabled
}
// set audio stream
err = peer.SetAudio(audio)
if err != nil {
return err
2022-03-27 11:20:38 +13:00
}
2021-09-02 07:58:39 +12:00
session.Send(
event.SIGNAL_PROVIDE,
2020-11-19 08:30:33 +13:00
message.SignalProvide{
2021-03-18 03:47:49 +13:00
SDP: offer.SDP,
ICEServers: h.webrtc.ICEServers(),
Video: peer.Video(),
Audio: peer.Audio(),
2020-11-19 08:30:33 +13:00
})
2021-09-02 07:58:39 +12:00
return nil
}
2021-06-28 08:02:05 +12:00
func (h *MessageHandlerCtx) signalRestart(session types.Session) error {
peer := session.GetWebRTCPeer()
if peer == nil {
2021-09-02 09:10:18 +12:00
return errors.New("webRTC peer does not exist")
2021-06-28 08:02:05 +12:00
}
offer, err := peer.CreateOffer(true)
2021-06-28 08:02:05 +12:00
if err != nil {
return err
}
// TODO: Use offer event instead.
2021-09-02 07:58:39 +12:00
session.Send(
event.SIGNAL_RESTART,
2021-11-25 12:07:17 +13:00
message.SignalDescription{
2021-09-02 07:58:39 +12:00
SDP: offer.SDP,
2021-06-28 08:02:05 +12:00
})
2021-09-02 07:58:39 +12:00
return nil
2021-06-28 08:02:05 +12:00
}
2021-11-25 12:07:17 +13:00
func (h *MessageHandlerCtx) signalOffer(session types.Session, payload *message.SignalDescription) error {
peer := session.GetWebRTCPeer()
if peer == nil {
return errors.New("webRTC peer does not exist")
}
2023-04-17 09:34:02 +12:00
err := peer.SetRemoteDescription(webrtc.SessionDescription{
SDP: payload.SDP,
Type: webrtc.SDPTypeOffer,
})
2021-11-29 06:36:47 +13:00
if err != nil {
return err
}
answer, err := peer.CreateAnswer()
if err != nil {
return err
}
session.Send(
event.SIGNAL_ANSWER,
message.SignalDescription{
SDP: answer.SDP,
})
return nil
2021-11-25 12:07:17 +13:00
}
func (h *MessageHandlerCtx) signalAnswer(session types.Session, payload *message.SignalDescription) error {
2021-02-06 06:14:45 +13:00
peer := session.GetWebRTCPeer()
if peer == nil {
2021-09-02 09:10:18 +12:00
return errors.New("webRTC peer does not exist")
2021-02-06 06:14:45 +13:00
}
2023-04-17 09:34:02 +12:00
return peer.SetRemoteDescription(webrtc.SessionDescription{
SDP: payload.SDP,
Type: webrtc.SDPTypeAnswer,
})
}
2021-02-03 08:43:33 +13:00
func (h *MessageHandlerCtx) signalCandidate(session types.Session, payload *message.SignalCandidate) error {
2021-02-06 06:14:45 +13:00
peer := session.GetWebRTCPeer()
if peer == nil {
2021-09-02 09:10:18 +12:00
return errors.New("webRTC peer does not exist")
2021-02-06 06:14:45 +13:00
}
2021-11-29 06:36:47 +13:00
return peer.SetCandidate(payload.ICECandidateInit)
2021-02-03 08:43:33 +13:00
}
2021-02-06 08:35:30 +13:00
func (h *MessageHandlerCtx) signalVideo(session types.Session, payload *message.SignalVideo) error {
peer := session.GetWebRTCPeer()
if peer == nil {
2021-09-02 09:10:18 +12:00
return errors.New("webRTC peer does not exist")
2021-02-06 08:35:30 +13:00
}
return peer.SetVideo(payload.PeerVideoRequest)
}
func (h *MessageHandlerCtx) signalAudio(session types.Session, payload *message.SignalAudio) error {
peer := session.GetWebRTCPeer()
if peer == nil {
return errors.New("webRTC peer does not exist")
2021-02-08 05:29:40 +13:00
}
return peer.SetAudio(payload.PeerAudioRequest)
2021-02-06 08:35:30 +13:00
}