Mirrored_Repos/obs-websocket
1
0
Fork 0
mirror of https://github.com/Palakis/obs-websocket.git synced 2024-08-30 18:12:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #266 from Palakis/response-return

Browse Source 
Return response in request handlers
This commit is contained in:
Stéphane Lepin 2019-01-01 18:23:22 +01:00 committed by GitHub
commit 38ad465233
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 476 additions and 626 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
src/WSRequestHandler.cpp
View File

@ -24,7 +24,7 @@
#include "WSRequestHandler.h"
QHash<QString, void(*)(WSRequestHandler*)> WSRequestHandler::messageMap {
QHash<QString, HandlerResponse(*)(WSRequestHandler*)> WSRequestHandler::messageMap {
{ "GetVersion", WSRequestHandler::HandleGetVersion },
{ "GetAuthRequired", WSRequestHandler::HandleGetAuthRequired },
{ "Authenticate", WSRequestHandler::HandleAuthenticate },
@ -136,26 +136,22 @@ WSRequestHandler::WSRequestHandler(QVariantHash& connProperties) :
{
}
std::string WSRequestHandler::processIncomingMessage(std::string& textMessage) {
obs_data_t* WSRequestHandler::processIncomingMessage(std::string& textMessage) {
std::string msgContainer(textMessage);
const char* msg = msgContainer.c_str();
data = obs_data_create_from_json(msg);
if (!data) {
blog(LOG_ERROR, "invalid JSON payload received for '%s'", msg);
SendErrorResponse("invalid JSON payload");
return _response;
return SendErrorResponse("invalid JSON payload");
}
if (Config::Current()->DebugEnabled) {
blog(LOG_DEBUG, "Request >> '%s'", msg);
}
if (!hasField("request-type")
|| !hasField("message-id"))
{
SendErrorResponse("missing request parameters");
return _response;
if (!hasField("request-type") || !hasField("message-id")) {
return SendErrorResponse("missing request parameters");
}
_requestType = obs_data_get_string(data, "request-type");
@ -165,59 +161,45 @@ std::string WSRequestHandler::processIncomingMessage(std::string& textMessage) {
&& (!authNotRequired.contains(_requestType))
&& (_connProperties.value(PROP_AUTHENTICATED).toBool() == false))
{
SendErrorResponse("Not Authenticated");
return _response;
return SendErrorResponse("Not Authenticated");
}
void (*handlerFunc)(WSRequestHandler*) = (messageMap[_requestType]);
HandlerResponse (*handlerFunc)(WSRequestHandler*) = (messageMap[_requestType]);
if (!handlerFunc) {
return SendErrorResponse("invalid request type");
}
if (handlerFunc != nullptr)
handlerFunc(this);
else
SendErrorResponse("invalid request type");
return _response;
return handlerFunc(this);
}
WSRequestHandler::~WSRequestHandler() {
}
void WSRequestHandler::SendOKResponse(obs_data_t* additionalFields) {
OBSDataAutoRelease response = obs_data_create();
obs_data_set_string(response, "status", "ok");
obs_data_set_string(response, "message-id", _messageId);
if (additionalFields)
obs_data_apply(response, additionalFields);
SendResponse(response);
HandlerResponse WSRequestHandler::SendOKResponse(obs_data_t* additionalFields) {
return SendResponse("ok", additionalFields);
}
void WSRequestHandler::SendErrorResponse(const char* errorMessage) {
OBSDataAutoRelease response = obs_data_create();
obs_data_set_string(response, "status", "error");
obs_data_set_string(response, "error", errorMessage);
obs_data_set_string(response, "message-id", _messageId);
HandlerResponse WSRequestHandler::SendErrorResponse(const char* errorMessage) {
OBSDataAutoRelease fields = obs_data_create();
obs_data_set_string(fields, "error", errorMessage);
SendResponse(response);
return SendResponse("error", fields);
}
void WSRequestHandler::SendErrorResponse(obs_data_t* additionalFields) {
OBSDataAutoRelease response = obs_data_create();
obs_data_set_string(response, "status", "error");
obs_data_set_string(response, "message-id", _messageId);
if (additionalFields)
obs_data_set_obj(response, "error", additionalFields);
SendResponse(response);
HandlerResponse WSRequestHandler::SendErrorResponse(obs_data_t* additionalFields) {
return SendResponse("error", additionalFields);
}
void WSRequestHandler::SendResponse(obs_data_t* response) {
_response = obs_data_get_json(response);
HandlerResponse WSRequestHandler::SendResponse(const char* status, obs_data_t* fields) {
obs_data_t* response = obs_data_create();
obs_data_set_string(response, "message-id", _messageId);
obs_data_set_string(response, "status", status);
if (Config::Current()->DebugEnabled)
blog(LOG_DEBUG, "Response << '%s'", _response.c_str());
if (fields) {
obs_data_apply(response, fields);
}
return response;
}
bool WSRequestHandler::hasField(QString name) {

169
src/WSRequestHandler.h
View File

@ -29,125 +29,126 @@ with this program. If not, see <https://www.gnu.org/licenses/>
#include "obs-websocket.h"
typedef obs_data_t* HandlerResponse;
class WSRequestHandler : public QObject {
Q_OBJECT
public:
explicit WSRequestHandler(QVariantHash& connProperties);
~WSRequestHandler();
std::string processIncomingMessage(std::string& textMessage);
obs_data_t* processIncomingMessage(std::string& textMessage);
bool hasField(QString name);
private:
const char* _messageId;
const char* _requestType;
std::string _response;
QVariantHash& _connProperties;
OBSDataAutoRelease data;
void SendOKResponse(obs_data_t* additionalFields = NULL);
void SendErrorResponse(const char* errorMessage);
void SendErrorResponse(obs_data_t* additionalFields = NULL);
void SendResponse(obs_data_t* response);
HandlerResponse SendOKResponse(obs_data_t* additionalFields = nullptr);
HandlerResponse SendErrorResponse(const char* errorMessage);
HandlerResponse SendErrorResponse(obs_data_t* additionalFields = nullptr);
HandlerResponse SendResponse(const char* status, obs_data_t* additionalFields = nullptr);
static QHash<QString, void(*)(WSRequestHandler*)> messageMap;
static QHash<QString, HandlerResponse(*)(WSRequestHandler*)> messageMap;
static QSet<QString> authNotRequired;
static void HandleGetVersion(WSRequestHandler* req);
static void HandleGetAuthRequired(WSRequestHandler* req);
static void HandleAuthenticate(WSRequestHandler* req);
static HandlerResponse HandleGetVersion(WSRequestHandler* req);
static HandlerResponse HandleGetAuthRequired(WSRequestHandler* req);
static HandlerResponse HandleAuthenticate(WSRequestHandler* req);
static void HandleSetHeartbeat(WSRequestHandler* req);
static HandlerResponse HandleSetHeartbeat(WSRequestHandler* req);
static void HandleSetFilenameFormatting(WSRequestHandler* req);
static void HandleGetFilenameFormatting(WSRequestHandler* req);
static HandlerResponse HandleSetFilenameFormatting(WSRequestHandler* req);
static HandlerResponse HandleGetFilenameFormatting(WSRequestHandler* req);
static void HandleSetCurrentScene(WSRequestHandler* req);
static void HandleGetCurrentScene(WSRequestHandler* req);
static void HandleGetSceneList(WSRequestHandler* req);
static HandlerResponse HandleSetCurrentScene(WSRequestHandler* req);
static HandlerResponse HandleGetCurrentScene(WSRequestHandler* req);
static HandlerResponse HandleGetSceneList(WSRequestHandler* req);
static void HandleSetSceneItemRender(WSRequestHandler* req);
static void HandleSetSceneItemPosition(WSRequestHandler* req);
static void HandleSetSceneItemTransform(WSRequestHandler* req);
static void HandleSetSceneItemCrop(WSRequestHandler* req);
static void HandleGetSceneItemProperties(WSRequestHandler* req);
static void HandleSetSceneItemProperties(WSRequestHandler* req);
static void HandleResetSceneItem(WSRequestHandler* req);
static void HandleDuplicateSceneItem(WSRequestHandler* req);
static void HandleDeleteSceneItem(WSRequestHandler* req);
static void HandleReorderSceneItems(WSRequestHandler* req);
static HandlerResponse HandleSetSceneItemRender(WSRequestHandler* req);
static HandlerResponse HandleSetSceneItemPosition(WSRequestHandler* req);
static HandlerResponse HandleSetSceneItemTransform(WSRequestHandler* req);
static HandlerResponse HandleSetSceneItemCrop(WSRequestHandler* req);
static HandlerResponse HandleGetSceneItemProperties(WSRequestHandler* req);
static HandlerResponse HandleSetSceneItemProperties(WSRequestHandler* req);
static HandlerResponse HandleResetSceneItem(WSRequestHandler* req);
static HandlerResponse HandleDuplicateSceneItem(WSRequestHandler* req);
static HandlerResponse HandleDeleteSceneItem(WSRequestHandler* req);
static HandlerResponse HandleReorderSceneItems(WSRequestHandler* req);
static void HandleGetStreamingStatus(WSRequestHandler* req);
static void HandleStartStopStreaming(WSRequestHandler* req);
static void HandleStartStopRecording(WSRequestHandler* req);
static void HandleStartStreaming(WSRequestHandler* req);
static void HandleStopStreaming(WSRequestHandler* req);
static void HandleStartRecording(WSRequestHandler* req);
static void HandleStopRecording(WSRequestHandler* req);
static HandlerResponse HandleGetStreamingStatus(WSRequestHandler* req);
static HandlerResponse HandleStartStopStreaming(WSRequestHandler* req);
static HandlerResponse HandleStartStopRecording(WSRequestHandler* req);
static HandlerResponse HandleStartStreaming(WSRequestHandler* req);
static HandlerResponse HandleStopStreaming(WSRequestHandler* req);
static HandlerResponse HandleStartRecording(WSRequestHandler* req);
static HandlerResponse HandleStopRecording(WSRequestHandler* req);
static void HandleStartStopReplayBuffer(WSRequestHandler* req);
static void HandleStartReplayBuffer(WSRequestHandler* req);
static void HandleStopReplayBuffer(WSRequestHandler* req);
static void HandleSaveReplayBuffer(WSRequestHandler* req);
static HandlerResponse HandleStartStopReplayBuffer(WSRequestHandler* req);
static HandlerResponse HandleStartReplayBuffer(WSRequestHandler* req);
static HandlerResponse HandleStopReplayBuffer(WSRequestHandler* req);
static HandlerResponse HandleSaveReplayBuffer(WSRequestHandler* req);
static void HandleSetRecordingFolder(WSRequestHandler* req);
static void HandleGetRecordingFolder(WSRequestHandler* req);
static HandlerResponse HandleSetRecordingFolder(WSRequestHandler* req);
static HandlerResponse HandleGetRecordingFolder(WSRequestHandler* req);
static void HandleGetTransitionList(WSRequestHandler* req);
static void HandleGetCurrentTransition(WSRequestHandler* req);
static void HandleSetCurrentTransition(WSRequestHandler* req);
static HandlerResponse HandleGetTransitionList(WSRequestHandler* req);
static HandlerResponse HandleGetCurrentTransition(WSRequestHandler* req);
static HandlerResponse HandleSetCurrentTransition(WSRequestHandler* req);
static void HandleSetVolume(WSRequestHandler* req);
static void HandleGetVolume(WSRequestHandler* req);
static void HandleToggleMute(WSRequestHandler* req);
static void HandleSetMute(WSRequestHandler* req);
static void HandleGetMute(WSRequestHandler* req);
static void HandleSetSyncOffset(WSRequestHandler* req);
static void HandleGetSyncOffset(WSRequestHandler* req);
static void HandleGetSpecialSources(WSRequestHandler* req);
static void HandleGetSourcesList(WSRequestHandler* req);
static void HandleGetSourceTypesList(WSRequestHandler* req);
static void HandleGetSourceSettings(WSRequestHandler* req);
static void HandleSetSourceSettings(WSRequestHandler* req);
static HandlerResponse HandleSetVolume(WSRequestHandler* req);
static HandlerResponse HandleGetVolume(WSRequestHandler* req);
static HandlerResponse HandleToggleMute(WSRequestHandler* req);
static HandlerResponse HandleSetMute(WSRequestHandler* req);
static HandlerResponse HandleGetMute(WSRequestHandler* req);
static HandlerResponse HandleSetSyncOffset(WSRequestHandler* req);
static HandlerResponse HandleGetSyncOffset(WSRequestHandler* req);
static HandlerResponse HandleGetSpecialSources(WSRequestHandler* req);
static HandlerResponse HandleGetSourcesList(WSRequestHandler* req);
static HandlerResponse HandleGetSourceTypesList(WSRequestHandler* req);
static HandlerResponse HandleGetSourceSettings(WSRequestHandler* req);
static HandlerResponse HandleSetSourceSettings(WSRequestHandler* req);
static void HandleGetSourceFilters(WSRequestHandler* req);
static void HandleAddFilterToSource(WSRequestHandler* req);
static void HandleRemoveFilterFromSource(WSRequestHandler* req);
static void HandleReorderSourceFilter(WSRequestHandler* req);
static void HandleMoveSourceFilter(WSRequestHandler* req);
static void HandleSetSourceFilterSettings(WSRequestHandler* req);
static HandlerResponse HandleGetSourceFilters(WSRequestHandler* req);
static HandlerResponse HandleAddFilterToSource(WSRequestHandler* req);
static HandlerResponse HandleRemoveFilterFromSource(WSRequestHandler* req);
static HandlerResponse HandleReorderSourceFilter(WSRequestHandler* req);
static HandlerResponse HandleMoveSourceFilter(WSRequestHandler* req);
static HandlerResponse HandleSetSourceFilterSettings(WSRequestHandler* req);
static void HandleSetCurrentSceneCollection(WSRequestHandler* req);
static void HandleGetCurrentSceneCollection(WSRequestHandler* req);
static void HandleListSceneCollections(WSRequestHandler* req);
static HandlerResponse HandleSetCurrentSceneCollection(WSRequestHandler* req);
static HandlerResponse HandleGetCurrentSceneCollection(WSRequestHandler* req);
static HandlerResponse HandleListSceneCollections(WSRequestHandler* req);
static void HandleSetCurrentProfile(WSRequestHandler* req);
static void HandleGetCurrentProfile(WSRequestHandler* req);
static void HandleListProfiles(WSRequestHandler* req);
static HandlerResponse HandleSetCurrentProfile(WSRequestHandler* req);
static HandlerResponse HandleGetCurrentProfile(WSRequestHandler* req);
static HandlerResponse HandleListProfiles(WSRequestHandler* req);
static void HandleSetStreamSettings(WSRequestHandler* req);
static void HandleGetStreamSettings(WSRequestHandler* req);
static void HandleSaveStreamSettings(WSRequestHandler* req);
static HandlerResponse HandleSetStreamSettings(WSRequestHandler* req);
static HandlerResponse HandleGetStreamSettings(WSRequestHandler* req);
static HandlerResponse HandleSaveStreamSettings(WSRequestHandler* req);
static void HandleSetTransitionDuration(WSRequestHandler* req);
static void HandleGetTransitionDuration(WSRequestHandler* req);
static HandlerResponse HandleSetTransitionDuration(WSRequestHandler* req);
static HandlerResponse HandleGetTransitionDuration(WSRequestHandler* req);
static void HandleGetStudioModeStatus(WSRequestHandler* req);
static void HandleGetPreviewScene(WSRequestHandler* req);
static void HandleSetPreviewScene(WSRequestHandler* req);
static void HandleTransitionToProgram(WSRequestHandler* req);
static void HandleEnableStudioMode(WSRequestHandler* req);
static void HandleDisableStudioMode(WSRequestHandler* req);
static void HandleToggleStudioMode(WSRequestHandler* req);
static HandlerResponse HandleGetStudioModeStatus(WSRequestHandler* req);
static HandlerResponse HandleGetPreviewScene(WSRequestHandler* req);
static HandlerResponse HandleSetPreviewScene(WSRequestHandler* req);
static HandlerResponse HandleTransitionToProgram(WSRequestHandler* req);
static HandlerResponse HandleEnableStudioMode(WSRequestHandler* req);
static HandlerResponse HandleDisableStudioMode(WSRequestHandler* req);
static HandlerResponse HandleToggleStudioMode(WSRequestHandler* req);
static void HandleSetTextGDIPlusProperties(WSRequestHandler* req);
static void HandleGetTextGDIPlusProperties(WSRequestHandler* req);
static HandlerResponse HandleSetTextGDIPlusProperties(WSRequestHandler* req);
static HandlerResponse HandleGetTextGDIPlusProperties(WSRequestHandler* req);
static void HandleSetTextFreetype2Properties(WSRequestHandler* req);
static void HandleGetTextFreetype2Properties(WSRequestHandler* req);
static HandlerResponse HandleSetTextFreetype2Properties(WSRequestHandler* req);
static HandlerResponse HandleGetTextFreetype2Properties(WSRequestHandler* req);
static void HandleSetBrowserSourceProperties(WSRequestHandler* req);
static void HandleGetBrowserSourceProperties(WSRequestHandler* req);
static HandlerResponse HandleSetBrowserSourceProperties(WSRequestHandler* req);
static HandlerResponse HandleGetBrowserSourceProperties(WSRequestHandler* req);
};
#endif // WSPROTOCOL_H

51
src/WSRequestHandler_General.cpp
View File

@ -19,7 +19,7 @@
* @category general
* @since 0.3
*/
void WSRequestHandler::HandleGetVersion(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetVersion(WSRequestHandler* req) {
QString obsVersion = Utils::OBSVersionString();
QList<QString> names = req->messageMap.keys();
@ -37,7 +37,7 @@
obs_data_set_string(data, "obs-studio-version", obsVersion.toUtf8());
obs_data_set_string(data, "available-requests", requests.toUtf8());
req->SendOKResponse(data);
return req->SendOKResponse(data);
}
/**
@ -53,7 +53,7 @@
* @category general
* @since 0.3
*/
void WSRequestHandler::HandleGetAuthRequired(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetAuthRequired(WSRequestHandler* req) {
bool authRequired = Config::Current()->AuthRequired;
OBSDataAutoRelease data = obs_data_create();
@ -66,7 +66,7 @@ void WSRequestHandler::HandleGetAuthRequired(WSRequestHandler* req) {
Config::Current()->Salt.toUtf8());
}
req->SendOKResponse(data);
return req->SendOKResponse(data);
}
/**
@ -79,30 +79,26 @@ void WSRequestHandler::HandleGetAuthRequired(WSRequestHandler* req) {
* @category general
* @since 0.3
*/
void WSRequestHandler::HandleAuthenticate(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleAuthenticate(WSRequestHandler* req) {
if (!req->hasField("auth")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
if (req->_connProperties.value(PROP_AUTHENTICATED).toBool() == true) {
req->SendErrorResponse("already authenticated");
return;
return req->SendErrorResponse("already authenticated");
}
QString auth = obs_data_get_string(req->data, "auth");
if (auth.isEmpty()) {
req->SendErrorResponse("auth not specified!");
return;
return req->SendErrorResponse("auth not specified!");
}
if (Config::Current()->CheckAuth(auth) == false) {
req->SendErrorResponse("Authentication Failed.");
return;
return req->SendErrorResponse("Authentication Failed.");
}
req->_connProperties.insert(PROP_AUTHENTICATED, true);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -115,19 +111,17 @@ void WSRequestHandler::HandleAuthenticate(WSRequestHandler* req) {
* @category general
* @since 4.3.0
*/
void WSRequestHandler::HandleSetHeartbeat(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetHeartbeat(WSRequestHandler* req) {
if (!req->hasField("enable")) {
req->SendErrorResponse("Heartbeat <enable> parameter missing");
return;
return req->SendErrorResponse("Heartbeat <enable> parameter missing");
}
auto events = WSEvents::Current();
events->HeartbeatIsActive = obs_data_get_bool(req->data, "enable");
OBSDataAutoRelease response = obs_data_create();
obs_data_set_bool(response, "enable", events->HeartbeatIsActive);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -140,19 +134,18 @@ void WSRequestHandler::HandleAuthenticate(WSRequestHandler* req) {
* @category general
* @since 4.3.0
*/
void WSRequestHandler::HandleSetFilenameFormatting(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetFilenameFormatting(WSRequestHandler* req) {
if (!req->hasField("filename-formatting")) {
req->SendErrorResponse("<filename-formatting> parameter missing");
return;
return req->SendErrorResponse("<filename-formatting> parameter missing");
}
QString filenameFormatting = obs_data_get_string(req->data, "filename-formatting");
if (!filenameFormatting.isEmpty()) {
Utils::SetFilenameFormatting(filenameFormatting.toUtf8());
req->SendOKResponse();
} else {
req->SendErrorResponse("invalid request parameters");
if (filenameFormatting.isEmpty()) {
return req->SendErrorResponse("invalid request parameters");
}
Utils::SetFilenameFormatting(filenameFormatting.toUtf8());
return req->SendOKResponse();
}
/**
@ -165,8 +158,8 @@ void WSRequestHandler::HandleSetFilenameFormatting(WSRequestHandler* req) {
* @category general
* @since 4.3.0
*/
void WSRequestHandler::HandleGetFilenameFormatting(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetFilenameFormatting(WSRequestHandler* req) {
OBSDataAutoRelease response = obs_data_create();
obs_data_set_string(response, "filename-formatting", Utils::GetFilenameFormatting());
req->SendOKResponse(response);
return req->SendOKResponse(response);
}

32
src/WSRequestHandler_Profiles.cpp
View File

@ -13,20 +13,19 @@
* @category profiles
* @since 4.0.0
*/
void WSRequestHandler::HandleSetCurrentProfile(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetCurrentProfile(WSRequestHandler* req) {
if (!req->hasField("profile-name")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString profileName = obs_data_get_string(req->data, "profile-name");
if (!profileName.isEmpty()) {
// TODO : check if profile exists
obs_frontend_set_current_profile(profileName.toUtf8());
req->SendOKResponse();
} else {
req->SendErrorResponse("invalid request parameters");
if (profileName.isEmpty()) {
return req->SendErrorResponse("invalid request parameters");
}
// TODO : check if profile exists
obs_frontend_set_current_profile(profileName.toUtf8());
return req->SendOKResponse();
}
/**
@ -39,12 +38,10 @@
* @category profiles
* @since 4.0.0
*/
void WSRequestHandler::HandleGetCurrentProfile(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetCurrentProfile(WSRequestHandler* req) {
OBSDataAutoRelease response = obs_data_create();
obs_data_set_string(response, "profile-name",
obs_frontend_get_current_profile());
req->SendOKResponse(response);
obs_data_set_string(response, "profile-name", obs_frontend_get_current_profile());
return req->SendOKResponse(response);
}
/**
@ -57,14 +54,13 @@ void WSRequestHandler::HandleGetCurrentProfile(WSRequestHandler* req) {
* @category profiles
* @since 4.0.0
*/
void WSRequestHandler::HandleListProfiles(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleListProfiles(WSRequestHandler* req) {
char** profiles = obs_frontend_get_profiles();
OBSDataArrayAutoRelease list =
Utils::StringListToArray(profiles, "profile-name");
OBSDataArrayAutoRelease list = Utils::StringListToArray(profiles, "profile-name");
bfree(profiles);
OBSDataAutoRelease response = obs_data_create();
obs_data_set_array(response, "profiles", list);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}

34
src/WSRequestHandler_Recording.cpp
View File

@ -11,13 +11,13 @@
* @category recording
* @since 0.3
*/
void WSRequestHandler::HandleStartStopRecording(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleStartStopRecording(WSRequestHandler* req) {
if (obs_frontend_recording_active())
obs_frontend_recording_stop();
else
obs_frontend_recording_start();
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -29,12 +29,12 @@
* @category recording
* @since 4.1.0
*/
void WSRequestHandler::HandleStartRecording(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleStartRecording(WSRequestHandler* req) {
if (obs_frontend_recording_active() == false) {
obs_frontend_recording_start();
req->SendOKResponse();
return req->SendOKResponse();
} else {
req->SendErrorResponse("recording already active");
return req->SendErrorResponse("recording already active");
}
}
@ -47,12 +47,12 @@
* @category recording
* @since 4.1.0
*/
void WSRequestHandler::HandleStopRecording(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleStopRecording(WSRequestHandler* req) {
if (obs_frontend_recording_active() == true) {
obs_frontend_recording_stop();
req->SendOKResponse();
return req->SendOKResponse();
} else {
req->SendErrorResponse("recording not active");
return req->SendErrorResponse("recording not active");
}
}
@ -66,18 +66,18 @@ void WSRequestHandler::HandleStopRecording(WSRequestHandler* req) {
* @category recording
* @since 4.1.0
*/
void WSRequestHandler::HandleSetRecordingFolder(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetRecordingFolder(WSRequestHandler* req) {
if (!req->hasField("rec-folder")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* newRecFolder = obs_data_get_string(req->data, "rec-folder");
bool success = Utils::SetRecordingFolder(newRecFolder);
if (success)
req->SendOKResponse();
else
req->SendErrorResponse("invalid request parameters");
if (!success) {
return req->SendErrorResponse("invalid request parameters");
}
return req->SendOKResponse();
}
/**
@ -90,11 +90,11 @@ void WSRequestHandler::HandleStopRecording(WSRequestHandler* req) {
* @category recording
* @since 4.1.0
*/
void WSRequestHandler::HandleGetRecordingFolder(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetRecordingFolder(WSRequestHandler* req) {
const char* recFolder = Utils::GetRecordingFolder();
OBSDataAutoRelease response = obs_data_create();
obs_data_set_string(response, "rec-folder", recFolder);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}

27
src/WSRequestHandler_ReplayBuffer.cpp
View File

@ -11,13 +11,13 @@
* @category replay buffer
* @since 4.2.0
*/
void WSRequestHandler::HandleStartStopReplayBuffer(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleStartStopReplayBuffer(WSRequestHandler* req) {
if (obs_frontend_replay_buffer_active()) {
obs_frontend_replay_buffer_stop();
} else {
Utils::StartReplayBuffer();
}
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -32,19 +32,17 @@ void WSRequestHandler::HandleStartStopReplayBuffer(WSRequestHandler* req) {
* @category replay buffer
* @since 4.2.0
*/
void WSRequestHandler::HandleStartReplayBuffer(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleStartReplayBuffer(WSRequestHandler* req) {
if (!Utils::ReplayBufferEnabled()) {
req->SendErrorResponse("replay buffer disabled in settings");
return;
return req->SendErrorResponse("replay buffer disabled in settings");
}
if (obs_frontend_replay_buffer_active() == true) {
req->SendErrorResponse("replay buffer already active");
return;
return req->SendErrorResponse("replay buffer already active");
}
Utils::StartReplayBuffer();
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -56,12 +54,12 @@ void WSRequestHandler::HandleStartReplayBuffer(WSRequestHandler* req) {
* @category replay buffer
* @since 4.2.0
*/
void WSRequestHandler::HandleStopReplayBuffer(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleStopReplayBuffer(WSRequestHandler* req) {
if (obs_frontend_replay_buffer_active() == true) {
obs_frontend_replay_buffer_stop();
req->SendOKResponse();
return req->SendOKResponse();
} else {
req->SendErrorResponse("replay buffer not active");
return req->SendErrorResponse("replay buffer not active");
}
}
@ -75,10 +73,9 @@ void WSRequestHandler::HandleStopReplayBuffer(WSRequestHandler* req) {
* @category replay buffer
* @since 4.2.0
*/
void WSRequestHandler::HandleSaveReplayBuffer(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSaveReplayBuffer(WSRequestHandler* req) {
if (!obs_frontend_replay_buffer_active()) {
req->SendErrorResponse("replay buffer not active");
return;
return req->SendErrorResponse("replay buffer not active");
}
OBSOutputAutoRelease replayOutput = obs_frontend_get_replay_buffer_output();
@ -88,5 +85,5 @@ void WSRequestHandler::HandleSaveReplayBuffer(WSRequestHandler* req) {
proc_handler_call(ph, "save", &cd);
calldata_free(&cd);
req->SendOKResponse();
return req->SendOKResponse();
}

25
src/WSRequestHandler_SceneCollections.cpp
View File

@ -13,20 +13,19 @@
* @category scene collections
* @since 4.0.0
*/
void WSRequestHandler::HandleSetCurrentSceneCollection(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetCurrentSceneCollection(WSRequestHandler* req) {
if (!req->hasField("sc-name")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString sceneCollection = obs_data_get_string(req->data, "sc-name");
if (!sceneCollection.isEmpty()) {
// TODO : Check if specified profile exists and if changing is allowed
obs_frontend_set_current_scene_collection(sceneCollection.toUtf8());
req->SendOKResponse();
} else {
req->SendErrorResponse("invalid request parameters");
if (sceneCollection.isEmpty()) {
return req->SendErrorResponse("invalid request parameters");
}
// TODO : Check if specified profile exists and if changing is allowed
obs_frontend_set_current_scene_collection(sceneCollection.toUtf8());
return req->SendOKResponse();
}
/**
@ -39,12 +38,12 @@
* @category scene collections
* @since 4.0.0
*/
void WSRequestHandler::HandleGetCurrentSceneCollection(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetCurrentSceneCollection(WSRequestHandler* req) {
OBSDataAutoRelease response = obs_data_create();
obs_data_set_string(response, "sc-name",
obs_frontend_get_current_scene_collection());
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -57,7 +56,7 @@ void WSRequestHandler::HandleGetCurrentSceneCollection(WSRequestHandler* req) {
* @category scene collections
* @since 4.0.0
*/
void WSRequestHandler::HandleListSceneCollections(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleListSceneCollections(WSRequestHandler* req) {
char** sceneCollections = obs_frontend_get_scene_collections();
OBSDataArrayAutoRelease list =
Utils::StringListToArray(sceneCollections, "sc-name");
@ -66,5 +65,5 @@ void WSRequestHandler::HandleListSceneCollections(WSRequestHandler* req) {
OBSDataAutoRelease response = obs_data_create();
obs_data_set_array(response, "scene-collections", list);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}

211
src/WSRequestHandler_SceneItems.cpp
View File

@ -31,30 +31,26 @@
* @category scene items
* @since 4.3.0
*/
void WSRequestHandler::HandleGetSceneItemProperties(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetSceneItemProperties(WSRequestHandler* req) {
if (!req->hasField("item")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString itemName = obs_data_get_string(req->data, "item");
if (itemName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
QString sceneName = obs_data_get_string(req->data, "scene-name");
OBSSourceAutoRelease scene = Utils::GetSceneFromNameOrCurrent(sceneName);
if (!scene) {
req->SendErrorResponse("requested scene doesn't exist");
return;
return req->SendErrorResponse("requested scene doesn't exist");
}
OBSSceneItemAutoRelease sceneItem =
Utils::GetSceneItemFromName(scene, itemName);
if (!sceneItem) {
req->SendErrorResponse("specified scene item doesn't exist");
return;
return req->SendErrorResponse("specified scene item doesn't exist");
}
OBSDataAutoRelease data = obs_data_create();
@ -128,7 +124,7 @@ void WSRequestHandler::HandleGetSceneItemProperties(WSRequestHandler* req) {
}
obs_data_set_obj(data, "bounds", boundsData);
req->SendOKResponse(data);
return req->SendOKResponse(data);
}
/**
@ -157,30 +153,26 @@ void WSRequestHandler::HandleGetSceneItemProperties(WSRequestHandler* req) {
* @category scene items
* @since 4.3.0
*/
void WSRequestHandler::HandleSetSceneItemProperties(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetSceneItemProperties(WSRequestHandler* req) {
if (!req->hasField("item")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString itemName = obs_data_get_string(req->data, "item");
if (itemName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
QString sceneName = obs_data_get_string(req->data, "scene-name");
OBSSourceAutoRelease scene = Utils::GetSceneFromNameOrCurrent(sceneName);
if (!scene) {
req->SendErrorResponse("requested scene doesn't exist");
return;
return req->SendErrorResponse("requested scene doesn't exist");
}
OBSSceneItemAutoRelease sceneItem =
Utils::GetSceneItemFromName(scene, itemName);
if (!sceneItem) {
req->SendErrorResponse("specified scene item doesn't exist");
return;
return req->SendErrorResponse("specified scene item doesn't exist");
}
bool badRequest = false;
@ -312,11 +304,10 @@ void WSRequestHandler::HandleSetSceneItemProperties(WSRequestHandler* req) {
}
if (badRequest) {
req->SendErrorResponse(errorMessage);
}
else {
req->SendOKResponse();
return req->SendErrorResponse(errorMessage);
}
return req->SendOKResponse();
}
/**
@ -330,39 +321,35 @@ void WSRequestHandler::HandleSetSceneItemProperties(WSRequestHandler* req) {
* @category scene items
* @since 4.2.0
*/
void WSRequestHandler::HandleResetSceneItem(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleResetSceneItem(WSRequestHandler* req) {
// TODO: remove this request, or refactor it to ResetSource
if (!req->hasField("item")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* itemName = obs_data_get_string(req->data, "item");
if (!itemName) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
const char* sceneName = obs_data_get_string(req->data, "scene-name");
OBSSourceAutoRelease scene = Utils::GetSceneFromNameOrCurrent(sceneName);
if (!scene) {
req->SendErrorResponse("requested scene doesn't exist");
return;
return req->SendErrorResponse("requested scene doesn't exist");
}
OBSSceneItemAutoRelease sceneItem = Utils::GetSceneItemFromName(scene, itemName);
if (sceneItem) {
OBSSource sceneItemSource = obs_sceneitem_get_source(sceneItem);
OBSDataAutoRelease settings = obs_source_get_settings(sceneItemSource);
obs_source_update(sceneItemSource, settings);
req->SendOKResponse();
}
else {
req->SendErrorResponse("specified scene item doesn't exist");
if (!sceneItem) {
return req->SendErrorResponse("specified scene item doesn't exist");
}
OBSSource sceneItemSource = obs_sceneitem_get_source(sceneItem);
OBSDataAutoRelease settings = obs_source_get_settings(sceneItemSource);
obs_source_update(sceneItemSource, settings);
return req->SendOKResponse();
}
/**
@ -378,38 +365,34 @@ void WSRequestHandler::HandleResetSceneItem(WSRequestHandler* req) {
* @since 0.3
* @deprecated Since 4.3.0. Prefer the use of SetSceneItemProperties.
*/
void WSRequestHandler::HandleSetSceneItemRender(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetSceneItemRender(WSRequestHandler* req) {
if (!req->hasField("source") ||
!req->hasField("render"))
{
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* itemName = obs_data_get_string(req->data, "source");
bool isVisible = obs_data_get_bool(req->data, "render");
if (!itemName) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
const char* sceneName = obs_data_get_string(req->data, "scene-name");
OBSSourceAutoRelease scene = Utils::GetSceneFromNameOrCurrent(sceneName);
if (!scene) {
req->SendErrorResponse("requested scene doesn't exist");
return;
return req->SendErrorResponse("requested scene doesn't exist");
}
OBSSceneItemAutoRelease sceneItem =
Utils::GetSceneItemFromName(scene, itemName);
if (sceneItem) {
obs_sceneitem_set_visible(sceneItem, isVisible);
req->SendOKResponse();
}
else {
req->SendErrorResponse("specified scene item doesn't exist");
if (!sceneItem) {
return req->SendErrorResponse("specified scene item doesn't exist");
}
obs_sceneitem_set_visible(sceneItem, isVisible);
return req->SendOKResponse();
}
/**
@ -427,38 +410,34 @@ void WSRequestHandler::HandleSetSceneItemRender(WSRequestHandler* req) {
* @since 4.0.0
* @deprecated Since 4.3.0. Prefer the use of SetSceneItemProperties.
*/
void WSRequestHandler::HandleSetSceneItemPosition(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetSceneItemPosition(WSRequestHandler* req) {
if (!req->hasField("item") ||
!req->hasField("x") || !req->hasField("y")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString itemName = obs_data_get_string(req->data, "item");
if (itemName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
QString sceneName = obs_data_get_string(req->data, "scene-name");
OBSSourceAutoRelease scene = Utils::GetSceneFromNameOrCurrent(sceneName);
if (!scene) {
req->SendErrorResponse("requested scene could not be found");
return;
return req->SendErrorResponse("requested scene could not be found");
}
OBSSceneItem sceneItem = Utils::GetSceneItemFromName(scene, itemName);
if (sceneItem) {
vec2 item_position = { 0 };
item_position.x = obs_data_get_double(req->data, "x");
item_position.y = obs_data_get_double(req->data, "y");
obs_sceneitem_set_pos(sceneItem, &item_position);
if (!sceneItem) {
return req->SendErrorResponse("specified scene item doesn't exist");
}
vec2 item_position = { 0 };
item_position.x = obs_data_get_double(req->data, "x");
item_position.y = obs_data_get_double(req->data, "y");
obs_sceneitem_set_pos(sceneItem, &item_position);
req->SendOKResponse();
}
else {
req->SendErrorResponse("specified scene item doesn't exist");
}
return req->SendOKResponse();
}
/**
@ -476,27 +455,24 @@ void WSRequestHandler::HandleSetSceneItemPosition(WSRequestHandler* req) {
* @since 4.0.0
* @deprecated Since 4.3.0. Prefer the use of SetSceneItemProperties.
*/
void WSRequestHandler::HandleSetSceneItemTransform(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetSceneItemTransform(WSRequestHandler* req) {
if (!req->hasField("item") ||
!req->hasField("x-scale") ||
!req->hasField("y-scale") ||
!req->hasField("rotation"))
{
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString itemName = obs_data_get_string(req->data, "item");
if (itemName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
QString sceneName = obs_data_get_string(req->data, "scene-name");
OBSSourceAutoRelease scene = Utils::GetSceneFromNameOrCurrent(sceneName);
if (!scene) {
req->SendErrorResponse("requested scene doesn't exist");
return;
return req->SendErrorResponse("requested scene doesn't exist");
}
vec2 scale;
@ -505,14 +481,13 @@ void WSRequestHandler::HandleSetSceneItemTransform(WSRequestHandler* req) {
float rotation = obs_data_get_double(req->data, "rotation");
OBSSceneItemAutoRelease sceneItem = Utils::GetSceneItemFromName(scene, itemName);
if (sceneItem) {
obs_sceneitem_set_scale(sceneItem, &scale);
obs_sceneitem_set_rot(sceneItem, rotation);
req->SendOKResponse();
}
else {
req->SendErrorResponse("specified scene item doesn't exist");
if (!sceneItem) {
return req->SendErrorResponse("specified scene item doesn't exist");
}
obs_sceneitem_set_scale(sceneItem, &scale);
obs_sceneitem_set_rot(sceneItem, rotation);
return req->SendOKResponse();
}
/**
@ -531,40 +506,36 @@ void WSRequestHandler::HandleSetSceneItemTransform(WSRequestHandler* req) {
* @since 4.1.0
* @deprecated Since 4.3.0. Prefer the use of SetSceneItemProperties.
*/
void WSRequestHandler::HandleSetSceneItemCrop(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetSceneItemCrop(WSRequestHandler* req) {
if (!req->hasField("item")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString itemName = obs_data_get_string(req->data, "item");
if (itemName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
QString sceneName = obs_data_get_string(req->data, "scene-name");
OBSSourceAutoRelease scene = Utils::GetSceneFromNameOrCurrent(sceneName);
if (!scene) {
req->SendErrorResponse("requested scene doesn't exist");
return;
return req->SendErrorResponse("requested scene doesn't exist");
}
OBSSceneItemAutoRelease sceneItem = Utils::GetSceneItemFromName(scene, itemName);
if (sceneItem) {
struct obs_sceneitem_crop crop = { 0 };
crop.top = obs_data_get_int(req->data, "top");
crop.bottom = obs_data_get_int(req->data, "bottom");
crop.left = obs_data_get_int(req->data, "left");
crop.right = obs_data_get_int(req->data, "right");
obs_sceneitem_set_crop(sceneItem, &crop);
req->SendOKResponse();
}
else {
req->SendErrorResponse("specified scene item doesn't exist");
if (!sceneItem) {
return req->SendErrorResponse("specified scene item doesn't exist");
}
struct obs_sceneitem_crop crop = { 0 };
crop.top = obs_data_get_int(req->data, "top");
crop.bottom = obs_data_get_int(req->data, "bottom");
crop.left = obs_data_get_int(req->data, "left");
crop.right = obs_data_get_int(req->data, "right");
obs_sceneitem_set_crop(sceneItem, &crop);
return req->SendOKResponse();
}
/**
@ -580,29 +551,26 @@ void WSRequestHandler::HandleSetSceneItemCrop(WSRequestHandler* req) {
* @category scene items
* @since 4.5.0
*/
void WSRequestHandler::HandleDeleteSceneItem(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleDeleteSceneItem(WSRequestHandler* req) {
if (!req->hasField("item")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sceneName = obs_data_get_string(req->data, "scene");
OBSSourceAutoRelease scene = Utils::GetSceneFromNameOrCurrent(sceneName);
if (!scene) {
req->SendErrorResponse("requested scene doesn't exist");
return;
return req->SendErrorResponse("requested scene doesn't exist");
}
OBSDataAutoRelease item = obs_data_get_obj(req->data, "item");
OBSSceneItemAutoRelease sceneItem = Utils::GetSceneItemFromItem(scene, item);
if (!sceneItem) {
req->SendErrorResponse("item with id/name combination not found in specified scene");
return;
return req->SendErrorResponse("item with id/name combination not found in specified scene");
}
obs_sceneitem_remove(sceneItem);
req->SendOKResponse();
return req->SendOKResponse();
}
struct DuplicateSceneItemData {
@ -636,31 +604,27 @@ static void DuplicateSceneItem(void *_data, obs_scene_t *scene) {
* @category scene items
* @since 4.5.0
*/
void WSRequestHandler::HandleDuplicateSceneItem(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleDuplicateSceneItem(WSRequestHandler* req) {
if (!req->hasField("item")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* fromSceneName = obs_data_get_string(req->data, "fromScene");
OBSSourceAutoRelease fromScene = Utils::GetSceneFromNameOrCurrent(fromSceneName);
if (!fromScene) {
req->SendErrorResponse("requested fromScene doesn't exist");
return;
return req->SendErrorResponse("requested fromScene doesn't exist");
}
const char* toSceneName = obs_data_get_string(req->data, "toScene");
OBSSourceAutoRelease toScene = Utils::GetSceneFromNameOrCurrent(toSceneName);
if (!toScene) {
req->SendErrorResponse("requested toScene doesn't exist");
return;
return req->SendErrorResponse("requested toScene doesn't exist");
}
OBSDataAutoRelease item = obs_data_get_obj(req->data, "item");
OBSSceneItemAutoRelease referenceItem = Utils::GetSceneItemFromItem(fromScene, item);
if (!referenceItem) {
req->SendErrorResponse("item with id/name combination not found in specified scene");
return;
return req->SendErrorResponse("item with id/name combination not found in specified scene");
}
DuplicateSceneItemData data;
@ -673,8 +637,7 @@ void WSRequestHandler::HandleDuplicateSceneItem(WSRequestHandler* req) {
obs_sceneitem_t *newItem = data.newItem;
if (!newItem) {
req->SendErrorResponse("Error duplicating scene item");
return;
return req->SendErrorResponse("Error duplicating scene item");
}
OBSDataAutoRelease itemData = obs_data_create();
@ -685,5 +648,5 @@ void WSRequestHandler::HandleDuplicateSceneItem(WSRequestHandler* req) {
obs_data_set_obj(responseData, "item", itemData);
obs_data_set_string(responseData, "scene", obs_source_get_name(toScene));
req->SendOKResponse(responseData);
return req->SendOKResponse(responseData);
}

36
src/WSRequestHandler_Scenes.cpp
View File

@ -19,10 +19,9 @@
* @category scenes
* @since 0.3
*/
void WSRequestHandler::HandleSetCurrentScene(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetCurrentScene(WSRequestHandler* req) {
if (!req->hasField("scene-name")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sceneName = obs_data_get_string(req->data, "scene-name");
@ -30,9 +29,9 @@
if (source) {
obs_frontend_set_current_scene(source);
req->SendOKResponse();
return req->SendOKResponse();
} else {
req->SendErrorResponse("requested scene does not exist");
return req->SendErrorResponse("requested scene does not exist");
}
}
@ -47,7 +46,7 @@
* @category scenes
* @since 0.3
*/
void WSRequestHandler::HandleGetCurrentScene(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetCurrentScene(WSRequestHandler* req) {
OBSSourceAutoRelease currentScene = obs_frontend_get_current_scene();
OBSDataArrayAutoRelease sceneItems = Utils::GetSceneItems(currentScene);
@ -55,7 +54,7 @@ void WSRequestHandler::HandleGetCurrentScene(WSRequestHandler* req) {
obs_data_set_string(data, "name", obs_source_get_name(currentScene));
obs_data_set_array(data, "sources", sceneItems);
req->SendOKResponse(data);
return req->SendOKResponse(data);
}
/**
@ -69,7 +68,7 @@ void WSRequestHandler::HandleGetCurrentScene(WSRequestHandler* req) {
* @category scenes
* @since 0.3
*/
void WSRequestHandler::HandleGetSceneList(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetSceneList(WSRequestHandler* req) {
OBSSourceAutoRelease currentScene = obs_frontend_get_current_scene();
OBSDataArrayAutoRelease scenes = Utils::GetScenes();
@ -78,7 +77,7 @@ void WSRequestHandler::HandleGetSceneList(WSRequestHandler* req) {
obs_source_get_name(currentScene));
obs_data_set_array(data, "scenes", scenes);
req->SendOKResponse(data);
return req->SendOKResponse(data);
}
/**
@ -94,18 +93,16 @@ void WSRequestHandler::HandleGetSceneList(WSRequestHandler* req) {
* @category scenes
* @since 4.5.0
*/
void WSRequestHandler::HandleReorderSceneItems(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleReorderSceneItems(WSRequestHandler* req) {
QString sceneName = obs_data_get_string(req->data, "scene");
OBSSourceAutoRelease scene = Utils::GetSceneFromNameOrCurrent(sceneName);
if (!scene) {
req->SendErrorResponse("requested scene doesn't exist");
return;
return req->SendErrorResponse("requested scene doesn't exist");
}
OBSDataArrayAutoRelease items = obs_data_get_array(req->data, "items");
if (!items) {
req->SendErrorResponse("sceneItem order not specified");
return;
return req->SendErrorResponse("sceneItem order not specified");
}
size_t count = obs_data_array_count(items);
@ -120,14 +117,12 @@ void WSRequestHandler::HandleReorderSceneItems(WSRequestHandler* req) {
obs_sceneitem_release(sceneItem); // ref dec
if (!sceneItem) {
req->SendErrorResponse("Invalid sceneItem id or name specified");
return;
return req->SendErrorResponse("Invalid sceneItem id or name specified");
}
for (size_t j = 0; j <= i; ++j) {
if (sceneItem == newOrder[j]) {
req->SendErrorResponse("Duplicate sceneItem in specified order");
return;
return req->SendErrorResponse("Duplicate sceneItem in specified order");
}
}
@ -136,13 +131,12 @@ void WSRequestHandler::HandleReorderSceneItems(WSRequestHandler* req) {
bool success = obs_scene_reorder_items(obs_scene_from_source(scene), newOrder.data(), count);
if (!success) {
req->SendErrorResponse("Invalid sceneItem order");
return;
return req->SendErrorResponse("Invalid sceneItem order");
}
for (auto const& item: newOrder) {
obs_sceneitem_release(item);
}
req->SendOKResponse();
return req->SendOKResponse();
}

306
src/WSRequestHandler_Sources.cpp
View File

@ -30,7 +30,7 @@
* @category sources
* @since 4.3.0
*/
void WSRequestHandler::HandleGetSourcesList(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetSourcesList(WSRequestHandler* req)
{
OBSDataArrayAutoRelease sourcesArray = obs_data_array_create();
@ -73,7 +73,7 @@ void WSRequestHandler::HandleGetSourcesList(WSRequestHandler* req)
OBSDataAutoRelease response = obs_data_create();
obs_data_set_array(response, "sources", sourcesArray);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -98,7 +98,7 @@ void WSRequestHandler::HandleGetSourcesList(WSRequestHandler* req)
* @category sources
* @since 4.3.0
*/
void WSRequestHandler::HandleGetSourceTypesList(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetSourceTypesList(WSRequestHandler* req)
{
OBSDataArrayAutoRelease idsArray = obs_data_array_create();
@ -151,7 +151,7 @@ void WSRequestHandler::HandleGetSourceTypesList(WSRequestHandler* req)
OBSDataAutoRelease response = obs_data_create();
obs_data_set_array(response, "types", idsArray);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -168,23 +168,20 @@ void WSRequestHandler::HandleGetSourceTypesList(WSRequestHandler* req)
* @category sources
* @since 4.0.0
*/
void WSRequestHandler::HandleGetVolume(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetVolume(WSRequestHandler* req)
{
if (!req->hasField("source")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString sourceName = obs_data_get_string(req->data, "source");
if (sourceName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.toUtf8());
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
OBSDataAutoRelease response = obs_data_create();
@ -192,7 +189,7 @@ void WSRequestHandler::HandleGetVolume(WSRequestHandler* req)
obs_data_set_double(response, "volume", obs_source_get_volume(source));
obs_data_set_bool(response, "muted", obs_source_muted(source));
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -206,30 +203,26 @@ void WSRequestHandler::HandleGetVolume(WSRequestHandler* req)
* @category sources
* @since 4.0.0
*/
void WSRequestHandler::HandleSetVolume(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleSetVolume(WSRequestHandler* req)
{
if (!req->hasField("source") || !req->hasField("volume"))
{
req->SendErrorResponse("missing request parameters");
return;
if (!req->hasField("source") || !req->hasField("volume")) {
return req->SendErrorResponse("missing request parameters");
}
QString sourceName = obs_data_get_string(req->data, "source");
float sourceVolume = obs_data_get_double(req->data, "volume");
if (sourceName.isEmpty() || sourceVolume < 0.0 || sourceVolume > 1.0) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.toUtf8());
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
obs_source_set_volume(source, sourceVolume);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -245,30 +238,27 @@ void WSRequestHandler::HandleGetVolume(WSRequestHandler* req)
* @category sources
* @since 4.0.0
*/
void WSRequestHandler::HandleGetMute(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetMute(WSRequestHandler* req)
{
if (!req->hasField("source")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString sourceName = obs_data_get_string(req->data, "source");
if (sourceName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.toUtf8());
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
OBSDataAutoRelease response = obs_data_create();
obs_data_set_string(response, "name", obs_source_get_name(source));
obs_data_set_bool(response, "muted", obs_source_muted(source));
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -282,29 +272,26 @@ void WSRequestHandler::HandleGetMute(WSRequestHandler* req)
* @category sources
* @since 4.0.0
*/
void WSRequestHandler::HandleSetMute(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleSetMute(WSRequestHandler* req)
{
if (!req->hasField("source") || !req->hasField("mute")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString sourceName = obs_data_get_string(req->data, "source");
bool mute = obs_data_get_bool(req->data, "mute");
if (sourceName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.toUtf8());
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
obs_source_set_muted(source, mute);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -317,27 +304,24 @@ void WSRequestHandler::HandleSetMute(WSRequestHandler* req)
* @category sources
* @since 4.0.0
*/
void WSRequestHandler::HandleToggleMute(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleToggleMute(WSRequestHandler* req)
{
if (!req->hasField("source")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString sourceName = obs_data_get_string(req->data, "source");
if (sourceName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.toUtf8());
if (!source) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
obs_source_set_muted(source, !obs_source_muted(source));
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -351,29 +335,26 @@ void WSRequestHandler::HandleToggleMute(WSRequestHandler* req)
* @category sources
* @since 4.2.0
*/
void WSRequestHandler::HandleSetSyncOffset(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleSetSyncOffset(WSRequestHandler* req)
{
if (!req->hasField("source") || !req->hasField("offset")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString sourceName = obs_data_get_string(req->data, "source");
int64_t sourceSyncOffset = (int64_t)obs_data_get_int(req->data, "offset");
if (sourceName.isEmpty() || sourceSyncOffset < 0) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.toUtf8());
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
obs_source_set_sync_offset(source, sourceSyncOffset);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -389,30 +370,27 @@ void WSRequestHandler::HandleSetSyncOffset(WSRequestHandler* req)
* @category sources
* @since 4.2.0
*/
void WSRequestHandler::HandleGetSyncOffset(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetSyncOffset(WSRequestHandler* req)
{
if (!req->hasField("source")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString sourceName = obs_data_get_string(req->data, "source");
if (sourceName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName.toUtf8());
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
OBSDataAutoRelease response = obs_data_create();
obs_data_set_string(response, "name", obs_source_get_name(source));
obs_data_set_int(response, "offset", obs_source_get_sync_offset(source));
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -430,18 +408,16 @@ void WSRequestHandler::HandleGetSyncOffset(WSRequestHandler* req)
* @category sources
* @since 4.3.0
*/
void WSRequestHandler::HandleGetSourceSettings(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetSourceSettings(WSRequestHandler* req)
{
if (!req->hasField("sourceName")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sourceName = obs_data_get_string(req->data, "sourceName");
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
if (req->hasField("sourceType")) {
@ -449,8 +425,7 @@ void WSRequestHandler::HandleGetSourceSettings(WSRequestHandler* req)
QString requestedType = obs_data_get_string(req->data, "sourceType");
if (actualSourceType != requestedType) {
req->SendErrorResponse("specified source exists but is not of expected type");
return;
return req->SendErrorResponse("specified source exists but is not of expected type");
}
}
@ -461,7 +436,7 @@ void WSRequestHandler::HandleGetSourceSettings(WSRequestHandler* req)
obs_data_set_string(response, "sourceType", obs_source_get_id(source));
obs_data_set_obj(response, "sourceSettings", sourceSettings);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -480,18 +455,16 @@ void WSRequestHandler::HandleGetSourceSettings(WSRequestHandler* req)
* @category sources
* @since 4.3.0
*/
void WSRequestHandler::HandleSetSourceSettings(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleSetSourceSettings(WSRequestHandler* req)
{
if (!req->hasField("sourceName") || !req->hasField("sourceSettings")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sourceName = obs_data_get_string(req->data, "sourceName");
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
if (req->hasField("sourceType")) {
@ -499,8 +472,7 @@ void WSRequestHandler::HandleSetSourceSettings(WSRequestHandler* req)
QString requestedType = obs_data_get_string(req->data, "sourceType");
if (actualSourceType != requestedType) {
req->SendErrorResponse("specified source exists but is not of expected type");
return;
return req->SendErrorResponse("specified source exists but is not of expected type");
}
}
@ -519,7 +491,7 @@ void WSRequestHandler::HandleSetSourceSettings(WSRequestHandler* req)
obs_data_set_string(response, "sourceType", obs_source_get_id(source));
obs_data_set_obj(response, "sourceSettings", sourceSettings);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -561,30 +533,27 @@ void WSRequestHandler::HandleSetSourceSettings(WSRequestHandler* req)
* @category sources
* @since 4.1.0
*/
void WSRequestHandler::HandleGetTextGDIPlusProperties(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetTextGDIPlusProperties(WSRequestHandler* req)
{
const char* sourceName = obs_data_get_string(req->data, "source");
if (!sourceName) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
QString sourceId = obs_source_get_id(source);
if (sourceId != "text_gdiplus") {
req->SendErrorResponse("not a text gdi plus source");
return;
return req->SendErrorResponse("not a text gdi plus source");
}
OBSDataAutoRelease response = obs_source_get_settings(source);
obs_data_set_string(response, "source", obs_source_get_name(source));
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -625,29 +594,25 @@ void WSRequestHandler::HandleSetSourceSettings(WSRequestHandler* req)
* @category sources
* @since 4.1.0
*/
void WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req)
{
if (!req->hasField("source")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sourceName = obs_data_get_string(req->data, "source");
if (!sourceName) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
QString sourceId = obs_source_get_id(source);
if (sourceId != "text_gdiplus") {
req->SendErrorResponse("not a text gdi plus source");
return;
return req->SendErrorResponse("not a text gdi plus source");
}
OBSDataAutoRelease settings = obs_source_get_settings(source);
@ -769,7 +734,7 @@ void WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req)
obs_source_update(source, settings);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -799,30 +764,27 @@ void WSRequestHandler::HandleSetTextGDIPlusProperties(WSRequestHandler* req)
* @category sources
* @since 4.5.0
*/
void WSRequestHandler::HandleGetTextFreetype2Properties(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetTextFreetype2Properties(WSRequestHandler* req)
{
const char* sourceName = obs_data_get_string(req->data, "source");
if (!sourceName) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
QString sourceId = obs_source_get_id(source);
if (sourceId != "text_ft2_source") {
req->SendErrorResponse("not a freetype 2 source");
return;
return req->SendErrorResponse("not a freetype 2 source");
}
OBSDataAutoRelease response = obs_source_get_settings(source);
obs_data_set_string(response, "source", sourceName);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -850,24 +812,21 @@ void WSRequestHandler::HandleGetTextFreetype2Properties(WSRequestHandler* req)
* @category sources
* @since 4.5.0
*/
void WSRequestHandler::HandleSetTextFreetype2Properties(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleSetTextFreetype2Properties(WSRequestHandler* req)
{
const char* sourceName = obs_data_get_string(req->data, "source");
if (!sourceName) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
QString sourceId = obs_source_get_id(source);
if (sourceId != "text_ft2_source") {
req->SendErrorResponse("not text freetype 2 source");
return;
return req->SendErrorResponse("not text freetype 2 source");
}
OBSDataAutoRelease settings = obs_source_get_settings(source);
@ -937,7 +896,7 @@ void WSRequestHandler::HandleSetTextFreetype2Properties(WSRequestHandler* req)
obs_source_update(source, settings);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -960,30 +919,27 @@ void WSRequestHandler::HandleSetTextFreetype2Properties(WSRequestHandler* req)
* @category sources
* @since 4.1.0
*/
void WSRequestHandler::HandleGetBrowserSourceProperties(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetBrowserSourceProperties(WSRequestHandler* req)
{
const char* sourceName = obs_data_get_string(req->data, "source");
if (!sourceName) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
QString sourceId = obs_source_get_id(source);
if (sourceId != "browser_source") {
req->SendErrorResponse("not a browser source");
return;
return req->SendErrorResponse("not a browser source");
}
OBSDataAutoRelease response = obs_source_get_settings(source);
obs_data_set_string(response, "source", obs_source_get_name(source));
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -1005,29 +961,25 @@ void WSRequestHandler::HandleGetBrowserSourceProperties(WSRequestHandler* req)
* @category sources
* @since 4.1.0
*/
void WSRequestHandler::HandleSetBrowserSourceProperties(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleSetBrowserSourceProperties(WSRequestHandler* req)
{
if (!req->hasField("source")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sourceName = obs_data_get_string(req->data, "source");
if (!sourceName) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
QString sourceId = obs_source_get_id(source);
if(sourceId != "browser_source") {
req->SendErrorResponse("not a browser source");
return;
return req->SendErrorResponse("not a browser source");
}
OBSDataAutoRelease settings = obs_source_get_settings(source);
@ -1070,7 +1022,7 @@ void WSRequestHandler::HandleSetBrowserSourceProperties(WSRequestHandler* req)
obs_source_update(source, settings);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -1087,7 +1039,7 @@ void WSRequestHandler::HandleSetBrowserSourceProperties(WSRequestHandler* req)
* @category sources
* @since 4.1.0
*/
void WSRequestHandler::HandleGetSpecialSources(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetSpecialSources(WSRequestHandler* req)
{
OBSDataAutoRelease response = obs_data_create();
@ -1109,7 +1061,7 @@ void WSRequestHandler::HandleSetBrowserSourceProperties(WSRequestHandler* req)
}
}
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -1127,18 +1079,16 @@ void WSRequestHandler::HandleSetBrowserSourceProperties(WSRequestHandler* req)
* @category sources
* @since 4.5.0
*/
void WSRequestHandler::HandleGetSourceFilters(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleGetSourceFilters(WSRequestHandler* req)
{
if (!req->hasField("sourceName")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sourceName = obs_data_get_string(req->data, "sourceName");
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
OBSDataArrayAutoRelease filters = obs_data_array_create();
@ -1154,7 +1104,7 @@ void WSRequestHandler::HandleGetSourceFilters(WSRequestHandler* req)
OBSDataAutoRelease response = obs_data_create();
obs_data_set_array(response, "filters", filters);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -1170,13 +1120,12 @@ void WSRequestHandler::HandleGetSourceFilters(WSRequestHandler* req)
* @category sources
* @since 4.5.0
*/
void WSRequestHandler::HandleAddFilterToSource(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleAddFilterToSource(WSRequestHandler* req)
{
if (!req->hasField("sourceName") || !req->hasField("filterName") ||
!req->hasField("filterType") || !req->hasField("filterSettings"))
{
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sourceName = obs_data_get_string(req->data, "sourceName");
@ -1186,29 +1135,25 @@ void WSRequestHandler::HandleAddFilterToSource(WSRequestHandler* req)
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
OBSSourceAutoRelease existingFilter = obs_source_get_filter_by_name(source, filterName);
if (existingFilter) {
req->SendErrorResponse("filter name already taken");
return;
return req->SendErrorResponse("filter name already taken");
}
OBSSourceAutoRelease filter = obs_source_create_private(filterType, filterName, filterSettings);
if (!filter) {
req->SendErrorResponse("filter creation failed");
return;
return req->SendErrorResponse("filter creation failed");
}
if (obs_source_get_type(filter) != OBS_SOURCE_TYPE_FILTER) {
req->SendErrorResponse("invalid filter type");
return;
return req->SendErrorResponse("invalid filter type");
}
obs_source_filter_add(source, filter);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -1222,11 +1167,10 @@ void WSRequestHandler::HandleAddFilterToSource(WSRequestHandler* req)
* @category sources
* @since 4.5.0
*/
void WSRequestHandler::HandleRemoveFilterFromSource(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleRemoveFilterFromSource(WSRequestHandler* req)
{
if (!req->hasField("sourceName") || !req->hasField("filterName")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sourceName = obs_data_get_string(req->data, "sourceName");
@ -1234,19 +1178,17 @@ void WSRequestHandler::HandleRemoveFilterFromSource(WSRequestHandler* req)
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
OBSSourceAutoRelease filter = obs_source_get_filter_by_name(source, filterName);
if (!filter) {
req->SendErrorResponse("specified filter doesn't exist");
return;
return req->SendErrorResponse("specified filter doesn't exist");
}
obs_source_filter_remove(source, filter);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -1261,11 +1203,10 @@ void WSRequestHandler::HandleRemoveFilterFromSource(WSRequestHandler* req)
* @category sources
* @since 4.5.0
*/
void WSRequestHandler::HandleReorderSourceFilter(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleReorderSourceFilter(WSRequestHandler* req)
{
if (!req->hasField("sourceName") || !req->hasField("filterName") || !req->hasField("newIndex")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sourceName = obs_data_get_string(req->data, "sourceName");
@ -1273,20 +1214,17 @@ void WSRequestHandler::HandleReorderSourceFilter(WSRequestHandler* req)
int newIndex = obs_data_get_int(req->data, "newIndex");
if (newIndex < 0) {
req->SendErrorResponse("invalid index");
return;
return req->SendErrorResponse("invalid index");
}
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
OBSSourceAutoRelease filter = obs_source_get_filter_by_name(source, filterName);
if (!filter) {
req->SendErrorResponse("specified filter doesn't exist");
return;
return req->SendErrorResponse("specified filter doesn't exist");
}
struct filterSearch {
@ -1306,8 +1244,7 @@ void WSRequestHandler::HandleReorderSourceFilter(WSRequestHandler* req)
int lastFilterIndex = ctx.i + 1;
if (newIndex > lastFilterIndex) {
req->SendErrorResponse("index out of bounds");
return;
return req->SendErrorResponse("index out of bounds");
}
int currentIndex = ctx.filterIndex;
@ -1324,7 +1261,7 @@ void WSRequestHandler::HandleReorderSourceFilter(WSRequestHandler* req)
}
}
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -1339,11 +1276,10 @@ void WSRequestHandler::HandleReorderSourceFilter(WSRequestHandler* req)
* @category sources
* @since 4.5.0
*/
void WSRequestHandler::HandleMoveSourceFilter(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleMoveSourceFilter(WSRequestHandler* req)
{
if (!req->hasField("sourceName") || !req->hasField("filterName") || !req->hasField("movementType")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sourceName = obs_data_get_string(req->data, "sourceName");
@ -1352,14 +1288,12 @@ void WSRequestHandler::HandleMoveSourceFilter(WSRequestHandler* req)
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
OBSSourceAutoRelease filter = obs_source_get_filter_by_name(source, filterName);
if (!filter) {
req->SendErrorResponse("specified filter doesn't exist");
return;
return req->SendErrorResponse("specified filter doesn't exist");
}
obs_order_movement movement;
@ -1376,13 +1310,12 @@ void WSRequestHandler::HandleMoveSourceFilter(WSRequestHandler* req)
movement = OBS_ORDER_MOVE_BOTTOM;
}
else {
req->SendErrorResponse("invalid value for movementType: must be either 'up', 'down', 'top' or 'bottom'.");
return;
return req->SendErrorResponse("invalid value for movementType: must be either 'up', 'down', 'top' or 'bottom'.");
}
obs_source_filter_set_order(source, filter, movement);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -1397,11 +1330,10 @@ void WSRequestHandler::HandleMoveSourceFilter(WSRequestHandler* req)
* @category sources
* @since 4.5.0
*/
void WSRequestHandler::HandleSetSourceFilterSettings(WSRequestHandler* req)
HandlerResponse WSRequestHandler::HandleSetSourceFilterSettings(WSRequestHandler* req)
{
if (!req->hasField("sourceName") || !req->hasField("filterName") || !req->hasField("filterSettings")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* sourceName = obs_data_get_string(req->data, "sourceName");
@ -1410,19 +1342,17 @@ void WSRequestHandler::HandleSetSourceFilterSettings(WSRequestHandler* req)
OBSSourceAutoRelease source = obs_get_source_by_name(sourceName);
if (!source) {
req->SendErrorResponse("specified source doesn't exist");
return;
return req->SendErrorResponse("specified source doesn't exist");
}
OBSSourceAutoRelease filter = obs_source_get_filter_by_name(source, filterName);
if (!filter) {
req->SendErrorResponse("specified filter doesn't exist");
return;
return req->SendErrorResponse("specified filter doesn't exist");
}
OBSDataAutoRelease settings = obs_source_get_settings(filter);
obs_data_apply(settings, newFilterSettings);
obs_source_update(filter, settings);
req->SendOKResponse();
return req->SendOKResponse();
}

37
src/WSRequestHandler_Streaming.cpp
View File

@ -20,7 +20,7 @@
* @category streaming
* @since 0.3
*/
void WSRequestHandler::HandleGetStreamingStatus(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetStreamingStatus(WSRequestHandler* req) {
auto events = WSEvents::Current();
OBSDataAutoRelease data = obs_data_create();
@ -41,7 +41,7 @@
bfree((void*)tc);
}
req->SendOKResponse(data);
return req->SendOKResponse(data);
}
/**
@ -52,11 +52,11 @@
* @category streaming
* @since 0.3
*/
void WSRequestHandler::HandleStartStopStreaming(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleStartStopStreaming(WSRequestHandler* req) {
if (obs_frontend_streaming_active())
HandleStopStreaming(req);
return HandleStopStreaming(req);
else
HandleStartStreaming(req);
return HandleStartStreaming(req);
}
/**
@ -78,7 +78,7 @@
* @category streaming
* @since 4.1.0
*/
void WSRequestHandler::HandleStartStreaming(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleStartStreaming(WSRequestHandler* req) {
if (obs_frontend_streaming_active() == false) {
OBSService configuredService = obs_frontend_get_streaming_service();
OBSService newService = nullptr;
@ -159,9 +159,9 @@
obs_frontend_set_streaming_service(configuredService);
}
req->SendOKResponse();
return req->SendOKResponse();
} else {
req->SendErrorResponse("streaming already active");
return req->SendErrorResponse("streaming already active");
}
}
@ -174,12 +174,12 @@
* @category streaming
* @since 4.1.0
*/
void WSRequestHandler::HandleStopStreaming(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleStopStreaming(WSRequestHandler* req) {
if (obs_frontend_streaming_active() == true) {
obs_frontend_streaming_stop();
req->SendOKResponse();
return req->SendOKResponse();
} else {
req->SendErrorResponse("streaming not active");
return req->SendErrorResponse("streaming not active");
}
}
@ -200,13 +200,12 @@ void WSRequestHandler::HandleStopStreaming(WSRequestHandler* req) {
* @category streaming
* @since 4.1.0
*/
void WSRequestHandler::HandleSetStreamSettings(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetStreamSettings(WSRequestHandler* req) {
OBSService service = obs_frontend_get_streaming_service();
OBSDataAutoRelease requestSettings = obs_data_get_obj(req->data, "settings");
if (!requestSettings) {
req->SendErrorResponse("'settings' are required'");
return;
return req->SendErrorResponse("'settings' are required'");
}
QString serviceType = obs_service_get_type(service);
@ -244,7 +243,7 @@ void WSRequestHandler::HandleStopStreaming(WSRequestHandler* req) {
obs_data_set_string(response, "type", requestedType.toUtf8());
obs_data_set_obj(response, "settings", serviceSettings);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -263,7 +262,7 @@ void WSRequestHandler::HandleStopStreaming(WSRequestHandler* req) {
* @category streaming
* @since 4.1.0
*/
void WSRequestHandler::HandleGetStreamSettings(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetStreamSettings(WSRequestHandler* req) {
OBSService service = obs_frontend_get_streaming_service();
const char* serviceType = obs_service_get_type(service);
@ -273,7 +272,7 @@ void WSRequestHandler::HandleGetStreamSettings(WSRequestHandler* req) {
obs_data_set_string(response, "type", serviceType);
obs_data_set_obj(response, "settings", settings);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -284,7 +283,7 @@ void WSRequestHandler::HandleGetStreamSettings(WSRequestHandler* req) {
* @category streaming
* @since 4.1.0
*/
void WSRequestHandler::HandleSaveStreamSettings(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSaveStreamSettings(WSRequestHandler* req) {
obs_frontend_save_streaming_service();
req->SendOKResponse();
return req->SendOKResponse();
}

55
src/WSRequestHandler_StudioMode.cpp
View File

@ -13,13 +13,13 @@
* @category studio mode
* @since 4.1.0
*/
void WSRequestHandler::HandleGetStudioModeStatus(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetStudioModeStatus(WSRequestHandler* req) {
bool previewActive = obs_frontend_preview_program_mode_active();
OBSDataAutoRelease response = obs_data_create();
obs_data_set_bool(response, "studio-mode", previewActive);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -34,10 +34,9 @@
* @category studio mode
* @since 4.1.0
*/
void WSRequestHandler::HandleGetPreviewScene(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetPreviewScene(WSRequestHandler* req) {
if (!obs_frontend_preview_program_mode_active()) {
req->SendErrorResponse("studio mode not enabled");
return;
return req->SendErrorResponse("studio mode not enabled");
}
OBSSourceAutoRelease scene = obs_frontend_get_current_preview_scene();
@ -47,7 +46,7 @@ void WSRequestHandler::HandleGetPreviewScene(WSRequestHandler* req) {
obs_data_set_string(data, "name", obs_source_get_name(scene));
obs_data_set_array(data, "sources", sceneItems);
req->SendOKResponse(data);
return req->SendOKResponse(data);
}
/**
@ -61,26 +60,23 @@ void WSRequestHandler::HandleGetPreviewScene(WSRequestHandler* req) {
* @category studio mode
* @since 4.1.0
*/
void WSRequestHandler::HandleSetPreviewScene(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetPreviewScene(WSRequestHandler* req) {
if (!obs_frontend_preview_program_mode_active()) {
req->SendErrorResponse("studio mode not enabled");
return;
return req->SendErrorResponse("studio mode not enabled");
}
if (!req->hasField("scene-name")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
const char* scene_name = obs_data_get_string(req->data, "scene-name");
OBSSourceAutoRelease scene = Utils::GetSceneFromNameOrCurrent(scene_name);
if (scene) {
obs_frontend_set_current_preview_scene(scene);
req->SendOKResponse();
} else {
req->SendErrorResponse("specified scene doesn't exist");
if (!scene) {
return req->SendErrorResponse("specified scene doesn't exist");
}
obs_frontend_set_current_preview_scene(scene);
return req->SendOKResponse();
}
/**
@ -96,10 +92,9 @@ void WSRequestHandler::HandleSetPreviewScene(WSRequestHandler* req) {
* @category studio mode
* @since 4.1.0
*/
void WSRequestHandler::HandleTransitionToProgram(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleTransitionToProgram(WSRequestHandler* req) {
if (!obs_frontend_preview_program_mode_active()) {
req->SendErrorResponse("studio mode not enabled");
return;
return req->SendErrorResponse("studio mode not enabled");
}
if (req->hasField("with-transition")) {
@ -110,14 +105,12 @@ void WSRequestHandler::HandleTransitionToProgram(WSRequestHandler* req) {
QString transitionName =
obs_data_get_string(transitionInfo, "name");
if (transitionName.isEmpty()) {
req->SendErrorResponse("invalid request parameters");
return;
return req->SendErrorResponse("invalid request parameters");
}
bool success = Utils::SetTransitionByName(transitionName);
if (!success) {
req->SendErrorResponse("specified transition doesn't exist");
return;
return req->SendErrorResponse("specified transition doesn't exist");
}
}
@ -129,7 +122,7 @@ void WSRequestHandler::HandleTransitionToProgram(WSRequestHandler* req) {
}
Utils::TransitionToProgram();
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -140,9 +133,9 @@ void WSRequestHandler::HandleTransitionToProgram(WSRequestHandler* req) {
* @category studio mode
* @since 4.1.0
*/
void WSRequestHandler::HandleEnableStudioMode(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleEnableStudioMode(WSRequestHandler* req) {
obs_frontend_set_preview_program_mode(true);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -153,9 +146,9 @@ void WSRequestHandler::HandleEnableStudioMode(WSRequestHandler* req) {
* @category studio mode
* @since 4.1.0
*/
void WSRequestHandler::HandleDisableStudioMode(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleDisableStudioMode(WSRequestHandler* req) {
obs_frontend_set_preview_program_mode(false);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -166,8 +159,8 @@ void WSRequestHandler::HandleDisableStudioMode(WSRequestHandler* req) {
* @category studio mode
* @since 4.1.0
*/
void WSRequestHandler::HandleToggleStudioMode(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleToggleStudioMode(WSRequestHandler* req) {
bool previewProgramMode = obs_frontend_preview_program_mode_active();
obs_frontend_set_preview_program_mode(!previewProgramMode);
req->SendOKResponse();
return req->SendOKResponse();
}

37
src/WSRequestHandler_Transitions.cpp
View File

@ -15,7 +15,7 @@
* @category transitions
* @since 4.1.0
*/
void WSRequestHandler::HandleGetTransitionList(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetTransitionList(WSRequestHandler* req) {
OBSSourceAutoRelease currentTransition = obs_frontend_get_current_transition();
obs_frontend_source_list transitionList = {};
obs_frontend_get_transitions(&transitionList);
@ -35,7 +35,7 @@
obs_source_get_name(currentTransition));
obs_data_set_array(response, "transitions", transitions);
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -49,7 +49,7 @@
* @category transitions
* @since 0.3
*/
void WSRequestHandler::HandleGetCurrentTransition(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetCurrentTransition(WSRequestHandler* req) {
OBSSourceAutoRelease currentTransition = obs_frontend_get_current_transition();
OBSDataAutoRelease response = obs_data_create();
@ -59,7 +59,7 @@ void WSRequestHandler::HandleGetCurrentTransition(WSRequestHandler* req) {
if (!obs_transition_fixed(currentTransition))
obs_data_set_int(response, "duration", Utils::GetTransitionDuration());
req->SendOKResponse(response);
return req->SendOKResponse(response);
}
/**
@ -72,18 +72,18 @@ void WSRequestHandler::HandleGetCurrentTransition(WSRequestHandler* req) {
* @category transitions
* @since 0.3
*/
void WSRequestHandler::HandleSetCurrentTransition(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetCurrentTransition(WSRequestHandler* req) {
if (!req->hasField("transition-name")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
QString name = obs_data_get_string(req->data, "transition-name");
bool success = Utils::SetTransitionByName(name);
if (success)
req->SendOKResponse();
else
req->SendErrorResponse("requested transition does not exist");
if (!success) {
return req->SendErrorResponse("requested transition does not exist");
}
return req->SendOKResponse();
}
/**
@ -96,15 +96,14 @@ void WSRequestHandler::HandleSetCurrentTransition(WSRequestHandler* req) {
* @category transitions
* @since 4.0.0
*/
void WSRequestHandler::HandleSetTransitionDuration(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleSetTransitionDuration(WSRequestHandler* req) {
if (!req->hasField("duration")) {
req->SendErrorResponse("missing request parameters");
return;
return req->SendErrorResponse("missing request parameters");
}
int ms = obs_data_get_int(req->data, "duration");
Utils::SetTransitionDuration(ms);
req->SendOKResponse();
return req->SendOKResponse();
}
/**
@ -117,10 +116,8 @@ void WSRequestHandler::HandleSetTransitionDuration(WSRequestHandler* req) {
* @category transitions
* @since 4.1.0
*/
void WSRequestHandler::HandleGetTransitionDuration(WSRequestHandler* req) {
HandlerResponse WSRequestHandler::HandleGetTransitionDuration(WSRequestHandler* req) {
OBSDataAutoRelease response = obs_data_create();
obs_data_set_int(response, "transition-duration",
Utils::GetTransitionDuration());
req->SendOKResponse(response);
obs_data_set_int(response, "transition-duration", Utils::GetTransitionDuration());
return req->SendOKResponse(response);
}

8
src/WSServer.cpp
View File

@ -139,7 +139,13 @@ void WSServer::onMessage(connection_hdl hdl, server::message_ptr message)
locker.unlock();
WSRequestHandler handler(connProperties);
std::string response = handler.processIncomingMessage(payload);
OBSDataAutoRelease responseData = handler.processIncomingMessage(payload);
std::string response = obs_data_get_json(responseData);
if (Config::Current()->DebugEnabled) {
blog(LOG_DEBUG, "Response << '%s'", response.c_str());
}
_server.send(hdl, response, websocketpp::frame::opcode::text);