758 lines
21 KiB
Go
758 lines
21 KiB
Go
package obsws
|
|
|
|
import (
|
|
"errors"
|
|
"time"
|
|
)
|
|
|
|
// This file is automatically generated.
|
|
// https://github.com/christopher-dG/go-obs-websocket/blob/master/codegen/protocol.py
|
|
|
|
// GetStreamingStatusRequest : Get current streaming and recording status.
|
|
//
|
|
// Since obs-websocket version: 0.3.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#getstreamingstatus
|
|
type GetStreamingStatusRequest struct {
|
|
_request `json:",squash"`
|
|
response chan GetStreamingStatusResponse
|
|
}
|
|
|
|
// NewGetStreamingStatusRequest returns a new GetStreamingStatusRequest.
|
|
func NewGetStreamingStatusRequest() GetStreamingStatusRequest {
|
|
return GetStreamingStatusRequest{
|
|
_request{
|
|
ID_: getMessageID(),
|
|
Type_: "GetStreamingStatus",
|
|
err: make(chan error, 1),
|
|
},
|
|
make(chan GetStreamingStatusResponse, 1),
|
|
}
|
|
}
|
|
|
|
// Send sends the request.
|
|
func (r *GetStreamingStatusRequest) Send(c *Client) error {
|
|
if r.sent {
|
|
return ErrAlreadySent
|
|
}
|
|
future, err := c.sendRequest(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
r.sent = true
|
|
go func() {
|
|
m := <-future
|
|
var resp GetStreamingStatusResponse
|
|
if err = mapToStruct(m, &resp); err != nil {
|
|
r.err <- err
|
|
} else if resp.Status() != StatusOK {
|
|
r.err <- errors.New(resp.Error())
|
|
} else {
|
|
r.response <- resp
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
// Receive waits for the response.
|
|
func (r GetStreamingStatusRequest) Receive() (GetStreamingStatusResponse, error) {
|
|
if !r.sent {
|
|
return GetStreamingStatusResponse{}, ErrNotSent
|
|
}
|
|
if receiveTimeout == 0 {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return GetStreamingStatusResponse{}, err
|
|
}
|
|
} else {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return GetStreamingStatusResponse{}, err
|
|
case <-time.After(receiveTimeout):
|
|
return GetStreamingStatusResponse{}, ErrReceiveTimeout
|
|
}
|
|
}
|
|
}
|
|
|
|
// SendReceive sends the request then immediately waits for the response.
|
|
func (r GetStreamingStatusRequest) SendReceive(c *Client) (GetStreamingStatusResponse, error) {
|
|
if err := r.Send(c); err != nil {
|
|
return GetStreamingStatusResponse{}, err
|
|
}
|
|
return r.Receive()
|
|
}
|
|
|
|
// GetStreamingStatusResponse : Response for GetStreamingStatusRequest.
|
|
//
|
|
// Since obs-websocket version: 0.3.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#getstreamingstatus
|
|
type GetStreamingStatusResponse struct {
|
|
// Current streaming status.
|
|
// Required: Yes.
|
|
Streaming bool `json:"streaming"`
|
|
// Current recording status.
|
|
// Required: Yes.
|
|
Recording bool `json:"recording"`
|
|
// Time elapsed since streaming started (only present if currently streaming).
|
|
// Required: No.
|
|
StreamTimecode string `json:"stream-timecode"`
|
|
// Time elapsed since recording started (only present if currently recording).
|
|
// Required: No.
|
|
RecTimecode string `json:"rec-timecode"`
|
|
// Always false.
|
|
// Retrocompatibility with OBSRemote.
|
|
// Required: Yes.
|
|
PreviewOnly bool `json:"preview-only"`
|
|
_response `json:",squash"`
|
|
}
|
|
|
|
// StartStopStreamingRequest : Toggle streaming on or off.
|
|
//
|
|
// Since obs-websocket version: 0.3.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#startstopstreaming
|
|
type StartStopStreamingRequest struct {
|
|
_request `json:",squash"`
|
|
response chan StartStopStreamingResponse
|
|
}
|
|
|
|
// NewStartStopStreamingRequest returns a new StartStopStreamingRequest.
|
|
func NewStartStopStreamingRequest() StartStopStreamingRequest {
|
|
return StartStopStreamingRequest{
|
|
_request{
|
|
ID_: getMessageID(),
|
|
Type_: "StartStopStreaming",
|
|
err: make(chan error, 1),
|
|
},
|
|
make(chan StartStopStreamingResponse, 1),
|
|
}
|
|
}
|
|
|
|
// Send sends the request.
|
|
func (r *StartStopStreamingRequest) Send(c *Client) error {
|
|
if r.sent {
|
|
return ErrAlreadySent
|
|
}
|
|
future, err := c.sendRequest(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
r.sent = true
|
|
go func() {
|
|
m := <-future
|
|
var resp StartStopStreamingResponse
|
|
if err = mapToStruct(m, &resp); err != nil {
|
|
r.err <- err
|
|
} else if resp.Status() != StatusOK {
|
|
r.err <- errors.New(resp.Error())
|
|
} else {
|
|
r.response <- resp
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
// Receive waits for the response.
|
|
func (r StartStopStreamingRequest) Receive() (StartStopStreamingResponse, error) {
|
|
if !r.sent {
|
|
return StartStopStreamingResponse{}, ErrNotSent
|
|
}
|
|
if receiveTimeout == 0 {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return StartStopStreamingResponse{}, err
|
|
}
|
|
} else {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return StartStopStreamingResponse{}, err
|
|
case <-time.After(receiveTimeout):
|
|
return StartStopStreamingResponse{}, ErrReceiveTimeout
|
|
}
|
|
}
|
|
}
|
|
|
|
// SendReceive sends the request then immediately waits for the response.
|
|
func (r StartStopStreamingRequest) SendReceive(c *Client) (StartStopStreamingResponse, error) {
|
|
if err := r.Send(c); err != nil {
|
|
return StartStopStreamingResponse{}, err
|
|
}
|
|
return r.Receive()
|
|
}
|
|
|
|
// StartStopStreamingResponse : Response for StartStopStreamingRequest.
|
|
//
|
|
// Since obs-websocket version: 0.3.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#startstopstreaming
|
|
type StartStopStreamingResponse struct {
|
|
_response `json:",squash"`
|
|
}
|
|
|
|
// StartStreamingRequest : Start streaming.
|
|
// Will return an `error` if streaming is already active.
|
|
//
|
|
// Since obs-websocket version: 4.1.0.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#startstreaming
|
|
type StartStreamingRequest struct {
|
|
// Special stream configuration.
|
|
// Please note: these won't be saved to OBS' configuration.
|
|
// Required: No.
|
|
Stream map[string]interface{} `json:"stream"`
|
|
// If specified ensures the type of stream matches the given type (usually 'rtmp_custom' or 'rtmp_common').
|
|
// If the currently configured stream type does not match the given stream type, all settings must be specified in the `settings` object or an error will occur when starting the stream.
|
|
// Required: No.
|
|
StreamType string `json:"stream.type"`
|
|
// Adds the given object parameters as encoded query string parameters to the 'key' of the RTMP stream.
|
|
// Used to pass data to the RTMP service about the streaming.
|
|
// May be any String, Numeric, or Boolean field.
|
|
// Required: No.
|
|
StreamMetadata map[string]interface{} `json:"stream.metadata"`
|
|
// Settings for the stream.
|
|
// Required: No.
|
|
StreamSettings map[string]interface{} `json:"stream.settings"`
|
|
// The publish URL.
|
|
// Required: No.
|
|
StreamSettingsServer string `json:"stream.settings.server"`
|
|
// The publish key of the stream.
|
|
// Required: No.
|
|
StreamSettingsKey string `json:"stream.settings.key"`
|
|
// Indicates whether authentication should be used when connecting to the streaming server.
|
|
// Required: No.
|
|
StreamSettingsUseAuth bool `json:"stream.settings.use-auth"`
|
|
// If authentication is enabled, the username for the streaming server.
|
|
// Ignored if `use-auth` is not set to `true`.
|
|
// Required: No.
|
|
StreamSettingsUsername string `json:"stream.settings.username"`
|
|
// If authentication is enabled, the password for the streaming server.
|
|
// Ignored if `use-auth` is not set to `true`.
|
|
// Required: No.
|
|
StreamSettingsPassword string `json:"stream.settings.password"`
|
|
_request `json:",squash"`
|
|
response chan StartStreamingResponse
|
|
}
|
|
|
|
// NewStartStreamingRequest returns a new StartStreamingRequest.
|
|
func NewStartStreamingRequest(
|
|
stream map[string]interface{},
|
|
streamType string,
|
|
streamMetadata map[string]interface{},
|
|
streamSettings map[string]interface{},
|
|
streamSettingsServer string,
|
|
streamSettingsKey string,
|
|
streamSettingsUseAuth bool,
|
|
streamSettingsUsername string,
|
|
streamSettingsPassword string,
|
|
) StartStreamingRequest {
|
|
return StartStreamingRequest{
|
|
stream,
|
|
streamType,
|
|
streamMetadata,
|
|
streamSettings,
|
|
streamSettingsServer,
|
|
streamSettingsKey,
|
|
streamSettingsUseAuth,
|
|
streamSettingsUsername,
|
|
streamSettingsPassword,
|
|
_request{
|
|
ID_: getMessageID(),
|
|
Type_: "StartStreaming",
|
|
err: make(chan error, 1),
|
|
},
|
|
make(chan StartStreamingResponse, 1),
|
|
}
|
|
}
|
|
|
|
// Send sends the request.
|
|
func (r *StartStreamingRequest) Send(c *Client) error {
|
|
if r.sent {
|
|
return ErrAlreadySent
|
|
}
|
|
future, err := c.sendRequest(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
r.sent = true
|
|
go func() {
|
|
m := <-future
|
|
var resp StartStreamingResponse
|
|
if err = mapToStruct(m, &resp); err != nil {
|
|
r.err <- err
|
|
} else if resp.Status() != StatusOK {
|
|
r.err <- errors.New(resp.Error())
|
|
} else {
|
|
r.response <- resp
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
// Receive waits for the response.
|
|
func (r StartStreamingRequest) Receive() (StartStreamingResponse, error) {
|
|
if !r.sent {
|
|
return StartStreamingResponse{}, ErrNotSent
|
|
}
|
|
if receiveTimeout == 0 {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return StartStreamingResponse{}, err
|
|
}
|
|
} else {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return StartStreamingResponse{}, err
|
|
case <-time.After(receiveTimeout):
|
|
return StartStreamingResponse{}, ErrReceiveTimeout
|
|
}
|
|
}
|
|
}
|
|
|
|
// SendReceive sends the request then immediately waits for the response.
|
|
func (r StartStreamingRequest) SendReceive(c *Client) (StartStreamingResponse, error) {
|
|
if err := r.Send(c); err != nil {
|
|
return StartStreamingResponse{}, err
|
|
}
|
|
return r.Receive()
|
|
}
|
|
|
|
// StartStreamingResponse : Response for StartStreamingRequest.
|
|
//
|
|
// Since obs-websocket version: 4.1.0.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#startstreaming
|
|
type StartStreamingResponse struct {
|
|
_response `json:",squash"`
|
|
}
|
|
|
|
// StopStreamingRequest : Stop streaming.
|
|
// Will return an `error` if streaming is not active.
|
|
//
|
|
// Since obs-websocket version: 4.1.0.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#stopstreaming
|
|
type StopStreamingRequest struct {
|
|
_request `json:",squash"`
|
|
response chan StopStreamingResponse
|
|
}
|
|
|
|
// NewStopStreamingRequest returns a new StopStreamingRequest.
|
|
func NewStopStreamingRequest() StopStreamingRequest {
|
|
return StopStreamingRequest{
|
|
_request{
|
|
ID_: getMessageID(),
|
|
Type_: "StopStreaming",
|
|
err: make(chan error, 1),
|
|
},
|
|
make(chan StopStreamingResponse, 1),
|
|
}
|
|
}
|
|
|
|
// Send sends the request.
|
|
func (r *StopStreamingRequest) Send(c *Client) error {
|
|
if r.sent {
|
|
return ErrAlreadySent
|
|
}
|
|
future, err := c.sendRequest(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
r.sent = true
|
|
go func() {
|
|
m := <-future
|
|
var resp StopStreamingResponse
|
|
if err = mapToStruct(m, &resp); err != nil {
|
|
r.err <- err
|
|
} else if resp.Status() != StatusOK {
|
|
r.err <- errors.New(resp.Error())
|
|
} else {
|
|
r.response <- resp
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
// Receive waits for the response.
|
|
func (r StopStreamingRequest) Receive() (StopStreamingResponse, error) {
|
|
if !r.sent {
|
|
return StopStreamingResponse{}, ErrNotSent
|
|
}
|
|
if receiveTimeout == 0 {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return StopStreamingResponse{}, err
|
|
}
|
|
} else {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return StopStreamingResponse{}, err
|
|
case <-time.After(receiveTimeout):
|
|
return StopStreamingResponse{}, ErrReceiveTimeout
|
|
}
|
|
}
|
|
}
|
|
|
|
// SendReceive sends the request then immediately waits for the response.
|
|
func (r StopStreamingRequest) SendReceive(c *Client) (StopStreamingResponse, error) {
|
|
if err := r.Send(c); err != nil {
|
|
return StopStreamingResponse{}, err
|
|
}
|
|
return r.Receive()
|
|
}
|
|
|
|
// StopStreamingResponse : Response for StopStreamingRequest.
|
|
//
|
|
// Since obs-websocket version: 4.1.0.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#stopstreaming
|
|
type StopStreamingResponse struct {
|
|
_response `json:",squash"`
|
|
}
|
|
|
|
// SetStreamSettingsRequest : Sets one or more attributes of the current streaming server settings
|
|
// Any options not passed will remain unchanged
|
|
// Returns the updated settings in response
|
|
// If 'type' is different than the current streaming service type, all settings are required
|
|
// Returns the full settings of the stream (the same as GetStreamSettings).
|
|
//
|
|
// Since obs-websocket version: 4.1.0.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#setstreamsettings
|
|
type SetStreamSettingsRequest struct {
|
|
// The type of streaming service configuration, usually `rtmp_custom` or `rtmp_common`.
|
|
// Required: Yes.
|
|
StreamType string `json:"type"`
|
|
// The actual settings of the stream.
|
|
// Required: Yes.
|
|
Settings map[string]interface{} `json:"settings"`
|
|
// The publish URL.
|
|
// Required: No.
|
|
SettingsServer string `json:"settings.server"`
|
|
// The publish key.
|
|
// Required: No.
|
|
SettingsKey string `json:"settings.key"`
|
|
// Indicates whether authentication should be used when connecting to the streaming server.
|
|
// Required: No.
|
|
SettingsUseAuth bool `json:"settings.use-auth"`
|
|
// The username for the streaming service.
|
|
// Required: No.
|
|
SettingsUsername string `json:"settings.username"`
|
|
// The password for the streaming service.
|
|
// Required: No.
|
|
SettingsPassword string `json:"settings.password"`
|
|
// Persist the settings to disk.
|
|
// Required: Yes.
|
|
Save bool `json:"save"`
|
|
_request `json:",squash"`
|
|
response chan SetStreamSettingsResponse
|
|
}
|
|
|
|
// NewSetStreamSettingsRequest returns a new SetStreamSettingsRequest.
|
|
func NewSetStreamSettingsRequest(
|
|
_type string,
|
|
settings map[string]interface{},
|
|
settingsServer string,
|
|
settingsKey string,
|
|
settingsUseAuth bool,
|
|
settingsUsername string,
|
|
settingsPassword string,
|
|
save bool,
|
|
) SetStreamSettingsRequest {
|
|
return SetStreamSettingsRequest{
|
|
_type,
|
|
settings,
|
|
settingsServer,
|
|
settingsKey,
|
|
settingsUseAuth,
|
|
settingsUsername,
|
|
settingsPassword,
|
|
save,
|
|
_request{
|
|
ID_: getMessageID(),
|
|
Type_: "SetStreamSettings",
|
|
err: make(chan error, 1),
|
|
},
|
|
make(chan SetStreamSettingsResponse, 1),
|
|
}
|
|
}
|
|
|
|
// Send sends the request.
|
|
func (r *SetStreamSettingsRequest) Send(c *Client) error {
|
|
if r.sent {
|
|
return ErrAlreadySent
|
|
}
|
|
future, err := c.sendRequest(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
r.sent = true
|
|
go func() {
|
|
m := <-future
|
|
var resp SetStreamSettingsResponse
|
|
if err = mapToStruct(m, &resp); err != nil {
|
|
r.err <- err
|
|
} else if resp.Status() != StatusOK {
|
|
r.err <- errors.New(resp.Error())
|
|
} else {
|
|
r.response <- resp
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
// Receive waits for the response.
|
|
func (r SetStreamSettingsRequest) Receive() (SetStreamSettingsResponse, error) {
|
|
if !r.sent {
|
|
return SetStreamSettingsResponse{}, ErrNotSent
|
|
}
|
|
if receiveTimeout == 0 {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return SetStreamSettingsResponse{}, err
|
|
}
|
|
} else {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return SetStreamSettingsResponse{}, err
|
|
case <-time.After(receiveTimeout):
|
|
return SetStreamSettingsResponse{}, ErrReceiveTimeout
|
|
}
|
|
}
|
|
}
|
|
|
|
// SendReceive sends the request then immediately waits for the response.
|
|
func (r SetStreamSettingsRequest) SendReceive(c *Client) (SetStreamSettingsResponse, error) {
|
|
if err := r.Send(c); err != nil {
|
|
return SetStreamSettingsResponse{}, err
|
|
}
|
|
return r.Receive()
|
|
}
|
|
|
|
// SetStreamSettingsResponse : Response for SetStreamSettingsRequest.
|
|
//
|
|
// Since obs-websocket version: 4.1.0.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#setstreamsettings
|
|
type SetStreamSettingsResponse struct {
|
|
_response `json:",squash"`
|
|
}
|
|
|
|
// GetStreamSettingsRequest : Get the current streaming server settings.
|
|
//
|
|
// Since obs-websocket version: 4.1.0.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#getstreamsettings
|
|
type GetStreamSettingsRequest struct {
|
|
_request `json:",squash"`
|
|
response chan GetStreamSettingsResponse
|
|
}
|
|
|
|
// NewGetStreamSettingsRequest returns a new GetStreamSettingsRequest.
|
|
func NewGetStreamSettingsRequest() GetStreamSettingsRequest {
|
|
return GetStreamSettingsRequest{
|
|
_request{
|
|
ID_: getMessageID(),
|
|
Type_: "GetStreamSettings",
|
|
err: make(chan error, 1),
|
|
},
|
|
make(chan GetStreamSettingsResponse, 1),
|
|
}
|
|
}
|
|
|
|
// Send sends the request.
|
|
func (r *GetStreamSettingsRequest) Send(c *Client) error {
|
|
if r.sent {
|
|
return ErrAlreadySent
|
|
}
|
|
future, err := c.sendRequest(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
r.sent = true
|
|
go func() {
|
|
m := <-future
|
|
var resp GetStreamSettingsResponse
|
|
if err = mapToStruct(m, &resp); err != nil {
|
|
r.err <- err
|
|
} else if resp.Status() != StatusOK {
|
|
r.err <- errors.New(resp.Error())
|
|
} else {
|
|
r.response <- resp
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
// Receive waits for the response.
|
|
func (r GetStreamSettingsRequest) Receive() (GetStreamSettingsResponse, error) {
|
|
if !r.sent {
|
|
return GetStreamSettingsResponse{}, ErrNotSent
|
|
}
|
|
if receiveTimeout == 0 {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return GetStreamSettingsResponse{}, err
|
|
}
|
|
} else {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return GetStreamSettingsResponse{}, err
|
|
case <-time.After(receiveTimeout):
|
|
return GetStreamSettingsResponse{}, ErrReceiveTimeout
|
|
}
|
|
}
|
|
}
|
|
|
|
// SendReceive sends the request then immediately waits for the response.
|
|
func (r GetStreamSettingsRequest) SendReceive(c *Client) (GetStreamSettingsResponse, error) {
|
|
if err := r.Send(c); err != nil {
|
|
return GetStreamSettingsResponse{}, err
|
|
}
|
|
return r.Receive()
|
|
}
|
|
|
|
// GetStreamSettingsResponse : Response for GetStreamSettingsRequest.
|
|
//
|
|
// Since obs-websocket version: 4.1.0.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#getstreamsettings
|
|
type GetStreamSettingsResponse struct {
|
|
// The type of streaming service configuration.
|
|
// Possible values: 'rtmp_custom' or 'rtmp_common'.
|
|
// Required: Yes.
|
|
Type string `json:"type"`
|
|
// Stream settings object.
|
|
// Required: Yes.
|
|
Settings map[string]interface{} `json:"settings"`
|
|
// The publish URL.
|
|
// Required: Yes.
|
|
SettingsServer string `json:"settings.server"`
|
|
// The publish key of the stream.
|
|
// Required: Yes.
|
|
SettingsKey string `json:"settings.key"`
|
|
// Indicates whether authentication should be used when connecting to the streaming server.
|
|
// Required: Yes.
|
|
SettingsUseAuth bool `json:"settings.use-auth"`
|
|
// The username to use when accessing the streaming server.
|
|
// Only present if `use-auth` is `true`.
|
|
// Required: Yes.
|
|
SettingsUsername string `json:"settings.username"`
|
|
// The password to use when accessing the streaming server.
|
|
// Only present if `use-auth` is `true`.
|
|
// Required: Yes.
|
|
SettingsPassword string `json:"settings.password"`
|
|
_response `json:",squash"`
|
|
}
|
|
|
|
// SaveStreamSettingsRequest : Save the current streaming server settings to disk.
|
|
//
|
|
// Since obs-websocket version: 4.1.0.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#savestreamsettings
|
|
type SaveStreamSettingsRequest struct {
|
|
_request `json:",squash"`
|
|
response chan SaveStreamSettingsResponse
|
|
}
|
|
|
|
// NewSaveStreamSettingsRequest returns a new SaveStreamSettingsRequest.
|
|
func NewSaveStreamSettingsRequest() SaveStreamSettingsRequest {
|
|
return SaveStreamSettingsRequest{
|
|
_request{
|
|
ID_: getMessageID(),
|
|
Type_: "SaveStreamSettings",
|
|
err: make(chan error, 1),
|
|
},
|
|
make(chan SaveStreamSettingsResponse, 1),
|
|
}
|
|
}
|
|
|
|
// Send sends the request.
|
|
func (r *SaveStreamSettingsRequest) Send(c *Client) error {
|
|
if r.sent {
|
|
return ErrAlreadySent
|
|
}
|
|
future, err := c.sendRequest(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
r.sent = true
|
|
go func() {
|
|
m := <-future
|
|
var resp SaveStreamSettingsResponse
|
|
if err = mapToStruct(m, &resp); err != nil {
|
|
r.err <- err
|
|
} else if resp.Status() != StatusOK {
|
|
r.err <- errors.New(resp.Error())
|
|
} else {
|
|
r.response <- resp
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
// Receive waits for the response.
|
|
func (r SaveStreamSettingsRequest) Receive() (SaveStreamSettingsResponse, error) {
|
|
if !r.sent {
|
|
return SaveStreamSettingsResponse{}, ErrNotSent
|
|
}
|
|
if receiveTimeout == 0 {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return SaveStreamSettingsResponse{}, err
|
|
}
|
|
} else {
|
|
select {
|
|
case resp := <-r.response:
|
|
return resp, nil
|
|
case err := <-r.err:
|
|
return SaveStreamSettingsResponse{}, err
|
|
case <-time.After(receiveTimeout):
|
|
return SaveStreamSettingsResponse{}, ErrReceiveTimeout
|
|
}
|
|
}
|
|
}
|
|
|
|
// SendReceive sends the request then immediately waits for the response.
|
|
func (r SaveStreamSettingsRequest) SendReceive(c *Client) (SaveStreamSettingsResponse, error) {
|
|
if err := r.Send(c); err != nil {
|
|
return SaveStreamSettingsResponse{}, err
|
|
}
|
|
return r.Receive()
|
|
}
|
|
|
|
// SaveStreamSettingsResponse : Response for SaveStreamSettingsRequest.
|
|
//
|
|
// Since obs-websocket version: 4.1.0.
|
|
//
|
|
// https://github.com/Palakis/obs-websocket/blob/4.3-maintenance/docs/generated/protocol.md#savestreamsettings
|
|
type SaveStreamSettingsResponse struct {
|
|
_response `json:",squash"`
|
|
}
|