Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

4.0 KB
Raw Blame
package nativehost

import (
	"errors"

	"github.com/TNTcraftHIM/Piik/internal/app/mediaedge"
	"github.com/TNTcraftHIM/Piik/internal/app/remoteinput"
	"github.com/pion/webrtc/v4"
)

type publicationKey struct {
	generation, connectionID string
}

func (session *Session) PreparePublication(generation, connectionID string, servers []webrtc.ICEServer) (webrtc.SessionDescription, mediaedge.PublicationMedia, error) {
	session.mu.Lock()
	key := publicationKey{generation: generation, connectionID: connectionID}
	if session.closed || len(session.publications) >= 2 || session.publications[key] != nil || session.source == nil {
		session.mu.Unlock()
		return webrtc.SessionDescription{}, mediaedge.PublicationMedia{}, errors.New("native publication is unavailable")
	}
	source, audio := session.source, session.audioSource
	session.mu.Unlock()
	var publication *mediaedge.Publication
	current := func() bool {
		session.mu.Lock()
		defer session.mu.Unlock()
		return !session.closed && publication != nil && session.publications[key] == publication
	}
	created, err := session.engine.NewPublication(source, mediaedge.EdgeOptions{
		ConnectionID: connectionID, ICEServers: servers, Audio: audio,
		Events: mediaedge.EdgeEvents{
			LocalCandidate: func(candidate *webrtc.ICECandidateInit) {
				session.emit(Event{Type: "publication-candidate", ShareID: session.shareID,
					Current:               current,
					PublicationGeneration: generation, ConnectionID: connectionID, Candidate: candidate})
			},
			ConnectionState: func(state webrtc.PeerConnectionState, _ *mediaedge.SelectedPair, isCurrentState func(webrtc.PeerConnectionState) bool) {
				session.emit(Event{Type: "publication-state", ShareID: session.shareID,
					Current:               func() bool { return current() && isCurrentState(state) },
					PublicationGeneration: generation, ConnectionID: connectionID, State: state.String()})
			},
		},
	})
	if err != nil {
		return webrtc.SessionDescription{}, mediaedge.PublicationMedia{}, err
	}
	session.mu.Lock()
	if session.closed || len(session.publications) >= 2 || session.publications[key] != nil {
		session.mu.Unlock()
		_ = created.Close()
		return webrtc.SessionDescription{}, mediaedge.PublicationMedia{}, errors.New("native publication changed")
	}
	if session.publications == nil {
		session.publications = make(map[publicationKey]*mediaedge.Publication)
	}
	publication = created
	session.publications[key] = publication
	session.mu.Unlock()
	if session.remoteInput != nil {
		channel, channelErr := publication.OpenDataChannel(remoteinput.ChannelLabel)
		if channelErr == nil {
			publication.OnInputTransportLost(session.remoteInput.Attach(connectionID, channel))
		}
	}
	offer, err := publication.CreateOffer()
	if err != nil {
		session.ClosePublication(generation, connectionID)
		return webrtc.SessionDescription{}, mediaedge.PublicationMedia{}, err
	}
	return offer, publication.Media(), nil
}

func (session *Session) ownsPublication(key publicationKey, publication *mediaedge.Publication) bool {
	session.mu.Lock()
	defer session.mu.Unlock()
	// A current encoder failure still needs its terminal event. Retirement is
	// determined by map ownership, not by the transport's closed state.
	return !session.closed && publication != nil && session.publications[key] == publication
}

func (session *Session) Publication(generation, connectionID string) (*mediaedge.Publication, error) {
	session.mu.Lock()
	defer session.mu.Unlock()
	publication := session.publications[publicationKey{generation: generation, connectionID: connectionID}]
	if session.closed || publication == nil {
		return nil, errors.New("native publication identity changed")
	}
	return publication, nil
}

func (session *Session) ClosePublication(generation, connectionID string) {
	session.mu.Lock()
	key := publicationKey{generation: generation, connectionID: connectionID}
	publication := session.publications[key]
	if publication == nil {
		session.mu.Unlock()
		return
	}
	delete(session.publications, key)
	session.mu.Unlock()
	_ = publication.Close()
}