RichPresence: Formatting and add settings reload

src/discord/richpresence.cpp

@@ -16,23 +16,27 @@
  *
  */
 
-#include "richpresence.h"
-
-#include "core/logging.h"
-#include "core/player.h"
-#include "core/settings.h"
-#include "engine/enginebase.h"
-#include "constants/notificationssettings.h"
-
 #include <discord_rpc.h>
 
-namespace {
+#include <QByteArray>
+#include <QString>
+#include <QDateTime>
 
+#include "constants/timeconstants.h"
+#include "constants/notificationssettings.h"
+#include "core/logging.h"
+#include "core/settings.h"
+#include "core/song.h"
+#include "core/player.h"
+#include "engine/enginebase.h"
+#include "playlist/playlistmanager.h"
+#include "richpresence.h"
+
+namespace {
 constexpr char kDiscordApplicationId[] = "1352351827206733974";
 constexpr char kStrawberryIconResourceName[] = "embedded_cover";
 constexpr char kStrawberryIconDescription[] = "Strawberry Music Player";
 constexpr qint64 kDiscordPresenceUpdateRateLimitMs = 2000;
-
 }  // namespace
 
 using namespace discord_rpc;
@@ -47,74 +51,86 @@ RichPresence::RichPresence(const SharedPtr<Player> player,
       playlist_manager_(playlist_manager),
       activity_({ {}, {}, {}, 0, 0, 0 }),
       send_presence_timestamp_(0),
-      is_enabled_(false) {
-  Discord_Initialize(kDiscordApplicationId, nullptr, true, nullptr);
+      enabled_(false) {
+
+  Discord_Initialize(kDiscordApplicationId, nullptr, 1, nullptr);
 
   QObject::connect(&*player_->engine(), &EngineBase::StateChanged, this, &RichPresence::EngineStateChanged);
   QObject::connect(&*playlist_manager_, &PlaylistManager::CurrentSongChanged, this, &RichPresence::CurrentSongChanged);
   QObject::connect(&*player_, &Player::Seeked, this, &RichPresence::Seeked);
+
+  ReloadSettings();
+
 }
 
 RichPresence::~RichPresence() {
   Discord_Shutdown();
 }
 
-void RichPresence::EngineStateChanged(EngineBase::State newState) {
-  if (newState == EngineBase::State::Playing) {
-    SetTimestamp(player_->engine()->position_nanosec() / 1e3);
+void RichPresence::ReloadSettings() {
+
+  Settings s;
+  s.beginGroup(DiscordRPCSettings::kSettingsGroup);
+  const bool enabled = s.value(DiscordRPCSettings::kEnabled, false).toBool();
+  s.endGroup();
+
+  if (enabled_ && !enabled) {
+    Discord_ClearPresence();
+  }
+
+  enabled_ = enabled;
+
+}
+
+void RichPresence::EngineStateChanged(const EngineBase::State state) {
+
+  if (state == EngineBase::State::Playing) {
+    SetTimestamp(player_->engine()->position_nanosec() / kNsecPerSec);
     SendPresenceUpdate();
   }
-  else
+  else {
     Discord_ClearPresence();
+  }
+
 }
 
 void RichPresence::CurrentSongChanged(const Song &song) {
-  SetTimestamp(0);
-  activity_.length_secs = song.length_nanosec() / 1e9;
+
+  SetTimestamp(0LL);
+  activity_.length_secs = song.length_nanosec() / kNsecPerSec;
   activity_.title = song.title();
   activity_.artist = song.artist();
   activity_.album = song.album();
 
   SendPresenceUpdate();
-}
 
-void RichPresence::CheckEnabled() {
-  Settings s;
-  s.beginGroup(DiscordRPCSettings::kSettingsGroup);
-
-  is_enabled_ = s.value(DiscordRPCSettings::kEnabled).toBool();
-
-  s.endGroup();
-
-  if (!is_enabled_)
-    Discord_ClearPresence();
 }
 
 void RichPresence::SendPresenceUpdate() {
-  CheckEnabled();
-  if (!is_enabled_)
-    return;
 
-  qint64 nowTimestamp = QDateTime::currentMSecsSinceEpoch();
-  if (nowTimestamp - send_presence_timestamp_ < kDiscordPresenceUpdateRateLimitMs) {
-    qLog(Debug) << "Not sending rich presence due to rate limit of " << kDiscordPresenceUpdateRateLimitMs << "ms";
+  if (!enabled_) {
     return;
   }
 
-  send_presence_timestamp_ = nowTimestamp;
+  const qint64 current_timestamp = QDateTime::currentMSecsSinceEpoch();
+  if (current_timestamp - send_presence_timestamp_ < kDiscordPresenceUpdateRateLimitMs) {
+    qLog(Info) << "Not sending rich presence due to rate limit of" << kDiscordPresenceUpdateRateLimitMs << "ms";
+    return;
+  }
 
-  ::DiscordRichPresence presence_data;
+  send_presence_timestamp_ = current_timestamp;
+
+  ::DiscordRichPresence presence_data{};
   memset(&presence_data, 0, sizeof(presence_data));
-  QByteArray title;
-  QByteArray artist;
-  QByteArray album;
-
-  presence_data.type = 2 /* Listening */;
+  presence_data.type = 2; // Listening
   presence_data.largeImageKey = kStrawberryIconResourceName;
   presence_data.smallImageKey = kStrawberryIconResourceName;
   presence_data.smallImageText = kStrawberryIconDescription;
-  presence_data.instance = false;
+  presence_data.instance = 0;
 
+  QByteArray artist;
+  QByteArray album;
+  QByteArray title;
   if (!activity_.artist.isEmpty()) {
     artist = activity_.artist.toUtf8();
     artist.prepend(tr("by ").toUtf8());
@@ -130,21 +146,22 @@ void RichPresence::SendPresenceUpdate() {
   title = activity_.title.toUtf8();
   presence_data.details = title.constData();
 
-  const qint64 startTimestamp = activity_.start_timestamp - activity_.seek_secs;
+  const qint64 start_timestamp = activity_.start_timestamp - activity_.seek_secs;
 
-  presence_data.startTimestamp = startTimestamp;
-  presence_data.endTimestamp = startTimestamp + activity_.length_secs;
+  presence_data.startTimestamp = start_timestamp;
+  presence_data.endTimestamp = start_timestamp + activity_.length_secs;
 
   Discord_UpdatePresence(&presence_data);
+
 }
 
-void RichPresence::SetTimestamp(const qint64 seekMicroseconds) {
-  activity_.start_timestamp = time(nullptr);
-  activity_.seek_secs = seekMicroseconds / 1e6;
+void RichPresence::SetTimestamp(const qint64 seconds) {
+  activity_.start_timestamp = QDateTime::currentSecsSinceEpoch();
+  activity_.seek_secs = seconds;
 }
 
-void RichPresence::Seeked(const qint64 microseconds) {
-  SetTimestamp(microseconds);
+void RichPresence::Seeked(const qint64 seek_microseconds) {
+  SetTimestamp(seek_microseconds / 1000LL);
   SendPresenceUpdate();
 }
 

src/discord/richpresence.h

@@ -22,10 +22,15 @@
 #include "config.h"
 
 #include <QObject>
+#include <QString>
 
-#include "core/player.h"
-#include "playlist/playlistmanager.h"
 #include "includes/shared_ptr.h"
+#include "core/player.h"
+#include "engine/enginebase.h"
+
+class Song;
+class Player;
+class PlaylistManager;
 
 namespace discord {
 
@@ -38,17 +43,17 @@ class RichPresence : public QObject {
                         QObject *parent = nullptr);
   ~RichPresence();
 
+  void ReloadSettings();
   void Stop();
 
  private Q_SLOTS:
-  void EngineStateChanged(EngineBase::State newState);
+  void EngineStateChanged(const EngineBase::State state);
   void CurrentSongChanged(const Song &song);
-  void Seeked(const qint64 microseconds);
+  void Seeked(const qint64 seek_microseconds);
 
  private:
-  void CheckEnabled();
   void SendPresenceUpdate();
-  void SetTimestamp(const qint64 seekMicroseconds = 0);
+  void SetTimestamp(const qint64 seconds = 0);
 
   const SharedPtr<Player> player_;
   const SharedPtr<PlaylistManager> playlist_manager_;
@@ -62,7 +67,7 @@ class RichPresence : public QObject {
     qint64 seek_secs;
   } activity_;
   qint64 send_presence_timestamp_;
-  bool is_enabled_;
+  bool enabled_;
 };
 
 }  // namespace discord