eden/src/network/announce_multiplayer_session.cpp

// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later

// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later

#include <chrono>
#include <future>
#include <vector>
#include "announce_multiplayer_session.h"
#include "common/announce_multiplayer_room.h"
#include "common/assert.h"
#include "common/settings.h"
#include "network/network.h"

#ifdef ENABLE_WEB_SERVICE
#include "web_service/announce_room_json.h"
#endif

namespace Core {

AnnounceMultiplayerSession::AnnounceMultiplayerSession() {
#ifdef ENABLE_WEB_SERVICE
    backend = std::make_unique<WebService::RoomJson>(Settings::values.web_api_url.GetValue(),
                                                     Settings::values.eden_username.GetValue(),
                                                     Settings::values.eden_token.GetValue());
#else
    backend = std::make_unique<AnnounceMultiplayerRoom::NullBackend>();
#endif
}

WebService::WebResult AnnounceMultiplayerSession::Register() {
    auto room = Network::GetRoom().lock();
    if (!room) {
        return WebService::WebResult{WebService::WebResult::Code::LibError,
                                     "Network is not initialized", ""};
    }
    if (room->GetState() != Network::Room::State::Open) {
        return WebService::WebResult{WebService::WebResult::Code::LibError, "Room is not open", ""};
    }
    UpdateBackendData(room);
    WebService::WebResult result = backend->Register();
    if (result.result_code != WebService::WebResult::Code::Success) {
        return result;
    }
    LOG_INFO(WebService, "Room has been registered");
    room->SetVerifyUID(result.returned_data);
    registered = true;
    return WebService::WebResult{WebService::WebResult::Code::Success, "", ""};
}

void AnnounceMultiplayerSession::Start() {
    if (announce_multiplayer_thread.has_value()) {
        Stop();
    }
    announce_multiplayer_thread.emplace([&](std::stop_token stoken) {
        // Invokes all current bound error callbacks.
        const auto ErrorCallback = [this](WebService::WebResult result) {
            std::lock_guard lock(callback_mutex);
            for (auto callback : error_callbacks)
                (*callback)(result);
        };

        if (!registered) {
            WebService::WebResult result = Register();
            if (result.result_code != WebService::WebResult::Code::Success) {
                ErrorCallback(result);
                return;
            }
        }

        // Time between room is announced to web_service
        std::chrono::seconds const announce_timeslice(15);
        auto update_time = std::chrono::steady_clock::now();
        std::future<WebService::WebResult> future;
        while (!shutdown_event.WaitUntil(update_time)) {
            update_time = std::chrono::steady_clock::now() + announce_timeslice;
            auto room = Network::GetRoom().lock();
            if (!room) {
                break;
            }
            if (room->GetState() != Network::Room::State::Open) {
                break;
            }
            UpdateBackendData(room);
            WebService::WebResult result = backend->Update();
            if (result.result_code != WebService::WebResult::Code::Success) {
                ErrorCallback(result);
            }
            if (result.result_string == "404") {
                registered = false;
                // Needs to register the room again
                WebService::WebResult register_result = Register();
                if (register_result.result_code != WebService::WebResult::Code::Success) {
                    ErrorCallback(register_result);
                }
            }
        }
    });
}

void AnnounceMultiplayerSession::Stop() {
    if (announce_multiplayer_thread.has_value()) {
        shutdown_event.Set();
        announce_multiplayer_thread.reset();
        backend->Delete();
        registered = false;
    }
}

AnnounceMultiplayerSession::CallbackHandle AnnounceMultiplayerSession::BindErrorCallback(
    std::function<void(const WebService::WebResult&)> function) {
    std::lock_guard lock(callback_mutex);
    auto handle = std::make_shared<std::function<void(const WebService::WebResult&)>>(function);
    error_callbacks.insert(handle);
    return handle;
}

void AnnounceMultiplayerSession::UnbindErrorCallback(CallbackHandle handle) {
    std::lock_guard lock(callback_mutex);
    error_callbacks.erase(handle);
}

AnnounceMultiplayerSession::~AnnounceMultiplayerSession() {
    Stop();
}

void AnnounceMultiplayerSession::UpdateBackendData(std::shared_ptr<Network::Room> room) {
    Network::RoomInformation room_information = room->GetRoomInformation();
    std::vector<AnnounceMultiplayerRoom::Member> memberlist = room->GetRoomMemberList();
    backend->SetRoomInformation(room_information.name, room_information.description,
                                room_information.port, room_information.member_slots,
                                Network::network_version, room->HasPassword(),
                                room_information.preferred_game);
    backend->ClearPlayers();
    for (const auto& member : memberlist) {
        backend->AddPlayer(member);
    }
}

AnnounceMultiplayerRoom::RoomList AnnounceMultiplayerSession::GetRoomList() {
    return backend->GetRoomList();
}

void AnnounceMultiplayerSession::UpdateCredentials() {
    ASSERT_MSG(!IsRunning(), "Credentials can only be updated when session is not running");
#ifdef ENABLE_WEB_SERVICE
    backend = std::make_unique<WebService::RoomJson>(Settings::values.web_api_url.GetValue(),
                                                     Settings::values.eden_username.GetValue(),
                                                     Settings::values.eden_token.GetValue());
#else
    backend = std::make_unique<AnnounceMultiplayerRoom::NullBackend>();
#endif
}

} // namespace Core