diff --git a/data/locale/en-US.ini b/data/locale/en-US.ini index f38b5c56..01c0b863 100644 --- a/data/locale/en-US.ini +++ b/data/locale/en-US.ini @@ -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." diff --git a/plugins/youtube/CMakeLists.txt b/plugins/youtube/CMakeLists.txt index d4122e26..7ecbf0c9 100644 --- a/plugins/youtube/CMakeLists.txt +++ b/plugins/youtube/CMakeLists.txt @@ -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 diff --git a/plugins/youtube/macro-condition-youtube.cpp b/plugins/youtube/macro-condition-youtube.cpp new file mode 100644 index 00000000..1a6cd127 --- /dev/null +++ b/plugins/youtube/macro-condition-youtube.cpp @@ -0,0 +1,321 @@ +#include "macro-condition-youtube.hpp" +#include "youtube-helpers.hpp" + +#include +#include + +#include +#include + +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 + 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> + 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> 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 broadcast; + std::string streamHealth; + { + SuspendLock suspendLock(static_cast(*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(_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(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(condition)); + } +} + +static void populateValueSelection( + QComboBox *list, + const std::vector> &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 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(_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( + _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 diff --git a/plugins/youtube/macro-condition-youtube.hpp b/plugins/youtube/macro-condition-youtube.hpp new file mode 100644 index 00000000..989077d0 --- /dev/null +++ b/plugins/youtube/macro-condition-youtube.hpp @@ -0,0 +1,86 @@ +#pragma once +#include "broadcast-selection.hpp" +#include "youtube-connection.hpp" + +#include + +#include +#include +#include + +namespace advss { + +class MacroConditionYouTube : public MacroCondition { +public: + MacroConditionYouTube(Macro *m) : MacroCondition(m) {} + static std::shared_ptr Create(Macro *m) + { + return std::make_shared(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 _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 entryData = nullptr); + void UpdateEntryData(); + static QWidget *Create(QWidget *parent, + std::shared_ptr cond) + { + return new MacroConditionYouTubeEdit( + parent, + std::dynamic_pointer_cast(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 _entryData; + bool _loading = true; +}; + +} // namespace advss