Add function to call websocket request from JavaScript

Author: exeldro

README.md

@@ -315,6 +315,31 @@ Permissions required: ALL
 window.obsstudio.stopVirtualcam()
 ```
 
+#### Call Websocket request
+Permissions required: ALL
+```js
+/**
+ * @typedef {Object} WebsocketResponse
+ * @property {number} code - RequestStatus code
+ * @property {bool} result - is true if the request resulted in Success. False if otherwise.
+ * @property {string} responseData - JSON string containing response data
+ * @property {string} comment - may be provided by the server on errors to offer further details on why a request failed.
+ */
+
+/**
+ * @callback WebsocketRequestCallback
+ * @param {WebsocketResponse} response
+ */
+
+/**
+ * @param {WebsocketRequestCallback} cb
+ * @param {string} request_type - The request type to call
+ * @param {string} request_data - JSON string containing appropriate request data
+ */
+window.obsstudio.websocketRequest(function (response_data) {
+    console.log(JSON.stringify(response))
+}, request_type, request_data)
+```
 
 ### Register for visibility callbacks
 

browser-app.cpp

@@ -99,13 +99,13 @@ void BrowserApp::OnBeforeCommandLineProcessing(const CefString &, CefRefPtr<CefC
 #endif
 }
 
-std::vector<std::string> exposedFunctions = {"getControlLevel",     "getCurrentScene",  "getStatus",
-					     "startRecording",      "stopRecording",    "startStreaming",
-					     "stopStreaming",       "pauseRecording",   "unpauseRecording",
-					     "startReplayBuffer",   "stopReplayBuffer", "saveReplayBuffer",
-					     "startVirtualcam",     "stopVirtualcam",   "getScenes",
-					     "setCurrentScene",     "getTransitions",   "getCurrentTransition",
-					     "setCurrentTransition"};
+std::vector<std::string> exposedFunctions = {"getControlLevel",      "getCurrentScene",  "getStatus",
+					     "startRecording",       "stopRecording",    "startStreaming",
+					     "stopStreaming",        "pauseRecording",   "unpauseRecording",
+					     "startReplayBuffer",    "stopReplayBuffer", "saveReplayBuffer",
+					     "startVirtualcam",      "stopVirtualcam",   "getScenes",
+					     "setCurrentScene",      "getTransitions",   "getCurrentTransition",
+					     "setCurrentTransition", "websocketRequest"};
 
 void BrowserApp::OnContextCreated(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame>, CefRefPtr<CefV8Context> context)
 {

browser-client.cpp

@@ -19,6 +19,7 @@
 #include "browser-client.hpp"
 #include "obs-browser-source.hpp"
 #include "base64/base64.hpp"
+#include "obs-websocket-api.h"
 #include <nlohmann/json.hpp>
 #include <obs-frontend-api.h>
 #include <obs.hpp>
@@ -153,6 +154,24 @@ bool BrowserClient::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser, CefR
 			obs_frontend_start_virtualcam();
 		} else if (name == "stopVirtualcam") {
 			obs_frontend_stop_virtualcam();
+		} else if (name == "websocketRequest") {
+			std::string request_type = input_args->GetString(1).ToString();
+			std::string request_data_string = input_args->GetString(2).ToString();
+			OBSDataAutoRelease request_data = obs_data_create_from_json(request_data_string.c_str());
+			struct obs_websocket_request_response *response =
+				obs_websocket_call_request(request_type.c_str(), request_data);
+			if (response) {
+				json = {{"code", response->status_code}, {"result", response->status_code == 100}};
+				if (response->response_data)
+					json["responseData"] = response->response_data;
+				if (response->comment)
+					json["comment"] = response->comment;
+				obs_websocket_request_response_free(response);
+			} else {
+				json = {{"code", 205}, // GenericError
+					{"result", false},
+					{"comment", "Unable to call obs-websocket request"}};
+			}
 		}
 		[[fallthrough]];
 	case ControlLevel::Advanced:

obs-websocket-api.h

@@ -0,0 +1,266 @@
+/*
+obs-websocket
+Copyright (C) 2016-2021 Stephane Lepin <[email protected]>
+Copyright (C) 2020-2022 Kyle Manning <[email protected]>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program. If not, see <https://www.gnu.org/licenses/>
+*/
+
+#ifndef _OBS_WEBSOCKET_API_H
+#define _OBS_WEBSOCKET_API_H
+
+#include <obs.h>
+
+#define OBS_WEBSOCKET_API_VERSION 3
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *obs_websocket_vendor;
+typedef void (*obs_websocket_request_callback_function)(obs_data_t *, obs_data_t *, void *);
+typedef void (*obs_websocket_event_callback_function)(uint64_t, const char *, const char *, void *);
+
+struct obs_websocket_request_response {
+	unsigned int status_code;
+	char *comment;
+	char *response_data; // JSON string, because obs_data_t* only supports array<object>, so conversions would break API.
+};
+
+/* ==================== INTERNAL DEFINITIONS ==================== */
+
+struct obs_websocket_request_callback {
+	obs_websocket_request_callback_function callback;
+	void *priv_data;
+};
+
+struct obs_websocket_event_callback {
+	obs_websocket_event_callback_function callback;
+	void *priv_data;
+};
+
+static proc_handler_t *_ph;
+
+/* ==================== INTERNAL API FUNCTIONS ==================== */
+
+static inline proc_handler_t *obs_websocket_get_ph(void)
+{
+	proc_handler_t *global_ph = obs_get_proc_handler();
+	assert(global_ph != NULL);
+
+	calldata_t cd = {0, 0, 0, 0};
+	if (!proc_handler_call(global_ph, "obs_websocket_api_get_ph", &cd))
+		blog(LOG_DEBUG, "Unable to fetch obs-websocket proc handler object. obs-websocket not installed?");
+	proc_handler_t *ret = (proc_handler_t *)calldata_ptr(&cd, "ph");
+	calldata_free(&cd);
+
+	return ret;
+}
+
+static inline bool obs_websocket_ensure_ph(void)
+{
+	if (!_ph)
+		_ph = obs_websocket_get_ph();
+	return _ph != NULL;
+}
+
+static inline bool obs_websocket_vendor_run_simple_proc(obs_websocket_vendor vendor, const char *proc_name,
+							calldata_t *cd)
+{
+	if (!obs_websocket_ensure_ph())
+		return false;
+
+	if (!vendor || !proc_name || !strlen(proc_name) || !cd)
+		return false;
+
+	calldata_set_ptr(cd, "vendor", vendor);
+
+	proc_handler_call(_ph, proc_name, cd);
+	return calldata_bool(cd, "success");
+}
+
+/* ==================== GENERAL API FUNCTIONS ==================== */
+
+// Gets the API version built with the obs-websocket plugin
+static inline unsigned int obs_websocket_get_api_version(void)
+{
+	if (!obs_websocket_ensure_ph())
+		return 0;
+
+	calldata_t cd = {0, 0, 0, 0};
+
+	if (!proc_handler_call(_ph, "get_api_version", &cd))
+		return 1; // API v1 does not include get_api_version
+
+	unsigned int ret = (unsigned int)calldata_int(&cd, "version");
+
+	calldata_free(&cd);
+
+	return ret;
+}
+
+// Calls an obs-websocket request. Free response with `obs_websocket_request_response_free()`
+static inline struct obs_websocket_request_response *obs_websocket_call_request(const char *request_type,
+										obs_data_t *request_data
+#ifdef __cplusplus
+										= NULL
+#endif
+)
+{
+	if (!obs_websocket_ensure_ph())
+		return NULL;
+
+	const char *request_data_string = NULL;
+	if (request_data)
+		request_data_string = obs_data_get_json(request_data);
+
+	calldata_t cd = {0, 0, 0, 0};
+	calldata_set_string(&cd, "request_type", request_type);
+	calldata_set_string(&cd, "request_data", request_data_string);
+
+	proc_handler_call(_ph, "call_request", &cd);
+
+	struct obs_websocket_request_response *ret =
+		(struct obs_websocket_request_response *)calldata_ptr(&cd, "response");
+
+	calldata_free(&cd);
+
+	return ret;
+}
+
+// Free a request response object returned by `obs_websocket_call_request()`
+static inline void obs_websocket_request_response_free(struct obs_websocket_request_response *response)
+{
+	if (!response)
+		return;
+
+	if (response->comment)
+		bfree(response->comment);
+	if (response->response_data)
+		bfree(response->response_data);
+	bfree(response);
+}
+
+// Register an event handler to receive obs-websocket events
+static inline bool obs_websocket_register_event_callback(obs_websocket_event_callback_function event_callback,
+							 void *priv_data)
+{
+	if (!obs_websocket_ensure_ph())
+		return false;
+
+	struct obs_websocket_event_callback cb = {event_callback, priv_data};
+
+	calldata_t cd = {0, 0, 0, 0};
+	calldata_set_ptr(&cd, "callback", &cb);
+
+	proc_handler_call(_ph, "register_event_callback", &cd);
+
+	bool ret = calldata_bool(&cd, "success");
+
+	calldata_free(&cd);
+
+	return ret;
+}
+
+// Unregister an existing event handler
+static inline bool obs_websocket_unregister_event_callback(obs_websocket_event_callback_function event_callback,
+							   void *priv_data)
+{
+	if (!obs_websocket_ensure_ph())
+		return false;
+
+	struct obs_websocket_event_callback cb = {event_callback, priv_data};
+
+	calldata_t cd = {0, 0, 0, 0};
+	calldata_set_ptr(&cd, "callback", &cb);
+
+	proc_handler_call(_ph, "unregister_event_callback", &cd);
+
+	bool ret = calldata_bool(&cd, "success");
+
+	calldata_free(&cd);
+
+	return ret;
+}
+
+/* ==================== VENDOR API FUNCTIONS ==================== */
+
+// ALWAYS CALL ONLY VIA `obs_module_post_load()` CALLBACK!
+// Registers a new "vendor" (Example: obs-ndi)
+static inline obs_websocket_vendor obs_websocket_register_vendor(const char *vendor_name)
+{
+	if (!obs_websocket_ensure_ph())
+		return NULL;
+
+	calldata_t cd = {0, 0, 0, 0};
+	calldata_set_string(&cd, "name", vendor_name);
+
+	proc_handler_call(_ph, "vendor_register", &cd);
+	obs_websocket_vendor ret = calldata_ptr(&cd, "vendor");
+	calldata_free(&cd);
+
+	return ret;
+}
+
+// Registers a new request for a vendor
+static inline bool obs_websocket_vendor_register_request(obs_websocket_vendor vendor, const char *request_type,
+							 obs_websocket_request_callback_function request_callback,
+							 void *priv_data)
+{
+	struct obs_websocket_request_callback cb = {request_callback, priv_data};
+
+	calldata_t cd = {0, 0, 0, 0};
+	calldata_set_string(&cd, "type", request_type);
+	calldata_set_ptr(&cd, "callback", &cb);
+
+	bool success = obs_websocket_vendor_run_simple_proc(vendor, "vendor_request_register", &cd);
+	calldata_free(&cd);
+
+	return success;
+}
+
+// Unregisters an existing vendor request
+static inline bool obs_websocket_vendor_unregister_request(obs_websocket_vendor vendor, const char *request_type)
+{
+	calldata_t cd = {0, 0, 0, 0};
+	calldata_set_string(&cd, "type", request_type);
+
+	bool success = obs_websocket_vendor_run_simple_proc(vendor, "vendor_request_unregister", &cd);
+	calldata_free(&cd);
+
+	return success;
+}
+
+// Does not affect event_data refcount.
+// Emits an event under the vendor's name
+static inline bool obs_websocket_vendor_emit_event(obs_websocket_vendor vendor, const char *event_name,
+						   obs_data_t *event_data)
+{
+	calldata_t cd = {0, 0, 0, 0};
+	calldata_set_string(&cd, "type", event_name);
+	calldata_set_ptr(&cd, "data", (void *)event_data);
+
+	bool success = obs_websocket_vendor_run_simple_proc(vendor, "vendor_event_emit", &cd);
+	calldata_free(&cd);
+
+	return success;
+}
+
+/* ==================== END API FUNCTIONS ==================== */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif