Add YouTube condition

Check broadcast:

* Health
* Status
This commit is contained in:
WarmUpTill
2026-11-09 19:54:02 +01:00
parent 3bdf4ace3b
commit 7db1cbb3a8
4 changed files with 426 additions and 0 deletions

View File

@@ -882,6 +882,18 @@ AdvSceneSwitcher.condition.twitch.entry="Channel{{channel}}{{conditions}}{{point
AdvSceneSwitcher.condition.twitch.entry.account="Check using account{{account}}"
AdvSceneSwitcher.condition.twitch.tokenPermissionsInsufficient="Permissions of selected token are insufficient to perform selected action!"
AdvSceneSwitcher.condition.twitch.title.title="Enter title"
AdvSceneSwitcher.condition.youtube="YouTube"
AdvSceneSwitcher.condition.youtube.type.broadcastStatus="Broadcast status is"
AdvSceneSwitcher.condition.youtube.type.streamHealth="Stream health is"
AdvSceneSwitcher.condition.youtube.layout="On{{connection}}{{conditions}}{{broadcastStatus}}{{streamHealth}}"
AdvSceneSwitcher.condition.youtube.broadcastStatus.ready="Ready"
AdvSceneSwitcher.condition.youtube.broadcastStatus.testing="Testing"
AdvSceneSwitcher.condition.youtube.broadcastStatus.live="Live"
AdvSceneSwitcher.condition.youtube.broadcastStatus.complete="Complete"
AdvSceneSwitcher.condition.youtube.streamHealth.good="Good"
AdvSceneSwitcher.condition.youtube.streamHealth.ok="OK"
AdvSceneSwitcher.condition.youtube.streamHealth.bad="Bad"
AdvSceneSwitcher.condition.youtube.streamHealth.noData="No data"
AdvSceneSwitcher.condition.queue="Queue"
AdvSceneSwitcher.condition.queue.type.started="Started"
AdvSceneSwitcher.condition.queue.type.stopped="Stopped"
@@ -1955,6 +1967,7 @@ AdvSceneSwitcher.twitchToken.validateTimestamps.tooltip="Verifies that incoming
AdvSceneSwitcher.twitchToken.warnIfInvalid="Display warning if the token expired or is invalid."
AdvSceneSwitcher.twitchToken.warnIfInvalid.doNotShowAgain="Don't show again for this connection"
AdvSceneSwitcher.twitchToken.warnIfInvalid.message="The Twitch connection \"%1\" is invalid.\nOpen connection settings or ignore?"
AdvSceneSwitcher.youtubeConnection.select="--select YouTube connection--"
AdvSceneSwitcher.youtubeConnection.add="Add new connection"
AdvSceneSwitcher.youtubeConnection.nameNotAvailable="Channel already in use"
@@ -2518,8 +2531,12 @@ AdvSceneSwitcher.tempVar.twitch.last_ad_at.ads="Last ad time"
AdvSceneSwitcher.tempVar.twitch.last_ad_at.ads.description="The UTC timestamp of the channel's last ad break, in RFC3339 format."
AdvSceneSwitcher.tempVar.twitch.preroll_free_time.ads="Pre-roll free time"
AdvSceneSwitcher.tempVar.twitch.preroll_free_time.ads.description="The amount of time in seconds the broadcaster must wait before running another commercial."
AdvSceneSwitcher.tempVar.youtube.id="Broadcast ID"
AdvSceneSwitcher.tempVar.youtube.title="Broadcast title"
AdvSceneSwitcher.tempVar.youtube.broadcastStatus="Broadcast status"
AdvSceneSwitcher.tempVar.youtube.streamHealth="Stream health"
AdvSceneSwitcher.tempVar.youtube.streamHealth.description="Only set when checking the stream health."
AdvSceneSwitcher.tempVar.audio.output_volume="Output volume"
AdvSceneSwitcher.tempVar.audio.output_volume.description="The volume the audio source is outputting."

View File

@@ -62,6 +62,8 @@ target_sources(
broadcast-selection.hpp
macro-action-youtube.cpp
macro-action-youtube.hpp
macro-condition-youtube.cpp
macro-condition-youtube.hpp
youtube-connection.cpp
youtube-connection.hpp
youtube-helpers.cpp

View File

@@ -0,0 +1,321 @@
#include "macro-condition-youtube.hpp"
#include "youtube-helpers.hpp"
#include <layout-helpers.hpp>
#include <sync-helpers.hpp>
#include <QHBoxLayout>
#include <QVBoxLayout>
namespace advss {
const std::string MacroConditionYouTube::id = "youtube";
bool MacroConditionYouTube::_registered = MacroConditionFactory::Register(
MacroConditionYouTube::id,
{MacroConditionYouTube::Create, MacroConditionYouTubeEdit::Create,
"AdvSceneSwitcher.condition.youtube"});
const static std::map<MacroConditionYouTube::Condition, std::string>
conditionTypes = {
{MacroConditionYouTube::Condition::BROADCAST_STATUS,
"AdvSceneSwitcher.condition.youtube.type.broadcastStatus"},
{MacroConditionYouTube::Condition::STREAM_HEALTH,
"AdvSceneSwitcher.condition.youtube.type.streamHealth"},
};
// The values are the ones used by the YouTube Data API
const static std::vector<std::pair<std::string, std::string>>
broadcastStatuses = {
{"ready",
"AdvSceneSwitcher.condition.youtube.broadcastStatus.ready"},
{"testing",
"AdvSceneSwitcher.condition.youtube.broadcastStatus.testing"},
{"live",
"AdvSceneSwitcher.condition.youtube.broadcastStatus.live"},
{"complete",
"AdvSceneSwitcher.condition.youtube.broadcastStatus.complete"},
};
const static std::vector<std::pair<std::string, std::string>> streamHealths = {
{"good", "AdvSceneSwitcher.condition.youtube.streamHealth.good"},
{"ok", "AdvSceneSwitcher.condition.youtube.streamHealth.ok"},
{"bad", "AdvSceneSwitcher.condition.youtube.streamHealth.bad"},
{"noData", "AdvSceneSwitcher.condition.youtube.streamHealth.noData"},
};
static std::string getStreamHealth(YouTubeConnection &connection,
const std::string &streamId)
{
if (streamId.empty()) {
return "";
}
const auto result = SendYouTubeRequest(
connection, YouTubeRequestMethod::GET, "/liveStreams",
{{"part", "status"}, {"id", streamId}}, "", true);
OBSDataArrayAutoRelease items =
obs_data_get_array(result.data, "items");
OBSDataAutoRelease item = obs_data_array_item(items, 0);
OBSDataAutoRelease status = obs_data_get_obj(item, "status");
OBSDataAutoRelease healthStatus =
obs_data_get_obj(status, "healthStatus");
return obs_data_get_string(healthStatus, "status");
}
bool MacroConditionYouTube::CheckCondition()
{
auto connection = _connection.lock();
if (!connection) {
return false;
}
const auto condition = _condition;
const auto broadcastSelection = _broadcast;
std::optional<YouTubeBroadcastInfo> broadcast;
std::string streamHealth;
{
SuspendLock suspendLock(static_cast<MacroCondition &>(*this));
broadcast = broadcastSelection.GetInfo(*connection, true);
if (broadcast && condition == Condition::STREAM_HEALTH) {
streamHealth = getStreamHealth(
*connection, broadcast->boundStreamId);
}
}
if (!broadcast) {
return false;
}
SetTempVarValue("id", broadcast->id);
SetTempVarValue("title", broadcast->title);
SetTempVarValue("broadcastStatus", broadcast->lifeCycleStatus);
SetTempVarValue("streamHealth", streamHealth);
switch (condition) {
case Condition::BROADCAST_STATUS:
return broadcast->lifeCycleStatus == _broadcastStatus;
case Condition::STREAM_HEALTH:
return streamHealth == _streamHealth;
}
return false;
}
bool MacroConditionYouTube::Save(obs_data_t *obj) const
{
MacroCondition::Save(obj);
obs_data_set_int(obj, "condition", static_cast<int>(_condition));
obs_data_set_string(obj, "connection",
GetWeakYouTubeConnectionName(_connection).c_str());
_broadcast.Save(obj);
obs_data_set_string(obj, "broadcastStatus", _broadcastStatus.c_str());
obs_data_set_string(obj, "streamHealth", _streamHealth.c_str());
return true;
}
bool MacroConditionYouTube::Load(obs_data_t *obj)
{
MacroCondition::Load(obj);
_condition = static_cast<Condition>(obs_data_get_int(obj, "condition"));
_connection = GetWeakYouTubeConnectionByName(
obs_data_get_string(obj, "connection"));
_broadcast.Load(obj);
obs_data_set_default_string(obj, "broadcastStatus", "live");
obs_data_set_default_string(obj, "streamHealth", "good");
_broadcastStatus = obs_data_get_string(obj, "broadcastStatus");
_streamHealth = obs_data_get_string(obj, "streamHealth");
return true;
}
std::string MacroConditionYouTube::GetShortDesc() const
{
return GetWeakYouTubeConnectionName(_connection);
}
void MacroConditionYouTube::SetupTempVars()
{
MacroCondition::SetupTempVars();
AddTempvar("id",
obs_module_text("AdvSceneSwitcher.tempVar.youtube.id"));
AddTempvar("title",
obs_module_text("AdvSceneSwitcher.tempVar.youtube.title"));
AddTempvar("broadcastStatus",
obs_module_text(
"AdvSceneSwitcher.tempVar.youtube.broadcastStatus"));
AddTempvar(
"streamHealth",
obs_module_text(
"AdvSceneSwitcher.tempVar.youtube.streamHealth"),
obs_module_text(
"AdvSceneSwitcher.tempVar.youtube.streamHealth.description"));
}
static void populateConditionSelection(QComboBox *list)
{
for (const auto &[condition, name] : conditionTypes) {
list->addItem(obs_module_text(name.c_str()),
static_cast<int>(condition));
}
}
static void populateValueSelection(
QComboBox *list,
const std::vector<std::pair<std::string, std::string>> &values)
{
for (const auto &[value, name] : values) {
list->addItem(obs_module_text(name.c_str()),
QString::fromStdString(value));
}
}
MacroConditionYouTubeEdit::MacroConditionYouTubeEdit(
QWidget *parent, std::shared_ptr<MacroConditionYouTube> entryData)
: QWidget(parent),
_connections(new YouTubeConnectionSelection(this)),
_conditions(new QComboBox(this)),
_broadcastStatus(new QComboBox(this)),
_streamHealth(new QComboBox(this)),
_broadcast(new YouTubeBroadcastSelection(this)),
_connectionWarning(new QLabel(this))
{
populateConditionSelection(_conditions);
populateValueSelection(_broadcastStatus, broadcastStatuses);
populateValueSelection(_streamHealth, streamHealths);
QWidget::connect(_connections,
SIGNAL(SelectionChanged(const QString &)), this,
SLOT(ConnectionChanged(const QString &)));
QWidget::connect(_conditions, SIGNAL(currentIndexChanged(int)), this,
SLOT(ConditionChanged(int)));
QWidget::connect(_broadcastStatus, SIGNAL(currentIndexChanged(int)),
this, SLOT(BroadcastStatusChanged(int)));
QWidget::connect(_streamHealth, SIGNAL(currentIndexChanged(int)), this,
SLOT(StreamHealthChanged(int)));
QWidget::connect(_broadcast,
SIGNAL(BroadcastChanged(const YouTubeBroadcast &)),
this,
SLOT(BroadcastChanged(const YouTubeBroadcast &)));
QWidget::connect(&_connectionCheckTimer, SIGNAL(timeout()), this,
SLOT(CheckConnection()));
auto entryLayout = new QHBoxLayout();
PlaceWidgets(
obs_module_text("AdvSceneSwitcher.condition.youtube.layout"),
entryLayout,
{{"{{connection}}", _connections},
{"{{conditions}}", _conditions},
{"{{broadcastStatus}}", _broadcastStatus},
{"{{streamHealth}}", _streamHealth}});
auto layout = new QVBoxLayout();
layout->addLayout(entryLayout);
layout->addWidget(_broadcast);
layout->addWidget(_connectionWarning);
setLayout(layout);
_entryData = entryData;
UpdateEntryData();
_loading = false;
_connectionCheckTimer.start(1000);
}
void MacroConditionYouTubeEdit::UpdateEntryData()
{
if (!_entryData) {
return;
}
_connections->SetConnection(_entryData->_connection);
_conditions->setCurrentIndex(_conditions->findData(
static_cast<int>(_entryData->_condition)));
_broadcastStatus->setCurrentIndex(_broadcastStatus->findData(
QString::fromStdString(_entryData->_broadcastStatus)));
_streamHealth->setCurrentIndex(_streamHealth->findData(
QString::fromStdString(_entryData->_streamHealth)));
_broadcast->SetConnection(_entryData->_connection);
_broadcast->SetBroadcast(_entryData->_broadcast);
SetWidgetVisibility();
CheckConnection();
}
void MacroConditionYouTubeEdit::ConnectionChanged(const QString &name)
{
GUARD_LOADING_AND_LOCK();
_entryData->_connection =
GetWeakYouTubeConnectionByName(name.toStdString());
_broadcast->SetConnection(_entryData->_connection);
CheckConnection();
emit HeaderInfoChanged(name);
}
void MacroConditionYouTubeEdit::ConditionChanged(int index)
{
GUARD_LOADING_AND_LOCK();
_entryData->_condition = static_cast<MacroConditionYouTube::Condition>(
_conditions->itemData(index).toInt());
SetWidgetVisibility();
}
void MacroConditionYouTubeEdit::BroadcastStatusChanged(int index)
{
GUARD_LOADING_AND_LOCK();
_entryData->_broadcastStatus =
_broadcastStatus->itemData(index).toString().toStdString();
}
void MacroConditionYouTubeEdit::StreamHealthChanged(int index)
{
GUARD_LOADING_AND_LOCK();
_entryData->_streamHealth =
_streamHealth->itemData(index).toString().toStdString();
}
void MacroConditionYouTubeEdit::BroadcastChanged(
const YouTubeBroadcast &broadcast)
{
GUARD_LOADING_AND_LOCK();
_entryData->_broadcast = broadcast;
}
void MacroConditionYouTubeEdit::CheckConnection()
{
if (!_entryData) {
return;
}
const auto connection = _entryData->_connection.lock();
const char *warning = nullptr;
if (!connection) {
warning = "AdvSceneSwitcher.youtubeConnection.noSelection";
} else if (!connection->IsValid()) {
warning = "AdvSceneSwitcher.youtubeConnection.notValid";
}
const bool wasHidden = _connectionWarning->isHidden();
if (warning) {
_connectionWarning->setText(obs_module_text(warning));
}
_connectionWarning->setHidden(!warning);
if (wasHidden != _connectionWarning->isHidden()) {
adjustSize();
updateGeometry();
}
}
void MacroConditionYouTubeEdit::SetWidgetVisibility()
{
if (!_entryData) {
return;
}
_broadcastStatus->setVisible(
_entryData->_condition ==
MacroConditionYouTube::Condition::BROADCAST_STATUS);
_streamHealth->setVisible(
_entryData->_condition ==
MacroConditionYouTube::Condition::STREAM_HEALTH);
adjustSize();
updateGeometry();
}
} // namespace advss

View File

@@ -0,0 +1,86 @@
#pragma once
#include "broadcast-selection.hpp"
#include "youtube-connection.hpp"
#include <macro-condition-edit.hpp>
#include <QComboBox>
#include <QLabel>
#include <QTimer>
namespace advss {
class MacroConditionYouTube : public MacroCondition {
public:
MacroConditionYouTube(Macro *m) : MacroCondition(m) {}
static std::shared_ptr<MacroCondition> Create(Macro *m)
{
return std::make_shared<MacroConditionYouTube>(m);
}
std::string GetId() const { return id; };
std::string GetShortDesc() const;
bool CheckCondition();
bool Save(obs_data_t *obj) const;
bool Load(obs_data_t *obj);
enum class Condition {
BROADCAST_STATUS = 10,
STREAM_HEALTH = 20,
};
Condition _condition = Condition::BROADCAST_STATUS;
std::weak_ptr<YouTubeConnection> _connection;
YouTubeBroadcast _broadcast;
std::string _broadcastStatus = "live";
std::string _streamHealth = "good";
private:
void SetupTempVars();
static bool _registered;
static const std::string id;
};
class MacroConditionYouTubeEdit : public QWidget {
Q_OBJECT
public:
MacroConditionYouTubeEdit(
QWidget *parent,
std::shared_ptr<MacroConditionYouTube> entryData = nullptr);
void UpdateEntryData();
static QWidget *Create(QWidget *parent,
std::shared_ptr<MacroCondition> cond)
{
return new MacroConditionYouTubeEdit(
parent,
std::dynamic_pointer_cast<MacroConditionYouTube>(cond));
}
private slots:
void ConnectionChanged(const QString &);
void ConditionChanged(int);
void BroadcastStatusChanged(int);
void StreamHealthChanged(int);
void BroadcastChanged(const YouTubeBroadcast &);
void CheckConnection();
signals:
void HeaderInfoChanged(const QString &);
private:
void SetWidgetVisibility();
YouTubeConnectionSelection *_connections;
QComboBox *_conditions;
QComboBox *_broadcastStatus;
QComboBox *_streamHealth;
YouTubeBroadcastSelection *_broadcast;
QLabel *_connectionWarning;
QTimer _connectionCheckTimer;
std::shared_ptr<MacroConditionYouTube> _entryData;
bool _loading = true;
};
} // namespace advss