feat(discord): always show launcher in Discord (#113)

so5iso4ka · web-flow · commit 26f0076ebcd6 · 2025-10-22T13:13:22.000+03:00
diff --git a/launcher/Application.cpp b/launcher/Application.cpp
@@ -742,6 +742,10 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         m_settings->registerSetting("ShaderDownloadGeometry", "");
 
         m_settings->registerSetting("EnableDiscordRichPresence", false);
+        m_settings->registerSetting("AlwaysShowInDiscord", false);
+        if (m_settings->get("AlwaysShowInDiscord").toBool()) {
+            discord();
+        }
 
         // HACK: This code feels so stupid is there a less stupid way of doing this?
         {
@@ -1394,7 +1398,7 @@ std::shared_ptr<DiscordIntegration> Application::discord()
 {
     // lazy initialize
     if (!m_discord) {
-        m_discord = std::make_shared<DiscordIntegration>();
+        m_discord = std::make_shared<DiscordIntegration>(m_settings->get("AlwaysShowInDiscord").toBool());
     }
     return m_discord;
 }
diff --git a/launcher/discord/Activity.cpp b/launcher/discord/Activity.cpp
@@ -26,6 +26,8 @@
 
 #include "Activity.h"
 
+#include "BuildConfig.h"
+
 namespace {
 enum class DiscordActivityType { Playing = 0, Streaming = 1, Listening = 2, Watching = 3, Custom = 4, Competing = 5 };
 
@@ -34,57 +36,53 @@ QJsonValue makeNonce()
     return QUuid::createUuid().toString();
 }
 
-QJsonValue makeActivityDetails(const InstancePtr& instance)
-{
-    return "Minecraft " + instance->getVersionString();
-}
-
-QJsonObject makeActivityTimestamps(const RunningInstance& instance)
+QJsonObject makeActivityTimestamps(const qint64 startTime)
 {
     QJsonObject timestamps;
 
-    timestamps["start"] = instance.startedAt.toSecsSinceEpoch();
+    timestamps["start"] = startTime;
 
     return timestamps;
 }
 
-[[maybe_unused]] QJsonObject makeActivityAssets(const InstancePtr& instance)
-{
-    QJsonObject assets;
-
-    assets["large_image"] = instance->iconKey();
-
-    return assets;
-}
-
-QJsonObject makeActivity(const RunningInstance& instance)
+QJsonObject makeActivity(qint64 startTime, const QString& details)
 {
     QJsonObject activity;
 
-    activity["name"] = "Freesm Launcher";
+    activity["name"] = BuildConfig.LAUNCHER_DISPLAYNAME;
     activity["type"] = static_cast<int>(DiscordActivityType::Playing);
-    activity["details"] = makeActivityDetails(instance.ptr());
-    activity["timestamps"] = makeActivityTimestamps(instance);
-    // activity["assets"] = makeActivityAssets(instance);
+    if (!details.isEmpty())
+        activity["details"] = details;
+    activity["timestamps"] = makeActivityTimestamps(startTime);
 
     return activity;
 }
-}  // namespace
 
-QByteArray generateActivity(const RunningInstance& instance)
+QByteArray makeRequest(qint64 startTime, const QString& details)
 {
     QJsonObject request;
 
     QJsonObject args;
     args["pid"] = APPLICATION->applicationPid();
-    args["activity"] = makeActivity(instance);
+    args["activity"] = makeActivity(startTime, details);
 
     request["args"] = args;
     request["nonce"] = makeNonce();
     request["cmd"] = "SET_ACTIVITY";
 
     return QJsonDocument(request).toJson();
 }
+}  // namespace
+
+QByteArray generateActivity(const RunningInstance& instance)
+{
+    return makeRequest(instance.startedAt.toSecsSinceEpoch(), "Minecraft " + instance.ptr()->getVersionString());
+}
+
+QByteArray generateBackgroundActivity(qint64 startTime)
+{
+    return makeRequest(startTime, "");
+}
 
 QByteArray generateEmptyActivity()
 {
diff --git a/launcher/discord/Activity.h b/launcher/discord/Activity.h
@@ -18,7 +18,10 @@
 
 #pragma once
 
+#include <QByteArray>
+
 struct RunningInstance;
 
 QByteArray generateActivity(const RunningInstance& instance);
+QByteArray generateBackgroundActivity(qint64 startTime);
 QByteArray generateEmptyActivity();
diff --git a/launcher/discord/DiscordIntegration.cpp b/launcher/discord/DiscordIntegration.cpp
@@ -16,6 +16,7 @@
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+#include <QDateTime>
 #include <QDir>
 #include <QJsonDocument>
 #include <QJsonObject>
@@ -28,7 +29,13 @@
 
 #include "DiscordIntegration.h"
 
-DiscordIntegration::DiscordIntegration() : m_socket(makeSocket()), m_queue(std::make_unique<DiscordQueue>())
+#include <QThread>
+
+DiscordIntegration::DiscordIntegration(bool showAlways)
+    : m_socket(makeSocket())
+    , m_queue(std::make_unique<DiscordQueue>())
+    , m_showAlways(showAlways)
+    , m_startTime(QDateTime::currentSecsSinceEpoch())
 {
     connect(m_socket.get(), &DiscordSocket::connected, this, &DiscordIntegration::socketConnected);
     connect(m_socket.get(), &DiscordSocket::failed, this, &DiscordIntegration::socketFailed);
@@ -51,14 +58,23 @@ void DiscordIntegration::instanceStopped(const std::shared_ptr<BaseInstance>& in
     m_queue->instanceStopped(instance);
 }
 
-bool DiscordIntegration::startActivity(const RunningInstance instance)
+void DiscordIntegration::showAlways(bool state)
+{
+    m_showAlways = state;
+
+    if (!m_queue->isInstanceRunning()) {
+        emit stopActivity();
+    }
+}
+
+void DiscordIntegration::startActivity(const RunningInstance instance)
 {
-    return m_socket->send(generateActivity(instance));
+    m_socket->enqueue(generateActivity(instance));
 }
 
-bool DiscordIntegration::stopActivity()
+void DiscordIntegration::stopActivity()
 {
-    return m_socket->send(generateEmptyActivity());
+    m_socket->enqueue(m_showAlways ? generateBackgroundActivity(m_startTime) : generateEmptyActivity());
 }
 
 void DiscordIntegration::socketConnected()
diff --git a/launcher/discord/DiscordIntegration.h b/launcher/discord/DiscordIntegration.h
@@ -29,22 +29,27 @@ class DiscordIntegration : public QObject {
     Q_OBJECT
 
    public:
-    DiscordIntegration();
+    explicit DiscordIntegration(bool showAlways);
     ~DiscordIntegration() override;
 
    public:
     void instanceStarted(const std::shared_ptr<BaseInstance>& instance);
     void instanceStopped(const std::shared_ptr<BaseInstance>& instance);
 
+    void showAlways(bool state);
+
    private slots:
     void socketConnected();
     void socketFailed();
 
-    bool startActivity(RunningInstance instance);
-    bool stopActivity();
+    void startActivity(RunningInstance instance);
+    void stopActivity();
 
    private:
     std::unique_ptr<DiscordSocket> m_socket;
 
     std::unique_ptr<DiscordQueue> m_queue;
+
+    bool m_showAlways;
+    qint64 m_startTime;
 };
diff --git a/launcher/discord/DiscordQueue.cpp b/launcher/discord/DiscordQueue.cpp
@@ -42,6 +42,11 @@ void DiscordQueue::instanceStopped(const std::shared_ptr<BaseInstance>& instance
     emit processQueue();
 }
 
+bool DiscordQueue::isInstanceRunning()
+{
+    return !m_runningInstance.expired();
+}
+
 void DiscordQueue::socketReady()
 {
     m_socketReady = true;
diff --git a/launcher/discord/DiscordQueue.h b/launcher/discord/DiscordQueue.h
@@ -32,6 +32,8 @@ class DiscordQueue : public QObject {
     void instanceStarted(const std::shared_ptr<BaseInstance>& instance);
     void instanceStopped(const std::shared_ptr<BaseInstance>& instance);
 
+    bool isInstanceRunning();
+
    public slots:
     void socketReady();
 
diff --git a/launcher/discord/DiscordSocket.cpp b/launcher/discord/DiscordSocket.cpp
@@ -52,27 +52,27 @@ void DiscordSocket::onConnected()
 
 void DiscordSocket::handshake()
 {
-    send(generateHandshake(), Opcode::Handshake);
+    enqueue(generateHandshake(), Opcode::Handshake);
 }
 
-void DiscordSocket::errorOccurred([[maybe_unused]] QLocalSocket::LocalSocketError socketError)
+void DiscordSocket::processReply()
 {
-    emit failed();
-}
-
-void DiscordSocket::read()
-{
-    if (m_socket.bytesAvailable() != 0) {
-        disconnect(&m_socket, &QLocalSocket::readyRead, this, &DiscordSocket::read);
+    const auto reply = QJsonDocument::fromJson(m_msg);
+    const auto obj = reply.object();
+    if (obj["cmd"] == "DISPATCH" && obj["evt"] == "READY") {
         emit connected();
+        return;
+    }
+
+    if (!m_messagesToSend.isEmpty()) {
+        emit send();
     }
 }
 
-bool DiscordSocket::send(const QByteArray& data, Opcode opcode)
+void DiscordSocket::send()
 {
-    if (m_socket.state() != QLocalSocket::ConnectedState) {
-        qDebug() << "socket.state() != QLocalSocket::ConnectedState";
-    }
+    m_state = State::Sent;
+    auto [data, opcode] = m_messagesToSend.dequeue();
 
     QByteArray frame;
     QDataStream stream(&frame, QIODevice::WriteOnly);
@@ -87,10 +87,54 @@ bool DiscordSocket::send(const QByteArray& data, Opcode opcode)
     const auto sent = m_socket.write(frame);
     if (sent != frame.size()) {
         qDebug() << "send failed, sent " << sent << '/' << frame.size();
-        return false;
+        return;
     }
     m_socket.flush();
-    return true;
+}
+
+void DiscordSocket::errorOccurred([[maybe_unused]] QLocalSocket::LocalSocketError socketError)
+{
+    emit failed();
+}
+
+void DiscordSocket::read()
+{
+    if (m_state != State::Reading) {
+        if (m_socket.bytesAvailable() >= sizeof(quint32) * 2) {
+            QDataStream in(&m_socket);
+            in.setByteOrder(QDataStream::LittleEndian);
+
+            quint32 op;
+            in >> op;
+
+            quint32 bytes;
+            in >> bytes;
+            m_pendingBytes = bytes;
+
+            m_state = State::Reading;
+            m_msg = {};
+        } else {
+            return;
+        }
+    }
+
+    if (m_state == State::Reading) {
+        auto toRead = std::min(m_socket.bytesAvailable(), m_pendingBytes);
+        m_msg.append(m_socket.read(toRead));
+        m_pendingBytes -= toRead;
+        if (m_pendingBytes == 0) {
+            m_state = State::Waiting;
+            processReply();
+        }
+    }
+}
+
+void DiscordSocket::enqueue(const QByteArray& data, Opcode opcode)
+{
+    m_messagesToSend.enqueue({ data, opcode });
+    if (m_state == State::Waiting) {
+        emit send();
+    }
 }
 
 void UnixDiscordSocket::connectSocket()
diff --git a/launcher/discord/DiscordSocket.h b/launcher/discord/DiscordSocket.h
@@ -18,11 +18,13 @@
 
 #pragma once
 
+#include <QByteArray>
 #include <QLocalSocket>
 #include <QObject>
+#include <QQueue>
 
 class DiscordSocket : public QObject {
-    enum class Opcode : uint32_t { Handshake = 0, Frame = 1, Close = 2, Ping = 3, Pong = 4 };
+    enum class Opcode : quint32 { Handshake = 0, Frame = 1, Close = 2, Ping = 3, Pong = 4 };
 
     Q_OBJECT
    public:
@@ -32,7 +34,7 @@ class DiscordSocket : public QObject {
 
     virtual void connectSocket() = 0;
 
-    bool send(const QByteArray& data, Opcode opcode = Opcode::Frame);
+    void enqueue(const QByteArray& data, Opcode opcode = Opcode::Frame);
 
     QString errorString() const { return m_socket.errorString(); }
 
@@ -45,15 +47,26 @@ class DiscordSocket : public QObject {
    protected:
     void handshake();
 
+    void processReply();
+
    protected slots:
     void onConnected();
 
     virtual void errorOccurred(QLocalSocket::LocalSocketError socketError);
 
     void read();
 
+    void send();
+
    protected:
     QLocalSocket m_socket;
+
+   private:
+    enum class State { Waiting, Sent, Reading } m_state{ State::Waiting };
+    qint64 m_pendingBytes{};
+    QByteArray m_msg;
+
+    QQueue<std::pair<QByteArray, Opcode>> m_messagesToSend;
 };
 
 class UnixDiscordSocket : public DiscordSocket {
diff --git a/launcher/ui/pages/global/LauncherPage.cpp b/launcher/ui/pages/global/LauncherPage.cpp
diff --git a/launcher/ui/pages/global/LauncherPage.ui b/launcher/ui/pages/global/LauncherPage.ui
diff --git a/launcher/ui/widgets/MinecraftSettingsWidget.ui b/launcher/ui/widgets/MinecraftSettingsWidget.ui

Original file line number	Diff line number	Diff line change
`@@ -742,6 +742,10 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)`
`742`	`742`	`m_settings->registerSetting("ShaderDownloadGeometry", "");`
`743`	`743`
`744`	`744`	`m_settings->registerSetting("EnableDiscordRichPresence", false);`
	`745`	`+ m_settings->registerSetting("AlwaysShowInDiscord", false);`
	`746`	`+ if (m_settings->get("AlwaysShowInDiscord").toBool()) {`
	`747`	`+ discord();`
	`748`	`+ }`
`745`	`749`
`746`	`750`	`// HACK: This code feels so stupid is there a less stupid way of doing this?`
`747`	`751`	`{`
`@@ -1394,7 +1398,7 @@ std::shared_ptr<DiscordIntegration> Application::discord()`
`1394`	`1398`	`{`
`1395`	`1399`	`// lazy initialize`
`1396`	`1400`	`if (!m_discord) {`
`1397`		`- m_discord = std::make_shared<DiscordIntegration>();`
	`1401`	`+ m_discord = std::make_shared<DiscordIntegration>(m_settings->get("AlwaysShowInDiscord").toBool());`
`1398`	`1402`	`}`
`1399`	`1403`	`return m_discord;`
`1400`	`1404`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,11 @@ void DiscordQueue::instanceStopped(const std::shared_ptr<BaseInstance>& instance`
`42`	`42`	`emit processQueue();`
`43`	`43`	`}`
`44`	`44`
	`45`	`+bool DiscordQueue::isInstanceRunning()`
	`46`	`+{`
	`47`	`+ return !m_runningInstance.expired();`
	`48`	`+}`
	`49`	`+`
`45`	`50`	`void DiscordQueue::socketReady()`
`46`	`51`	`{`
`47`	`52`	`m_socketReady = true;`