commit
3c03da12c8
@ -0,0 +1,143 @@
|
||||
// Copyright 2017 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <functional>
|
||||
#include <future>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "common/common_types.h"
|
||||
|
||||
namespace Common {
|
||||
struct WebResult {
|
||||
enum class Code : u32 {
|
||||
Success,
|
||||
InvalidURL,
|
||||
CredentialsMissing,
|
||||
CprError,
|
||||
HttpError,
|
||||
WrongContent,
|
||||
NoWebservice,
|
||||
};
|
||||
Code result_code;
|
||||
std::string result_string;
|
||||
};
|
||||
} // namespace Common
|
||||
|
||||
namespace AnnounceMultiplayerRoom {
|
||||
|
||||
using MacAddress = std::array<u8, 6>;
|
||||
|
||||
struct Room {
|
||||
struct Member {
|
||||
std::string name;
|
||||
MacAddress mac_address;
|
||||
std::string game_name;
|
||||
u64 game_id;
|
||||
};
|
||||
std::string name;
|
||||
std::string UID;
|
||||
std::string owner;
|
||||
std::string ip;
|
||||
u16 port;
|
||||
u32 max_player;
|
||||
u32 net_version;
|
||||
bool has_password;
|
||||
std::string preferred_game;
|
||||
u64 preferred_game_id;
|
||||
|
||||
std::vector<Member> members;
|
||||
};
|
||||
using RoomList = std::vector<Room>;
|
||||
|
||||
/**
|
||||
* A AnnounceMultiplayerRoom interface class. A backend to submit/get to/from a web service should
|
||||
* implement this interface.
|
||||
*/
|
||||
class Backend : NonCopyable {
|
||||
public:
|
||||
virtual ~Backend() = default;
|
||||
|
||||
/**
|
||||
* Sets the Information that gets used for the announce
|
||||
* @param uid The Id of the room
|
||||
* @param name The name of the room
|
||||
* @param port The port of the room
|
||||
* @param net_version The version of the libNetwork that gets used
|
||||
* @param has_password True if the room is passowrd protected
|
||||
* @param preferred_game The preferred game of the room
|
||||
* @param preferred_game_id The title id of the preferred game
|
||||
*/
|
||||
virtual void SetRoomInformation(const std::string& uid, const std::string& name, const u16 port,
|
||||
const u32 max_player, const u32 net_version,
|
||||
const bool has_password, const std::string& preferred_game,
|
||||
const u64 preferred_game_id) = 0;
|
||||
/**
|
||||
* Adds a player information to the data that gets announced
|
||||
* @param nickname The nickname of the player
|
||||
* @param mac_address The MAC Address of the player
|
||||
* @param game_id The title id of the game the player plays
|
||||
* @param game_name The name of the game the player plays
|
||||
*/
|
||||
virtual void AddPlayer(const std::string& nickname, const MacAddress& mac_address,
|
||||
const u64 game_id, const std::string& game_name) = 0;
|
||||
|
||||
/**
|
||||
* Send the data to the announce service
|
||||
* @result The result of the announce attempt
|
||||
*/
|
||||
virtual std::future<Common::WebResult> Announce() = 0;
|
||||
|
||||
/**
|
||||
* Empties the stored players
|
||||
*/
|
||||
virtual void ClearPlayers() = 0;
|
||||
|
||||
/**
|
||||
* Get the room information from the announce service
|
||||
* @param func a function that gets exectued when the get finished.
|
||||
* Can be used as a callback
|
||||
* @result A list of all rooms the announce service has
|
||||
*/
|
||||
virtual std::future<RoomList> GetRoomList(std::function<void()> func) = 0;
|
||||
|
||||
/**
|
||||
* Sends a delete message to the announce service
|
||||
*/
|
||||
virtual void Delete() = 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Empty implementation of AnnounceMultiplayerRoom interface that drops all data. Used when a
|
||||
* functional backend implementation is not available.
|
||||
*/
|
||||
class NullBackend : public Backend {
|
||||
public:
|
||||
~NullBackend() = default;
|
||||
void SetRoomInformation(const std::string& /*uid*/, const std::string& /*name*/,
|
||||
const u16 /*port*/, const u32 /*max_player*/, const u32 /*net_version*/,
|
||||
const bool /*has_password*/, const std::string& /*preferred_game*/,
|
||||
const u64 /*preferred_game_id*/) override {}
|
||||
void AddPlayer(const std::string& /*nickname*/, const MacAddress& /*mac_address*/,
|
||||
const u64 /*game_id*/, const std::string& /*game_name*/) override {}
|
||||
std::future<Common::WebResult> Announce() override {
|
||||
return std::async(std::launch::deferred, []() {
|
||||
return Common::WebResult{Common::WebResult::Code::NoWebservice,
|
||||
"WebService is missing"};
|
||||
});
|
||||
}
|
||||
void ClearPlayers() override {}
|
||||
std::future<RoomList> GetRoomList(std::function<void()> func) override {
|
||||
return std::async(std::launch::deferred, [func]() {
|
||||
func();
|
||||
return RoomList{};
|
||||
});
|
||||
}
|
||||
|
||||
void Delete() override {}
|
||||
};
|
||||
|
||||
} // namespace AnnounceMultiplayerRoom
|
@ -0,0 +1,108 @@
|
||||
// Copyright 2017 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include <chrono>
|
||||
#include <vector>
|
||||
#include "announce_multiplayer_session.h"
|
||||
#include "common/announce_multiplayer_room.h"
|
||||
#include "common/assert.h"
|
||||
#include "core/settings.h"
|
||||
#include "network/network.h"
|
||||
|
||||
#ifdef ENABLE_WEB_SERVICE
|
||||
#include "web_service/announce_room_json.h"
|
||||
#endif
|
||||
|
||||
namespace Core {
|
||||
|
||||
// Time between room is announced to web_service
|
||||
static constexpr std::chrono::seconds announce_time_interval(15);
|
||||
|
||||
AnnounceMultiplayerSession::AnnounceMultiplayerSession() {
|
||||
#ifdef ENABLE_WEB_SERVICE
|
||||
backend = std::make_unique<WebService::RoomJson>(
|
||||
Settings::values.announce_multiplayer_room_endpoint_url, Settings::values.citra_username,
|
||||
Settings::values.citra_token);
|
||||
#else
|
||||
backend = std::make_unique<AnnounceMultiplayerRoom::NullBackend>();
|
||||
#endif
|
||||
}
|
||||
|
||||
void AnnounceMultiplayerSession::Start() {
|
||||
if (announce_multiplayer_thread) {
|
||||
Stop();
|
||||
}
|
||||
shutdown_event.Reset();
|
||||
announce_multiplayer_thread =
|
||||
std::make_unique<std::thread>(&AnnounceMultiplayerSession::AnnounceMultiplayerLoop, this);
|
||||
}
|
||||
|
||||
void AnnounceMultiplayerSession::Stop() {
|
||||
if (announce_multiplayer_thread) {
|
||||
shutdown_event.Set();
|
||||
announce_multiplayer_thread->join();
|
||||
announce_multiplayer_thread.reset();
|
||||
backend->Delete();
|
||||
}
|
||||
}
|
||||
|
||||
AnnounceMultiplayerSession::CallbackHandle AnnounceMultiplayerSession::BindErrorCallback(
|
||||
std::function<void(const Common::WebResult&)> function) {
|
||||
std::lock_guard<std::mutex> lock(callback_mutex);
|
||||
auto handle = std::make_shared<std::function<void(const Common::WebResult&)>>(function);
|
||||
error_callbacks.insert(handle);
|
||||
return handle;
|
||||
}
|
||||
|
||||
void AnnounceMultiplayerSession::UnbindErrorCallback(CallbackHandle handle) {
|
||||
std::lock_guard<std::mutex> lock(callback_mutex);
|
||||
error_callbacks.erase(handle);
|
||||
}
|
||||
|
||||
AnnounceMultiplayerSession::~AnnounceMultiplayerSession() {
|
||||
Stop();
|
||||
}
|
||||
|
||||
void AnnounceMultiplayerSession::AnnounceMultiplayerLoop() {
|
||||
auto update_time = std::chrono::steady_clock::now();
|
||||
std::future<Common::WebResult> future;
|
||||
while (!shutdown_event.WaitUntil(update_time)) {
|
||||
update_time += announce_time_interval;
|
||||
std::shared_ptr<Network::Room> room = Network::GetRoom().lock();
|
||||
if (!room) {
|
||||
break;
|
||||
}
|
||||
if (room->GetState() != Network::Room::State::Open) {
|
||||
break;
|
||||
}
|
||||
Network::RoomInformation room_information = room->GetRoomInformation();
|
||||
std::vector<Network::Room::Member> memberlist = room->GetRoomMemberList();
|
||||
backend->SetRoomInformation(
|
||||
room_information.uid, room_information.name, room_information.port,
|
||||
room_information.member_slots, Network::network_version, room->HasPassword(),
|
||||
room_information.preferred_game, room_information.preferred_game_id);
|
||||
backend->ClearPlayers();
|
||||
for (const auto& member : memberlist) {
|
||||
backend->AddPlayer(member.nickname, member.mac_address, member.game_info.id,
|
||||
member.game_info.name);
|
||||
}
|
||||
future = backend->Announce();
|
||||
if (future.valid()) {
|
||||
Common::WebResult result = future.get();
|
||||
if (result.result_code != Common::WebResult::Code::Success) {
|
||||
std::lock_guard<std::mutex> lock(callback_mutex);
|
||||
for (auto callback : error_callbacks) {
|
||||
(*callback)(result);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::future<AnnounceMultiplayerRoom::RoomList> AnnounceMultiplayerSession::GetRoomList(
|
||||
std::function<void()> func) {
|
||||
return backend->GetRoomList(func);
|
||||
}
|
||||
|
||||
} // namespace Core
|
@ -0,0 +1,71 @@
|
||||
// Copyright 2017 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <set>
|
||||
#include <thread>
|
||||
#include "common/announce_multiplayer_room.h"
|
||||
#include "common/common_types.h"
|
||||
#include "common/thread.h"
|
||||
|
||||
namespace Core {
|
||||
|
||||
/**
|
||||
* Instruments AnnounceMultiplayerRoom::Backend.
|
||||
* Creates a thread that regularly updates the room information and submits them
|
||||
* An async get of room information is also possible
|
||||
*/
|
||||
class AnnounceMultiplayerSession : NonCopyable {
|
||||
public:
|
||||
using CallbackHandle = std::shared_ptr<std::function<void(const Common::WebResult&)>>;
|
||||
AnnounceMultiplayerSession();
|
||||
~AnnounceMultiplayerSession();
|
||||
|
||||
/**
|
||||
* Allows to bind a function that will get called if the announce encounters an error
|
||||
* @param function The function that gets called
|
||||
* @return A handle that can be used the unbind the function
|
||||
*/
|
||||
CallbackHandle BindErrorCallback(std::function<void(const Common::WebResult&)> function);
|
||||
|
||||
/**
|
||||
* Unbind a function from the error callbacks
|
||||
* @param handle The handle for the function that should get unbind
|
||||
*/
|
||||
void UnbindErrorCallback(CallbackHandle handle);
|
||||
|
||||
/**
|
||||
* Starts the announce of a room to web services
|
||||
*/
|
||||
void Start();
|
||||
|
||||
/**
|
||||
* Stops the announce to web services
|
||||
*/
|
||||
void Stop();
|
||||
|
||||
/**
|
||||
* Returns a list of all room information the backend got
|
||||
* @param func A function that gets executed when the async get finished, e.g. a signal
|
||||
* @return a list of rooms received from the web service
|
||||
*/
|
||||
std::future<AnnounceMultiplayerRoom::RoomList> GetRoomList(std::function<void()> func);
|
||||
|
||||
private:
|
||||
Common::Event shutdown_event;
|
||||
std::mutex callback_mutex;
|
||||
std::set<CallbackHandle> error_callbacks;
|
||||
std::unique_ptr<std::thread> announce_multiplayer_thread;
|
||||
|
||||
/// Backend interface that logs fields
|
||||
std::unique_ptr<AnnounceMultiplayerRoom::Backend> backend;
|
||||
|
||||
void AnnounceMultiplayerLoop();
|
||||
};
|
||||
|
||||
} // namespace Core
|
@ -0,0 +1,112 @@
|
||||
// Copyright 2017 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include <future>
|
||||
#include <json.hpp>
|
||||
#include "common/logging/log.h"
|
||||
#include "web_service/announce_room_json.h"
|
||||
#include "web_service/web_backend.h"
|
||||
|
||||
namespace AnnounceMultiplayerRoom {
|
||||
|
||||
void to_json(nlohmann::json& json, const Room::Member& member) {
|
||||
json["name"] = member.name;
|
||||
json["gameName"] = member.game_name;
|
||||
json["gameId"] = member.game_id;
|
||||
}
|
||||
|
||||
void from_json(const nlohmann::json& json, Room::Member& member) {
|
||||
member.name = json.at("name").get<std::string>();
|
||||
member.game_name = json.at("gameName").get<std::string>();
|
||||
member.game_id = json.at("gameId").get<u64>();
|
||||
}
|
||||
|
||||
void to_json(nlohmann::json& json, const Room& room) {
|
||||
json["id"] = room.UID;
|
||||
json["port"] = room.port;
|
||||
json["name"] = room.name;
|
||||
json["preferredGameName"] = room.preferred_game;
|
||||
json["preferredGameId"] = room.preferred_game_id;
|
||||
json["maxPlayers"] = room.max_player;
|
||||
json["netVersion"] = room.net_version;
|
||||
json["hasPassword"] = room.has_password;
|
||||
if (room.members.size() > 0) {
|
||||
nlohmann::json member_json = room.members;
|
||||
json["players"] = member_json;
|
||||
}
|
||||
}
|
||||
|
||||
void from_json(const nlohmann::json& json, Room& room) {
|
||||
room.ip = json.at("address").get<std::string>();
|
||||
room.name = json.at("name").get<std::string>();
|
||||
room.owner = json.at("owner").get<std::string>();
|
||||
room.port = json.at("port").get<u16>();
|
||||
room.preferred_game = json.at("preferredGameName").get<std::string>();
|
||||
room.preferred_game_id = json.at("preferredGameId").get<u64>();
|
||||
room.max_player = json.at("maxPlayers").get<u32>();
|
||||
room.net_version = json.at("netVersion").get<u32>();
|
||||
room.has_password = json.at("hasPassword").get<bool>();
|
||||
try {
|
||||
room.members = json.at("players").get<std::vector<Room::Member>>();
|
||||
} catch (const nlohmann::detail::out_of_range& e) {
|
||||
LOG_DEBUG(Network, "Out of range %s", e.what());
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace AnnounceMultiplayerRoom
|
||||
|
||||
namespace WebService {
|
||||
|
||||
void RoomJson::SetRoomInformation(const std::string& uid, const std::string& name, const u16 port,
|
||||
const u32 max_player, const u32 net_version,
|
||||
const bool has_password, const std::string& preferred_game,
|
||||
const u64 preferred_game_id) {
|
||||
room.name = name;
|
||||
room.UID = uid;
|
||||
room.port = port;
|
||||
room.max_player = max_player;
|
||||
room.net_version = net_version;
|
||||
room.has_password = has_password;
|
||||
room.preferred_game = preferred_game;
|
||||
room.preferred_game_id = preferred_game_id;
|
||||
}
|
||||
void RoomJson::AddPlayer(const std::string& nickname,
|
||||
const AnnounceMultiplayerRoom::MacAddress& mac_address, const u64 game_id,
|
||||
const std::string& game_name) {
|
||||
AnnounceMultiplayerRoom::Room::Member member;
|
||||
member.name = nickname;
|
||||
member.mac_address = mac_address;
|
||||
member.game_id = game_id;
|
||||
member.game_name = game_name;
|
||||
room.members.push_back(member);
|
||||
}
|
||||
|
||||
std::future<Common::WebResult> RoomJson::Announce() {
|
||||
nlohmann::json json = room;
|
||||
return PostJson(endpoint_url, json.dump(), false, username, token);
|
||||
}
|
||||
|
||||
void RoomJson::ClearPlayers() {
|
||||
room.members.clear();
|
||||
}
|
||||
|
||||
std::future<AnnounceMultiplayerRoom::RoomList> RoomJson::GetRoomList(std::function<void()> func) {
|
||||
auto DeSerialize = [func](const std::string& reply) -> AnnounceMultiplayerRoom::RoomList {
|
||||
nlohmann::json json = nlohmann::json::parse(reply);
|
||||
AnnounceMultiplayerRoom::RoomList room_list =
|
||||
json.at("rooms").get<AnnounceMultiplayerRoom::RoomList>();
|
||||
func();
|
||||
return room_list;
|
||||
};
|
||||
return GetJson<AnnounceMultiplayerRoom::RoomList>(DeSerialize, endpoint_url, true, username,
|
||||
token);
|
||||
}
|
||||
|
||||
void RoomJson::Delete() {
|
||||
nlohmann::json json;
|
||||
json["id"] = room.UID;
|
||||
DeleteJson(endpoint_url, json.dump(), username, token);
|
||||
}
|
||||
|
||||
} // namespace WebService
|
@ -0,0 +1,42 @@
|
||||
// Copyright 2017 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <functional>
|
||||
#include <future>
|
||||
#include <string>
|
||||
#include "common/announce_multiplayer_room.h"
|
||||
|
||||
namespace WebService {
|
||||
|
||||
/**
|
||||
* Implementation of AnnounceMultiplayerRoom::Backend that (de)serializes room information into/from
|
||||
* JSON, and submits/gets it to/from the Citra web service
|
||||
*/
|
||||
class RoomJson : public AnnounceMultiplayerRoom::Backend {
|
||||
public:
|
||||
RoomJson(const std::string& endpoint_url, const std::string& username, const std::string& token)
|
||||
: endpoint_url(endpoint_url), username(username), token(token) {}
|
||||
~RoomJson() = default;
|
||||
void SetRoomInformation(const std::string& uid, const std::string& name, const u16 port,
|
||||
const u32 max_player, const u32 net_version, const bool has_password,
|
||||
const std::string& preferred_game,
|
||||
const u64 preferred_game_id) override;
|
||||
void AddPlayer(const std::string& nickname,
|
||||
const AnnounceMultiplayerRoom::MacAddress& mac_address, const u64 game_id,
|
||||
const std::string& game_name) override;
|
||||
std::future<Common::WebResult> Announce() override;
|
||||
void ClearPlayers() override;
|
||||
std::future<AnnounceMultiplayerRoom::RoomList> GetRoomList(std::function<void()> func) override;
|
||||
void Delete() override;
|
||||
|
||||
private:
|
||||
AnnounceMultiplayerRoom::Room room;
|
||||
std::string endpoint_url;
|
||||
std::string username;
|
||||
std::string token;
|
||||
};
|
||||
|
||||
} // namespace WebService
|
Loading…
Reference in New Issue