Method AddEventSubscription

plugins/twitch/event-sub.cpp:244–331

}

std::string EventSub::AddEventSubscription(std::shared_ptr<TwitchToken> token,
					   Subscription subscription)
{
	auto eventSub = token->GetEventSub();
	if (!eventSub) {
		blog(LOG_WARNING, "failed to get Twitch EventSub from token!");
		return "";
	}

	std::unique_lock<std::mutex> lock(eventSub->_subscriptionMtx);
	if (!eventSub->_connected) {
		if (eventSub->_reconnecting) {
			return "";
		}

		vblog(LOG_INFO,
		      "new Twitch EventSub connect attempt started for %s",
		      token->GetName().c_str());
		lock.unlock();
		eventSub->Connect();
		return "";
	}

	if (isAlreadySubscribed(eventSub->_activeSubscriptions, subscription)) {
		eventSub->LogActiveSubscriptions();
		return eventSub->_activeSubscriptions.find(subscription)->id;
	}

	if (!eventSub->IsValidID(eventSub->_sessionID)) {
		vblog(LOG_INFO,
		      "session ID of Twitch event sub invalid - skip %s",
		      __func__);
		return "";
	}

	// Capture the session ID and release the lock before making the HTTP
	// request. Holding the mutex during a network call would block
	// SubscriptionIsActive() on the condition-check thread for the entire
	// duration of the request, causing visibly slow macro evaluations.
	const std::string sessionID = eventSub->_sessionID;
	lock.unlock();

	OBSDataAutoRelease postData = copyData(subscription.data);
	setTransportData(postData.Get(), sessionID);
	auto result = SendPostRequest(*token, registerSubscriptionURL.data(),
				      registerSubscriptionPath.data(), {},
				      postData.Get());

	lock.lock();

	if (result.status != 202) {
		const char *error = obs_data_get_string(result.data, "error");
		const char *message =
			obs_data_get_string(result.data, "message");
		vblog(LOG_INFO,
		      "failed to register Twitch EventSub (%d): %s - %s",
		      result.status, error ? error : "no error",
		      message ? message : "no message");