janus

README

janus-go

only support websocket transport

Update 1/14/2020

Notedit, the original creator is busy with other things, and has handed over the maintainer role on this project.

You can find a fork by @nustiueudinastea Here: https://github.com/nustiueudinastea/janus-go

Please see if it suits your needs, and feel free to file PRs, issues and suggestions there.

Thanks, Cameron and Alex

Documentation

Overview

Package janus is a Golang implementation of the Janus API, used to interact with the Janus WebRTC Gateway.

Index

• type AckMsg
• type BaseMsg
• type DetachedMsg
• type ErrorData
• type ErrorMsg
  • func (err *ErrorMsg) Error() string
• type EventMsg
• type Gateway
  • func Connect(wsURL string) (*Gateway, error)
  • func (gateway *Gateway) Close() error
  • func (gateway *Gateway) Create() (*Session, error)
  • func (gateway *Gateway) GetErrChan() chan error
  • func (gateway *Gateway) Info() (*InfoMsg, error)
• type Handle
  • func (handle *Handle) Detach() (*AckMsg, error)
  • func (handle *Handle) Message(body, jsep interface{}) (*EventMsg, error)
  • func (handle *Handle) Request(body interface{}) (*SuccessMsg, error)
  • func (handle *Handle) Trickle(candidate interface{}) (*AckMsg, error)
  • func (handle *Handle) TrickleMany(candidates interface{}) (*AckMsg, error)
• type HangupMsg
• type InfoMsg
• type MediaMsg
• type PluginData
• type PluginInfo
• type Session
  • func (session *Session) Attach(plugin string) (*Handle, error)
  • func (session *Session) Destroy() (*AckMsg, error)
  • func (session *Session) KeepAlive() (*AckMsg, error)
• type SlowLinkMsg
• type SuccessData
• type SuccessMsg
• type TimeoutMsg
• type WebRTCUpMsg

Types

type AckMsg

type AckMsg struct{}

type BaseMsg

type BaseMsg struct {
	Type    string `json:"janus"`
	ID      string `json:"transaction"`
	Session uint64 `json:"session_id"`
	Handle  uint64 `json:"sender"`
}

type DetachedMsg

type DetachedMsg struct{}

type ErrorData

type ErrorData struct {
	Code   int
	Reason string
}

type ErrorMsg

type ErrorMsg struct {
	Err ErrorData `json:"error"`
}

func (*ErrorMsg) Error

func (err *ErrorMsg) Error() string

type EventMsg

type EventMsg struct {
	Plugindata PluginData
	Jsep       map[string]interface{}
	Session    uint64 `json:"session_id"`
	Handle     uint64 `json:"sender"`
}

type Gateway

type Gateway struct {
	// Sessions is a map of the currently active sessions to the gateway.
	Sessions map[uint64]*Session

	// Access to the Sessions map should be synchronized with the Gateway.Lock()
	// and Gateway.Unlock() methods provided by the embeded sync.Mutex.
	sync.Mutex
	// contains filtered or unexported fields
}

Gateway represents a connection to an instance of the Janus Gateway.

func Connect

func Connect(wsURL string) (*Gateway, error)

Connect initiates a webscoket connection with the Janus Gateway

func (*Gateway) Close

func (gateway *Gateway) Close() error

Close closes the underlying connection to the Gateway.

func (*Gateway) Create

func (gateway *Gateway) Create() (*Session, error)

Create sends a create request to the Gateway. On success, a new Session will be returned and error will be nil.

func (*Gateway) GetErrChan

func (gateway *Gateway) GetErrChan() chan error

GetErrChan returns a channels through which the caller can check and react to connectivity errors

func (*Gateway) Info

func (gateway *Gateway) Info() (*InfoMsg, error)

Info sends an info request to the Gateway. On success, an InfoMsg will be returned and error will be nil.

type Handle

type Handle struct {
	// ID is the handle_id of this plugin handle
	ID uint64

	// Type   // pub  or sub
	Type string

	//User   // Userid
	User string

	// Events is a receive only channel that can be used to receive events
	// related to this handle from the gateway.
	Events chan interface{}
	// contains filtered or unexported fields
}

Handle represents a handle to a plugin instance on the Gateway.

func (*Handle) Detach

func (handle *Handle) Detach() (*AckMsg, error)

Detach sends a detach request to the Gateway to remove this handle. On success, an AckMsg will be returned and error will be nil.

func (*Handle) Message

func (handle *Handle) Message(body, jsep interface{}) (*EventMsg, error)

Message sends a message request to a plugin handle on the Gateway. body should be the plugin data to be passed to the plugin, and jsep should contain an optional SDP offer/answer to establish a WebRTC PeerConnection. On success, an EventMsg will be returned and error will be nil.

func (*Handle) Request

func (handle *Handle) Request(body interface{}) (*SuccessMsg, error)

Request sends a sync request

func (*Handle) Trickle

func (handle *Handle) Trickle(candidate interface{}) (*AckMsg, error)

Trickle sends a trickle request to the Gateway as part of establishing a new PeerConnection with a plugin. candidate should be a single ICE candidate, or a completed object to signify that all candidates have been sent:

{
	"completed": true
}

On success, an AckMsg will be returned and error will be nil.

func (*Handle) TrickleMany

func (handle *Handle) TrickleMany(candidates interface{}) (*AckMsg, error)

TrickleMany sends a trickle request to the Gateway as part of establishing a new PeerConnection with a plugin. candidates should be an array of ICE candidates. On success, an AckMsg will be returned and error will be nil.

type HangupMsg

type HangupMsg struct {
	Reason  string
	Session uint64 `json:"session_id"`
	Handle  uint64 `json:"sender"`
}

type InfoMsg

type InfoMsg struct {
	Name          string
	Version       int
	VersionString string `json:"version_string"`
	Author        string
	DataChannels  bool   `json:"data_channels"`
	IPv6          bool   `json:"ipv6"`
	LocalIP       string `json:"local-ip"`
	IceTCP        bool   `json:"ice-tcp"`
	Transports    map[string]PluginInfo
	Plugins       map[string]PluginInfo
}

type MediaMsg

type MediaMsg struct {
	Type      string
	Receiving bool
}

type PluginData

type PluginData struct {
	Plugin string
	Data   map[string]interface{}
}

type PluginInfo

type PluginInfo struct {
	Name          string
	Author        string
	Description   string
	Version       int
	VersionString string `json:"version_string"`
}

type Session

type Session struct {
	// ID is the session_id of this session
	ID uint64

	// Handles is a map of plugin handles within this session
	Handles map[uint64]*Handle

	Events chan interface{}

	// Access to the Handles map should be synchronized with the Session.Lock()
	// and Session.Unlock() methods provided by the embeded sync.Mutex.
	sync.Mutex
	// contains filtered or unexported fields
}

Session represents a session instance on the Janus Gateway.

func (*Session) Attach

func (session *Session) Attach(plugin string) (*Handle, error)

Attach sends an attach request to the Gateway within this session. plugin should be the unique string of the plugin to attach to. On success, a new Handle will be returned and error will be nil.

func (*Session) Destroy

func (session *Session) Destroy() (*AckMsg, error)

Destroy sends a destroy request to the Gateway to tear down this session. On success, the Session will be removed from the Gateway.Sessions map, an AckMsg will be returned and error will be nil.

func (*Session) KeepAlive

func (session *Session) KeepAlive() (*AckMsg, error)

KeepAlive sends a keep-alive request to the Gateway. On success, an AckMsg will be returned and error will be nil.

type SlowLinkMsg

type SlowLinkMsg struct {
	Uplink bool
	Lost   int64
}

type SuccessData

type SuccessData struct {
	ID uint64
}

type SuccessMsg

type SuccessMsg struct {
	Data       SuccessData
	PluginData PluginData
	Session    uint64 `json:"session_id"`
	Handle     uint64 `json:"sender"`
}

type TimeoutMsg

type TimeoutMsg struct {
	Session uint64 `json:"session_id"`
}

type WebRTCUpMsg

type WebRTCUpMsg struct {
	Session uint64 `json:"session_id"`
	Handle  uint64 `json:"sender"`
}