Browse Source
Merge pull request #8541 from FearlessTobi/multiplayer-part1
Merge pull request #8541 from FearlessTobi/multiplayer-part1
yuzu, network: Add room service and UI configurationpull/15/merge
liamwhite
4 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
99 changed files with 7503 additions and 32 deletions
-
6.gitmodules
-
9dist/license.md
-
BINdist/qt_themes/colorful/icons/16x16/connected.png
-
BINdist/qt_themes/colorful/icons/16x16/connected_notification.png
-
BINdist/qt_themes/colorful/icons/16x16/disconnected.png
-
3dist/qt_themes/colorful/style.qrc
-
4dist/qt_themes/colorful_dark/style.qrc
-
4dist/qt_themes/default/default.qrc
-
BINdist/qt_themes/default/icons/16x16/connected.png
-
BINdist/qt_themes/default/icons/16x16/connected_notification.png
-
BINdist/qt_themes/default/icons/16x16/disconnected.png
-
BINdist/qt_themes/default/icons/48x48/no_avatar.png
-
BINdist/qt_themes/qdarkstyle/icons/16x16/connected.png
-
BINdist/qt_themes/qdarkstyle/icons/16x16/connected_notification.png
-
BINdist/qt_themes/qdarkstyle/icons/16x16/disconnected.png
-
BINdist/qt_themes/qdarkstyle/icons/48x48/no_avatar.png
-
4dist/qt_themes/qdarkstyle/style.qrc
-
9externals/CMakeLists.txt
-
1externals/cpp-jwt
-
1externals/enet
-
1src/CMakeLists.txt
-
1src/common/CMakeLists.txt
-
143src/common/announce_multiplayer_room.h
-
14src/core/CMakeLists.txt
-
164src/core/announce_multiplayer_session.cpp
-
98src/core/announce_multiplayer_session.h
-
31src/core/core.cpp
-
10src/core/core.h
-
4src/core/hle/service/nifm/nifm.cpp
-
4src/core/hle/service/sockets/bsd.cpp
-
2src/core/hle/service/sockets/bsd.h
-
2src/core/hle/service/sockets/sockets_translate.cpp
-
2src/core/hle/service/sockets/sockets_translate.h
-
6src/core/internal_network/network.cpp
-
0src/core/internal_network/network.h
-
2src/core/internal_network/network_interface.cpp
-
0src/core/internal_network/network_interface.h
-
3src/core/internal_network/sockets.h
-
2src/input_common/helpers/udp_protocol.h
-
16src/network/CMakeLists.txt
-
50src/network/network.cpp
-
33src/network/network.h
-
262src/network/packet.cpp
-
165src/network/packet.h
-
1110src/network/room.cpp
-
151src/network/room.h
-
696src/network/room_member.cpp
-
318src/network/room_member.h
-
17src/network/verify_user.cpp
-
45src/network/verify_user.h
-
2src/tests/CMakeLists.txt
-
4src/tests/core/internal_network/network.cpp
-
6src/web_service/CMakeLists.txt
-
145src/web_service/announce_room_json.cpp
-
41src/web_service/announce_room_json.h
-
67src/web_service/verify_user_jwt.cpp
-
26src/web_service/verify_user_jwt.h
-
32src/yuzu/CMakeLists.txt
-
75src/yuzu/configuration/config.cpp
-
2src/yuzu/configuration/config.h
-
8src/yuzu/configuration/configure_dialog.cpp
-
3src/yuzu/configuration/configure_dialog.h
-
2src/yuzu/configuration/configure_network.cpp
-
5src/yuzu/configuration/configure_web.cpp
-
1src/yuzu/configuration/configure_web.h
-
10src/yuzu/configuration/configure_web.ui
-
6src/yuzu/game_list.cpp
-
8src/yuzu/game_list.h
-
40src/yuzu/main.cpp
-
5src/yuzu/main.h
-
38src/yuzu/main.ui
-
491src/yuzu/multiplayer/chat_room.cpp
-
75src/yuzu/multiplayer/chat_room.h
-
59src/yuzu/multiplayer/chat_room.ui
-
115src/yuzu/multiplayer/client_room.cpp
-
39src/yuzu/multiplayer/client_room.h
-
80src/yuzu/multiplayer/client_room.ui
-
130src/yuzu/multiplayer/direct_connect.cpp
-
43src/yuzu/multiplayer/direct_connect.h
-
168src/yuzu/multiplayer/direct_connect.ui
-
246src/yuzu/multiplayer/host_room.cpp
-
75src/yuzu/multiplayer/host_room.h
-
207src/yuzu/multiplayer/host_room.ui
-
367src/yuzu/multiplayer/lobby.cpp
-
128src/yuzu/multiplayer/lobby.h
-
123src/yuzu/multiplayer/lobby.ui
-
238src/yuzu/multiplayer/lobby_p.h
-
78src/yuzu/multiplayer/message.cpp
-
64src/yuzu/multiplayer/message.h
-
112src/yuzu/multiplayer/moderation_dialog.cpp
-
43src/yuzu/multiplayer/moderation_dialog.h
-
84src/yuzu/multiplayer/moderation_dialog.ui
-
308src/yuzu/multiplayer/state.cpp
-
92src/yuzu/multiplayer/state.h
-
48src/yuzu/multiplayer/validation.h
-
13src/yuzu/uisettings.h
-
11src/yuzu/util/clickable_label.cpp
-
21src/yuzu/util/clickable_label.h
-
158src/yuzu_cmd/yuzu.cpp
|
After Width: 16 | Height: 16 | Size: 362 B |
|
After Width: 16 | Height: 16 | Size: 607 B |
|
After Width: 16 | Height: 16 | Size: 784 B |
|
After Width: 16 | Height: 16 | Size: 269 B |
|
After Width: 16 | Height: 16 | Size: 517 B |
|
After Width: 16 | Height: 16 | Size: 306 B |
|
After Width: 48 | Height: 48 | Size: 588 B |
|
After Width: 18 | Height: 18 | Size: 397 B |
|
After Width: 16 | Height: 16 | Size: 526 B |
|
After Width: 18 | Height: 18 | Size: 444 B |
|
After Width: 48 | Height: 48 | Size: 708 B |
@ -0,0 +1,143 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <array> |
|||
#include <functional> |
|||
#include <string> |
|||
#include <vector> |
|||
#include "common/common_types.h" |
|||
#include "web_service/web_result.h" |
|||
|
|||
namespace AnnounceMultiplayerRoom { |
|||
|
|||
using MacAddress = std::array<u8, 6>; |
|||
|
|||
struct GameInfo { |
|||
std::string name{""}; |
|||
u64 id{0}; |
|||
}; |
|||
|
|||
struct Member { |
|||
std::string username; |
|||
std::string nickname; |
|||
std::string display_name; |
|||
std::string avatar_url; |
|||
MacAddress mac_address; |
|||
GameInfo game; |
|||
}; |
|||
|
|||
struct RoomInformation { |
|||
std::string name; ///< Name of the server |
|||
std::string description; ///< Server description |
|||
u32 member_slots; ///< Maximum number of members in this room |
|||
u16 port; ///< The port of this room |
|||
GameInfo preferred_game; ///< Game to advertise that you want to play |
|||
std::string host_username; ///< Forum username of the host |
|||
bool enable_yuzu_mods; ///< Allow yuzu Moderators to moderate on this room |
|||
}; |
|||
|
|||
struct Room { |
|||
RoomInformation information; |
|||
|
|||
std::string id; |
|||
std::string verify_uid; ///< UID used for verification |
|||
std::string ip; |
|||
u32 net_version; |
|||
bool has_password; |
|||
|
|||
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 { |
|||
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 description The room description |
|||
* @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& name, const std::string& description, |
|||
const u16 port, const u32 max_player, const u32 net_version, |
|||
const bool has_password, const GameInfo& preferred_game) = 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 Member& member) = 0; |
|||
|
|||
/** |
|||
* Updates the data in the announce service. Re-register the room when required. |
|||
* @result The result of the update attempt |
|||
*/ |
|||
virtual WebService::WebResult Update() = 0; |
|||
|
|||
/** |
|||
* Registers the data in the announce service |
|||
* @result The result of the register attempt. When the result code is Success, A global Guid of |
|||
* the room which may be used for verification will be in the result's returned_data. |
|||
*/ |
|||
virtual WebService::WebResult Register() = 0; |
|||
|
|||
/** |
|||
* Empties the stored players |
|||
*/ |
|||
virtual void ClearPlayers() = 0; |
|||
|
|||
/** |
|||
* Get the room information from the announce service |
|||
* @result A list of all rooms the announce service has |
|||
*/ |
|||
virtual RoomList GetRoomList() = 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& /*name*/, const std::string& /*description*/, |
|||
const u16 /*port*/, const u32 /*max_player*/, const u32 /*net_version*/, |
|||
const bool /*has_password*/, |
|||
const GameInfo& /*preferred_game*/) override {} |
|||
void AddPlayer(const Member& /*member*/) override {} |
|||
WebService::WebResult Update() override { |
|||
return WebService::WebResult{WebService::WebResult::Code::NoWebservice, |
|||
"WebService is missing", ""}; |
|||
} |
|||
WebService::WebResult Register() override { |
|||
return WebService::WebResult{WebService::WebResult::Code::NoWebservice, |
|||
"WebService is missing", ""}; |
|||
} |
|||
void ClearPlayers() override {} |
|||
RoomList GetRoomList() override { |
|||
return RoomList{}; |
|||
} |
|||
|
|||
void Delete() override {} |
|||
}; |
|||
|
|||
} // namespace AnnounceMultiplayerRoom |
|||
@ -0,0 +1,164 @@ |
|||
// 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 { |
|||
|
|||
// Time between room is announced to web_service
|
|||
static constexpr std::chrono::seconds announce_time_interval(15); |
|||
|
|||
AnnounceMultiplayerSession::AnnounceMultiplayerSession(Network::RoomNetwork& room_network_) |
|||
: room_network{room_network_} { |
|||
#ifdef ENABLE_WEB_SERVICE
|
|||
backend = std::make_unique<WebService::RoomJson>(Settings::values.web_api_url.GetValue(), |
|||
Settings::values.yuzu_username.GetValue(), |
|||
Settings::values.yuzu_token.GetValue()); |
|||
#else
|
|||
backend = std::make_unique<AnnounceMultiplayerRoom::NullBackend>(); |
|||
#endif
|
|||
} |
|||
|
|||
WebService::WebResult AnnounceMultiplayerSession::Register() { |
|||
std::shared_ptr<Network::Room> room = 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) { |
|||
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(); |
|||
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); |
|||
} |
|||
} |
|||
|
|||
void AnnounceMultiplayerSession::AnnounceMultiplayerLoop() { |
|||
// Invokes all current bound error callbacks.
|
|||
const auto ErrorCallback = [this](WebService::WebResult result) { |
|||
std::lock_guard<std::mutex> 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; |
|||
} |
|||
} |
|||
|
|||
auto update_time = std::chrono::steady_clock::now(); |
|||
std::future<WebService::WebResult> future; |
|||
while (!shutdown_event.WaitUntil(update_time)) { |
|||
update_time += announce_time_interval; |
|||
std::shared_ptr<Network::Room> room = 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); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
AnnounceMultiplayerRoom::RoomList AnnounceMultiplayerSession::GetRoomList() { |
|||
return backend->GetRoomList(); |
|||
} |
|||
|
|||
bool AnnounceMultiplayerSession::IsRunning() const { |
|||
return announce_multiplayer_thread != nullptr; |
|||
} |
|||
|
|||
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.yuzu_username.GetValue(), |
|||
Settings::values.yuzu_token.GetValue()); |
|||
#endif
|
|||
} |
|||
|
|||
} // namespace Core
|
|||
@ -0,0 +1,98 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <atomic> |
|||
#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 Network { |
|||
class Room; |
|||
class RoomNetwork; |
|||
} // namespace Network |
|||
|
|||
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 { |
|||
public: |
|||
using CallbackHandle = std::shared_ptr<std::function<void(const WebService::WebResult&)>>; |
|||
AnnounceMultiplayerSession(Network::RoomNetwork& room_network_); |
|||
~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 WebService::WebResult&)> function); |
|||
|
|||
/** |
|||
* Unbind a function from the error callbacks |
|||
* @param handle The handle for the function that should get unbind |
|||
*/ |
|||
void UnbindErrorCallback(CallbackHandle handle); |
|||
|
|||
/** |
|||
* Registers a room to web services |
|||
* @return The result of the registration attempt. |
|||
*/ |
|||
WebService::WebResult Register(); |
|||
|
|||
/** |
|||
* 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 |
|||
*/ |
|||
AnnounceMultiplayerRoom::RoomList GetRoomList(); |
|||
|
|||
/** |
|||
* Whether the announce session is still running |
|||
*/ |
|||
bool IsRunning() const; |
|||
|
|||
/** |
|||
* Recreates the backend, updating the credentials. |
|||
* This can only be used when the announce session is not running. |
|||
*/ |
|||
void UpdateCredentials(); |
|||
|
|||
private: |
|||
void UpdateBackendData(std::shared_ptr<Network::Room> room); |
|||
void AnnounceMultiplayerLoop(); |
|||
|
|||
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; |
|||
|
|||
std::atomic_bool registered = false; ///< Whether the room has been registered |
|||
|
|||
Network::RoomNetwork& room_network; |
|||
}; |
|||
|
|||
} // namespace Core |
|||
@ -0,0 +1,16 @@ |
|||
add_library(network STATIC |
|||
network.cpp |
|||
network.h |
|||
packet.cpp |
|||
packet.h |
|||
room.cpp |
|||
room.h |
|||
room_member.cpp |
|||
room_member.h |
|||
verify_user.cpp |
|||
verify_user.h |
|||
) |
|||
|
|||
create_target_directory_groups(network) |
|||
|
|||
target_link_libraries(network PRIVATE common enet Boost::boost) |
|||
@ -0,0 +1,50 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include "common/assert.h"
|
|||
#include "common/logging/log.h"
|
|||
#include "enet/enet.h"
|
|||
#include "network/network.h"
|
|||
|
|||
namespace Network { |
|||
|
|||
RoomNetwork::RoomNetwork() { |
|||
m_room = std::make_shared<Room>(); |
|||
m_room_member = std::make_shared<RoomMember>(); |
|||
} |
|||
|
|||
bool RoomNetwork::Init() { |
|||
if (enet_initialize() != 0) { |
|||
LOG_ERROR(Network, "Error initalizing ENet"); |
|||
return false; |
|||
} |
|||
m_room = std::make_shared<Room>(); |
|||
m_room_member = std::make_shared<RoomMember>(); |
|||
LOG_DEBUG(Network, "initialized OK"); |
|||
return true; |
|||
} |
|||
|
|||
std::weak_ptr<Room> RoomNetwork::GetRoom() { |
|||
return m_room; |
|||
} |
|||
|
|||
std::weak_ptr<RoomMember> RoomNetwork::GetRoomMember() { |
|||
return m_room_member; |
|||
} |
|||
|
|||
void RoomNetwork::Shutdown() { |
|||
if (m_room_member) { |
|||
if (m_room_member->IsConnected()) |
|||
m_room_member->Leave(); |
|||
m_room_member.reset(); |
|||
} |
|||
if (m_room) { |
|||
if (m_room->GetState() == Room::State::Open) |
|||
m_room->Destroy(); |
|||
m_room.reset(); |
|||
} |
|||
enet_deinitialize(); |
|||
LOG_DEBUG(Network, "shutdown OK"); |
|||
} |
|||
|
|||
} // namespace Network
|
|||
@ -0,0 +1,33 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include "network/room.h" |
|||
#include "network/room_member.h" |
|||
|
|||
namespace Network { |
|||
|
|||
class RoomNetwork { |
|||
public: |
|||
RoomNetwork(); |
|||
|
|||
/// Initializes and registers the network device, the room, and the room member. |
|||
bool Init(); |
|||
|
|||
/// Returns a pointer to the room handle |
|||
std::weak_ptr<Room> GetRoom(); |
|||
|
|||
/// Returns a pointer to the room member handle |
|||
std::weak_ptr<RoomMember> GetRoomMember(); |
|||
|
|||
/// Unregisters the network device, the room, and the room member and shut them down. |
|||
void Shutdown(); |
|||
|
|||
private: |
|||
std::shared_ptr<RoomMember> m_room_member; ///< RoomMember (Client) for network games |
|||
std::shared_ptr<Room> m_room; ///< Room (Server) for network games |
|||
}; |
|||
|
|||
} // namespace Network |
|||
@ -0,0 +1,262 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#ifdef _WIN32
|
|||
#include <winsock2.h>
|
|||
#else
|
|||
#include <arpa/inet.h>
|
|||
#endif
|
|||
#include <cstring>
|
|||
#include <string>
|
|||
#include "network/packet.h"
|
|||
|
|||
namespace Network { |
|||
|
|||
#ifndef htonll
|
|||
static u64 htonll(u64 x) { |
|||
return ((1 == htonl(1)) ? (x) : ((uint64_t)htonl((x)&0xFFFFFFFF) << 32) | htonl((x) >> 32)); |
|||
} |
|||
#endif
|
|||
|
|||
#ifndef ntohll
|
|||
static u64 ntohll(u64 x) { |
|||
return ((1 == ntohl(1)) ? (x) : ((uint64_t)ntohl((x)&0xFFFFFFFF) << 32) | ntohl((x) >> 32)); |
|||
} |
|||
#endif
|
|||
|
|||
void Packet::Append(const void* in_data, std::size_t size_in_bytes) { |
|||
if (in_data && (size_in_bytes > 0)) { |
|||
std::size_t start = data.size(); |
|||
data.resize(start + size_in_bytes); |
|||
std::memcpy(&data[start], in_data, size_in_bytes); |
|||
} |
|||
} |
|||
|
|||
void Packet::Read(void* out_data, std::size_t size_in_bytes) { |
|||
if (out_data && CheckSize(size_in_bytes)) { |
|||
std::memcpy(out_data, &data[read_pos], size_in_bytes); |
|||
read_pos += size_in_bytes; |
|||
} |
|||
} |
|||
|
|||
void Packet::Clear() { |
|||
data.clear(); |
|||
read_pos = 0; |
|||
is_valid = true; |
|||
} |
|||
|
|||
const void* Packet::GetData() const { |
|||
return !data.empty() ? &data[0] : nullptr; |
|||
} |
|||
|
|||
void Packet::IgnoreBytes(u32 length) { |
|||
read_pos += length; |
|||
} |
|||
|
|||
std::size_t Packet::GetDataSize() const { |
|||
return data.size(); |
|||
} |
|||
|
|||
bool Packet::EndOfPacket() const { |
|||
return read_pos >= data.size(); |
|||
} |
|||
|
|||
Packet::operator bool() const { |
|||
return is_valid; |
|||
} |
|||
|
|||
Packet& Packet::Read(bool& out_data) { |
|||
u8 value{}; |
|||
if (Read(value)) { |
|||
out_data = (value != 0); |
|||
} |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(s8& out_data) { |
|||
Read(&out_data, sizeof(out_data)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(u8& out_data) { |
|||
Read(&out_data, sizeof(out_data)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(s16& out_data) { |
|||
s16 value{}; |
|||
Read(&value, sizeof(value)); |
|||
out_data = ntohs(value); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(u16& out_data) { |
|||
u16 value{}; |
|||
Read(&value, sizeof(value)); |
|||
out_data = ntohs(value); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(s32& out_data) { |
|||
s32 value{}; |
|||
Read(&value, sizeof(value)); |
|||
out_data = ntohl(value); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(u32& out_data) { |
|||
u32 value{}; |
|||
Read(&value, sizeof(value)); |
|||
out_data = ntohl(value); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(s64& out_data) { |
|||
s64 value{}; |
|||
Read(&value, sizeof(value)); |
|||
out_data = ntohll(value); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(u64& out_data) { |
|||
u64 value{}; |
|||
Read(&value, sizeof(value)); |
|||
out_data = ntohll(value); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(float& out_data) { |
|||
Read(&out_data, sizeof(out_data)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(double& out_data) { |
|||
Read(&out_data, sizeof(out_data)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(char* out_data) { |
|||
// First extract string length
|
|||
u32 length = 0; |
|||
Read(length); |
|||
|
|||
if ((length > 0) && CheckSize(length)) { |
|||
// Then extract characters
|
|||
std::memcpy(out_data, &data[read_pos], length); |
|||
out_data[length] = '\0'; |
|||
|
|||
// Update reading position
|
|||
read_pos += length; |
|||
} |
|||
|
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Read(std::string& out_data) { |
|||
// First extract string length
|
|||
u32 length = 0; |
|||
Read(length); |
|||
|
|||
out_data.clear(); |
|||
if ((length > 0) && CheckSize(length)) { |
|||
// Then extract characters
|
|||
out_data.assign(&data[read_pos], length); |
|||
|
|||
// Update reading position
|
|||
read_pos += length; |
|||
} |
|||
|
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(bool in_data) { |
|||
Write(static_cast<u8>(in_data)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(s8 in_data) { |
|||
Append(&in_data, sizeof(in_data)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(u8 in_data) { |
|||
Append(&in_data, sizeof(in_data)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(s16 in_data) { |
|||
s16 toWrite = htons(in_data); |
|||
Append(&toWrite, sizeof(toWrite)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(u16 in_data) { |
|||
u16 toWrite = htons(in_data); |
|||
Append(&toWrite, sizeof(toWrite)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(s32 in_data) { |
|||
s32 toWrite = htonl(in_data); |
|||
Append(&toWrite, sizeof(toWrite)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(u32 in_data) { |
|||
u32 toWrite = htonl(in_data); |
|||
Append(&toWrite, sizeof(toWrite)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(s64 in_data) { |
|||
s64 toWrite = htonll(in_data); |
|||
Append(&toWrite, sizeof(toWrite)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(u64 in_data) { |
|||
u64 toWrite = htonll(in_data); |
|||
Append(&toWrite, sizeof(toWrite)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(float in_data) { |
|||
Append(&in_data, sizeof(in_data)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(double in_data) { |
|||
Append(&in_data, sizeof(in_data)); |
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(const char* in_data) { |
|||
// First insert string length
|
|||
u32 length = static_cast<u32>(std::strlen(in_data)); |
|||
Write(length); |
|||
|
|||
// Then insert characters
|
|||
Append(in_data, length * sizeof(char)); |
|||
|
|||
return *this; |
|||
} |
|||
|
|||
Packet& Packet::Write(const std::string& in_data) { |
|||
// First insert string length
|
|||
u32 length = static_cast<u32>(in_data.size()); |
|||
Write(length); |
|||
|
|||
// Then insert characters
|
|||
if (length > 0) |
|||
Append(in_data.c_str(), length * sizeof(std::string::value_type)); |
|||
|
|||
return *this; |
|||
} |
|||
|
|||
bool Packet::CheckSize(std::size_t size) { |
|||
is_valid = is_valid && (read_pos + size <= data.size()); |
|||
|
|||
return is_valid; |
|||
} |
|||
|
|||
} // namespace Network
|
|||
@ -0,0 +1,165 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <array> |
|||
#include <vector> |
|||
#include "common/common_types.h" |
|||
|
|||
namespace Network { |
|||
|
|||
/// A class that serializes data for network transfer. It also handles endianess |
|||
class Packet { |
|||
public: |
|||
Packet() = default; |
|||
~Packet() = default; |
|||
|
|||
/** |
|||
* Append data to the end of the packet |
|||
* @param data Pointer to the sequence of bytes to append |
|||
* @param size_in_bytes Number of bytes to append |
|||
*/ |
|||
void Append(const void* data, std::size_t size_in_bytes); |
|||
|
|||
/** |
|||
* Reads data from the current read position of the packet |
|||
* @param out_data Pointer where the data should get written to |
|||
* @param size_in_bytes Number of bytes to read |
|||
*/ |
|||
void Read(void* out_data, std::size_t size_in_bytes); |
|||
|
|||
/** |
|||
* Clear the packet |
|||
* After calling Clear, the packet is empty. |
|||
*/ |
|||
void Clear(); |
|||
|
|||
/** |
|||
* Ignores bytes while reading |
|||
* @param length THe number of bytes to ignore |
|||
*/ |
|||
void IgnoreBytes(u32 length); |
|||
|
|||
/** |
|||
* Get a pointer to the data contained in the packet |
|||
* @return Pointer to the data |
|||
*/ |
|||
const void* GetData() const; |
|||
|
|||
/** |
|||
* This function returns the number of bytes pointed to by |
|||
* what getData returns. |
|||
* @return Data size, in bytes |
|||
*/ |
|||
std::size_t GetDataSize() const; |
|||
|
|||
/** |
|||
* This function is useful to know if there is some data |
|||
* left to be read, without actually reading it. |
|||
* @return True if all data was read, false otherwise |
|||
*/ |
|||
bool EndOfPacket() const; |
|||
|
|||
explicit operator bool() const; |
|||
|
|||
/// Overloads of read function to read data from the packet |
|||
Packet& Read(bool& out_data); |
|||
Packet& Read(s8& out_data); |
|||
Packet& Read(u8& out_data); |
|||
Packet& Read(s16& out_data); |
|||
Packet& Read(u16& out_data); |
|||
Packet& Read(s32& out_data); |
|||
Packet& Read(u32& out_data); |
|||
Packet& Read(s64& out_data); |
|||
Packet& Read(u64& out_data); |
|||
Packet& Read(float& out_data); |
|||
Packet& Read(double& out_data); |
|||
Packet& Read(char* out_data); |
|||
Packet& Read(std::string& out_data); |
|||
template <typename T> |
|||
Packet& Read(std::vector<T>& out_data); |
|||
template <typename T, std::size_t S> |
|||
Packet& Read(std::array<T, S>& out_data); |
|||
|
|||
/// Overloads of write function to write data into the packet |
|||
Packet& Write(bool in_data); |
|||
Packet& Write(s8 in_data); |
|||
Packet& Write(u8 in_data); |
|||
Packet& Write(s16 in_data); |
|||
Packet& Write(u16 in_data); |
|||
Packet& Write(s32 in_data); |
|||
Packet& Write(u32 in_data); |
|||
Packet& Write(s64 in_data); |
|||
Packet& Write(u64 in_data); |
|||
Packet& Write(float in_data); |
|||
Packet& Write(double in_data); |
|||
Packet& Write(const char* in_data); |
|||
Packet& Write(const std::string& in_data); |
|||
template <typename T> |
|||
Packet& Write(const std::vector<T>& in_data); |
|||
template <typename T, std::size_t S> |
|||
Packet& Write(const std::array<T, S>& data); |
|||
|
|||
private: |
|||
/** |
|||
* Check if the packet can extract a given number of bytes |
|||
* This function updates accordingly the state of the packet. |
|||
* @param size Size to check |
|||
* @return True if size bytes can be read from the packet |
|||
*/ |
|||
bool CheckSize(std::size_t size); |
|||
|
|||
// Member data |
|||
std::vector<char> data; ///< Data stored in the packet |
|||
std::size_t read_pos = 0; ///< Current reading position in the packet |
|||
bool is_valid = true; ///< Reading state of the packet |
|||
}; |
|||
|
|||
template <typename T> |
|||
Packet& Packet::Read(std::vector<T>& out_data) { |
|||
// First extract the size |
|||
u32 size = 0; |
|||
Read(size); |
|||
out_data.resize(size); |
|||
|
|||
// Then extract the data |
|||
for (std::size_t i = 0; i < out_data.size(); ++i) { |
|||
T character; |
|||
Read(character); |
|||
out_data[i] = character; |
|||
} |
|||
return *this; |
|||
} |
|||
|
|||
template <typename T, std::size_t S> |
|||
Packet& Packet::Read(std::array<T, S>& out_data) { |
|||
for (std::size_t i = 0; i < out_data.size(); ++i) { |
|||
T character; |
|||
Read(character); |
|||
out_data[i] = character; |
|||
} |
|||
return *this; |
|||
} |
|||
|
|||
template <typename T> |
|||
Packet& Packet::Write(const std::vector<T>& in_data) { |
|||
// First insert the size |
|||
Write(static_cast<u32>(in_data.size())); |
|||
|
|||
// Then insert the data |
|||
for (std::size_t i = 0; i < in_data.size(); ++i) { |
|||
Write(in_data[i]); |
|||
} |
|||
return *this; |
|||
} |
|||
|
|||
template <typename T, std::size_t S> |
|||
Packet& Packet::Write(const std::array<T, S>& in_data) { |
|||
for (std::size_t i = 0; i < in_data.size(); ++i) { |
|||
Write(in_data[i]); |
|||
} |
|||
return *this; |
|||
} |
|||
|
|||
} // namespace Network |
|||
1110
src/network/room.cpp
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,151 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <array> |
|||
#include <memory> |
|||
#include <string> |
|||
#include <vector> |
|||
#include "common/announce_multiplayer_room.h" |
|||
#include "common/common_types.h" |
|||
#include "network/verify_user.h" |
|||
|
|||
namespace Network { |
|||
|
|||
using AnnounceMultiplayerRoom::GameInfo; |
|||
using AnnounceMultiplayerRoom::MacAddress; |
|||
using AnnounceMultiplayerRoom::Member; |
|||
using AnnounceMultiplayerRoom::RoomInformation; |
|||
|
|||
constexpr u32 network_version = 1; ///< The version of this Room and RoomMember |
|||
|
|||
constexpr u16 DefaultRoomPort = 24872; |
|||
|
|||
constexpr u32 MaxMessageSize = 500; |
|||
|
|||
/// Maximum number of concurrent connections allowed to this room. |
|||
static constexpr u32 MaxConcurrentConnections = 254; |
|||
|
|||
constexpr std::size_t NumChannels = 1; // Number of channels used for the connection |
|||
|
|||
/// A special MAC address that tells the room we're joining to assign us a MAC address |
|||
/// automatically. |
|||
constexpr MacAddress NoPreferredMac = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; |
|||
|
|||
// 802.11 broadcast MAC address |
|||
constexpr MacAddress BroadcastMac = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; |
|||
|
|||
// The different types of messages that can be sent. The first byte of each packet defines the type |
|||
enum RoomMessageTypes : u8 { |
|||
IdJoinRequest = 1, |
|||
IdJoinSuccess, |
|||
IdRoomInformation, |
|||
IdSetGameInfo, |
|||
IdWifiPacket, |
|||
IdChatMessage, |
|||
IdNameCollision, |
|||
IdMacCollision, |
|||
IdVersionMismatch, |
|||
IdWrongPassword, |
|||
IdCloseRoom, |
|||
IdRoomIsFull, |
|||
IdConsoleIdCollision, |
|||
IdStatusMessage, |
|||
IdHostKicked, |
|||
IdHostBanned, |
|||
/// Moderation requests |
|||
IdModKick, |
|||
IdModBan, |
|||
IdModUnban, |
|||
IdModGetBanList, |
|||
// Moderation responses |
|||
IdModBanListResponse, |
|||
IdModPermissionDenied, |
|||
IdModNoSuchUser, |
|||
IdJoinSuccessAsMod, |
|||
}; |
|||
|
|||
/// Types of system status messages |
|||
enum StatusMessageTypes : u8 { |
|||
IdMemberJoin = 1, ///< Member joining |
|||
IdMemberLeave, ///< Member leaving |
|||
IdMemberKicked, ///< A member is kicked from the room |
|||
IdMemberBanned, ///< A member is banned from the room |
|||
IdAddressUnbanned, ///< A username / ip address is unbanned from the room |
|||
}; |
|||
|
|||
/// This is what a server [person creating a server] would use. |
|||
class Room final { |
|||
public: |
|||
enum class State : u8 { |
|||
Open, ///< The room is open and ready to accept connections. |
|||
Closed, ///< The room is not opened and can not accept connections. |
|||
}; |
|||
|
|||
Room(); |
|||
~Room(); |
|||
|
|||
/** |
|||
* Gets the current state of the room. |
|||
*/ |
|||
State GetState() const; |
|||
|
|||
/** |
|||
* Gets the room information of the room. |
|||
*/ |
|||
const RoomInformation& GetRoomInformation() const; |
|||
|
|||
/** |
|||
* Gets the verify UID of this room. |
|||
*/ |
|||
std::string GetVerifyUID() const; |
|||
|
|||
/** |
|||
* Gets a list of the mbmers connected to the room. |
|||
*/ |
|||
std::vector<Member> GetRoomMemberList() const; |
|||
|
|||
/** |
|||
* Checks if the room is password protected |
|||
*/ |
|||
bool HasPassword() const; |
|||
|
|||
using UsernameBanList = std::vector<std::string>; |
|||
using IPBanList = std::vector<std::string>; |
|||
|
|||
using BanList = std::pair<UsernameBanList, IPBanList>; |
|||
|
|||
/** |
|||
* Creates the socket for this room. Will bind to default address if |
|||
* server is empty string. |
|||
*/ |
|||
bool Create(const std::string& name, const std::string& description = "", |
|||
const std::string& server = "", u16 server_port = DefaultRoomPort, |
|||
const std::string& password = "", |
|||
const u32 max_connections = MaxConcurrentConnections, |
|||
const std::string& host_username = "", const GameInfo = {}, |
|||
std::unique_ptr<VerifyUser::Backend> verify_backend = nullptr, |
|||
const BanList& ban_list = {}, bool enable_yuzu_mods = false); |
|||
|
|||
/** |
|||
* Sets the verification GUID of the room. |
|||
*/ |
|||
void SetVerifyUID(const std::string& uid); |
|||
|
|||
/** |
|||
* Gets the ban list (including banned forum usernames and IPs) of the room. |
|||
*/ |
|||
BanList GetBanList() const; |
|||
|
|||
/** |
|||
* Destroys the socket |
|||
*/ |
|||
void Destroy(); |
|||
|
|||
private: |
|||
class RoomImpl; |
|||
std::unique_ptr<RoomImpl> room_impl; |
|||
}; |
|||
|
|||
} // namespace Network |
|||
@ -0,0 +1,696 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <atomic>
|
|||
#include <list>
|
|||
#include <mutex>
|
|||
#include <set>
|
|||
#include <thread>
|
|||
#include "common/assert.h"
|
|||
#include "enet/enet.h"
|
|||
#include "network/packet.h"
|
|||
#include "network/room_member.h"
|
|||
|
|||
namespace Network { |
|||
|
|||
constexpr u32 ConnectionTimeoutMs = 5000; |
|||
|
|||
class RoomMember::RoomMemberImpl { |
|||
public: |
|||
ENetHost* client = nullptr; ///< ENet network interface.
|
|||
ENetPeer* server = nullptr; ///< The server peer the client is connected to
|
|||
|
|||
/// Information about the clients connected to the same room as us.
|
|||
MemberList member_information; |
|||
/// Information about the room we're connected to.
|
|||
RoomInformation room_information; |
|||
|
|||
/// The current game name, id and version
|
|||
GameInfo current_game_info; |
|||
|
|||
std::atomic<State> state{State::Idle}; ///< Current state of the RoomMember.
|
|||
void SetState(const State new_state); |
|||
void SetError(const Error new_error); |
|||
bool IsConnected() const; |
|||
|
|||
std::string nickname; ///< The nickname of this member.
|
|||
|
|||
std::string username; ///< The username of this member.
|
|||
mutable std::mutex username_mutex; ///< Mutex for locking username.
|
|||
|
|||
MacAddress mac_address; ///< The mac_address of this member.
|
|||
|
|||
std::mutex network_mutex; ///< Mutex that controls access to the `client` variable.
|
|||
/// Thread that receives and dispatches network packets
|
|||
std::unique_ptr<std::thread> loop_thread; |
|||
std::mutex send_list_mutex; ///< Mutex that controls access to the `send_list` variable.
|
|||
std::list<Packet> send_list; ///< A list that stores all packets to send the async
|
|||
|
|||
template <typename T> |
|||
using CallbackSet = std::set<CallbackHandle<T>>; |
|||
std::mutex callback_mutex; ///< The mutex used for handling callbacks
|
|||
|
|||
class Callbacks { |
|||
public: |
|||
template <typename T> |
|||
CallbackSet<T>& Get(); |
|||
|
|||
private: |
|||
CallbackSet<WifiPacket> callback_set_wifi_packet; |
|||
CallbackSet<ChatEntry> callback_set_chat_messages; |
|||
CallbackSet<StatusMessageEntry> callback_set_status_messages; |
|||
CallbackSet<RoomInformation> callback_set_room_information; |
|||
CallbackSet<State> callback_set_state; |
|||
CallbackSet<Error> callback_set_error; |
|||
CallbackSet<Room::BanList> callback_set_ban_list; |
|||
}; |
|||
Callbacks callbacks; ///< All CallbackSets to all events
|
|||
|
|||
void MemberLoop(); |
|||
|
|||
void StartLoop(); |
|||
|
|||
/**
|
|||
* Sends data to the room. It will be send on channel 0 with flag RELIABLE |
|||
* @param packet The data to send |
|||
*/ |
|||
void Send(Packet&& packet); |
|||
|
|||
/**
|
|||
* Sends a request to the server, asking for permission to join a room with the specified |
|||
* nickname and preferred mac. |
|||
* @params nickname The desired nickname. |
|||
* @params console_id_hash A hash of the Console ID. |
|||
* @params preferred_mac The preferred MAC address to use in the room, the NoPreferredMac tells |
|||
* @params password The password for the room |
|||
* the server to assign one for us. |
|||
*/ |
|||
void SendJoinRequest(const std::string& nickname_, const std::string& console_id_hash, |
|||
const MacAddress& preferred_mac = NoPreferredMac, |
|||
const std::string& password = "", const std::string& token = ""); |
|||
|
|||
/**
|
|||
* Extracts a MAC Address from a received ENet packet. |
|||
* @param event The ENet event that was received. |
|||
*/ |
|||
void HandleJoinPacket(const ENetEvent* event); |
|||
/**
|
|||
* Extracts RoomInformation and MemberInformation from a received ENet packet. |
|||
* @param event The ENet event that was received. |
|||
*/ |
|||
void HandleRoomInformationPacket(const ENetEvent* event); |
|||
|
|||
/**
|
|||
* Extracts a WifiPacket from a received ENet packet. |
|||
* @param event The ENet event that was received. |
|||
*/ |
|||
void HandleWifiPackets(const ENetEvent* event); |
|||
|
|||
/**
|
|||
* Extracts a chat entry from a received ENet packet and adds it to the chat queue. |
|||
* @param event The ENet event that was received. |
|||
*/ |
|||
void HandleChatPacket(const ENetEvent* event); |
|||
|
|||
/**
|
|||
* Extracts a system message entry from a received ENet packet and adds it to the system message |
|||
* queue. |
|||
* @param event The ENet event that was received. |
|||
*/ |
|||
void HandleStatusMessagePacket(const ENetEvent* event); |
|||
|
|||
/**
|
|||
* Extracts a ban list request response from a received ENet packet. |
|||
* @param event The ENet event that was received. |
|||
*/ |
|||
void HandleModBanListResponsePacket(const ENetEvent* event); |
|||
|
|||
/**
|
|||
* Disconnects the RoomMember from the Room |
|||
*/ |
|||
void Disconnect(); |
|||
|
|||
template <typename T> |
|||
void Invoke(const T& data); |
|||
|
|||
template <typename T> |
|||
CallbackHandle<T> Bind(std::function<void(const T&)> callback); |
|||
}; |
|||
|
|||
// RoomMemberImpl
|
|||
void RoomMember::RoomMemberImpl::SetState(const State new_state) { |
|||
if (state != new_state) { |
|||
state = new_state; |
|||
Invoke<State>(state); |
|||
} |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::SetError(const Error new_error) { |
|||
Invoke<Error>(new_error); |
|||
} |
|||
|
|||
bool RoomMember::RoomMemberImpl::IsConnected() const { |
|||
return state == State::Joining || state == State::Joined || state == State::Moderator; |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::MemberLoop() { |
|||
// Receive packets while the connection is open
|
|||
while (IsConnected()) { |
|||
std::lock_guard lock(network_mutex); |
|||
ENetEvent event; |
|||
if (enet_host_service(client, &event, 16) > 0) { |
|||
switch (event.type) { |
|||
case ENET_EVENT_TYPE_RECEIVE: |
|||
switch (event.packet->data[0]) { |
|||
case IdWifiPacket: |
|||
HandleWifiPackets(&event); |
|||
break; |
|||
case IdChatMessage: |
|||
HandleChatPacket(&event); |
|||
break; |
|||
case IdStatusMessage: |
|||
HandleStatusMessagePacket(&event); |
|||
break; |
|||
case IdRoomInformation: |
|||
HandleRoomInformationPacket(&event); |
|||
break; |
|||
case IdJoinSuccess: |
|||
case IdJoinSuccessAsMod: |
|||
// The join request was successful, we are now in the room.
|
|||
// If we joined successfully, there must be at least one client in the room: us.
|
|||
ASSERT_MSG(member_information.size() > 0, |
|||
"We have not yet received member information."); |
|||
HandleJoinPacket(&event); // Get the MAC Address for the client
|
|||
if (event.packet->data[0] == IdJoinSuccessAsMod) { |
|||
SetState(State::Moderator); |
|||
} else { |
|||
SetState(State::Joined); |
|||
} |
|||
break; |
|||
case IdModBanListResponse: |
|||
HandleModBanListResponsePacket(&event); |
|||
break; |
|||
case IdRoomIsFull: |
|||
SetState(State::Idle); |
|||
SetError(Error::RoomIsFull); |
|||
break; |
|||
case IdNameCollision: |
|||
SetState(State::Idle); |
|||
SetError(Error::NameCollision); |
|||
break; |
|||
case IdMacCollision: |
|||
SetState(State::Idle); |
|||
SetError(Error::MacCollision); |
|||
break; |
|||
case IdConsoleIdCollision: |
|||
SetState(State::Idle); |
|||
SetError(Error::ConsoleIdCollision); |
|||
break; |
|||
case IdVersionMismatch: |
|||
SetState(State::Idle); |
|||
SetError(Error::WrongVersion); |
|||
break; |
|||
case IdWrongPassword: |
|||
SetState(State::Idle); |
|||
SetError(Error::WrongPassword); |
|||
break; |
|||
case IdCloseRoom: |
|||
SetState(State::Idle); |
|||
SetError(Error::LostConnection); |
|||
break; |
|||
case IdHostKicked: |
|||
SetState(State::Idle); |
|||
SetError(Error::HostKicked); |
|||
break; |
|||
case IdHostBanned: |
|||
SetState(State::Idle); |
|||
SetError(Error::HostBanned); |
|||
break; |
|||
case IdModPermissionDenied: |
|||
SetError(Error::PermissionDenied); |
|||
break; |
|||
case IdModNoSuchUser: |
|||
SetError(Error::NoSuchUser); |
|||
break; |
|||
} |
|||
enet_packet_destroy(event.packet); |
|||
break; |
|||
case ENET_EVENT_TYPE_DISCONNECT: |
|||
if (state == State::Joined || state == State::Moderator) { |
|||
SetState(State::Idle); |
|||
SetError(Error::LostConnection); |
|||
} |
|||
break; |
|||
case ENET_EVENT_TYPE_NONE: |
|||
break; |
|||
case ENET_EVENT_TYPE_CONNECT: |
|||
// The ENET_EVENT_TYPE_CONNECT event can not possibly happen here because we're
|
|||
// already connected
|
|||
ASSERT_MSG(false, "Received unexpected connect event while already connected"); |
|||
break; |
|||
} |
|||
} |
|||
std::list<Packet> packets; |
|||
{ |
|||
std::lock_guard send_lock(send_list_mutex); |
|||
packets.swap(send_list); |
|||
} |
|||
for (const auto& packet : packets) { |
|||
ENetPacket* enetPacket = enet_packet_create(packet.GetData(), packet.GetDataSize(), |
|||
ENET_PACKET_FLAG_RELIABLE); |
|||
enet_peer_send(server, 0, enetPacket); |
|||
} |
|||
enet_host_flush(client); |
|||
} |
|||
Disconnect(); |
|||
}; |
|||
|
|||
void RoomMember::RoomMemberImpl::StartLoop() { |
|||
loop_thread = std::make_unique<std::thread>(&RoomMember::RoomMemberImpl::MemberLoop, this); |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::Send(Packet&& packet) { |
|||
std::lock_guard lock(send_list_mutex); |
|||
send_list.push_back(std::move(packet)); |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::SendJoinRequest(const std::string& nickname_, |
|||
const std::string& console_id_hash, |
|||
const MacAddress& preferred_mac, |
|||
const std::string& password, |
|||
const std::string& token) { |
|||
Packet packet; |
|||
packet.Write(static_cast<u8>(IdJoinRequest)); |
|||
packet.Write(nickname_); |
|||
packet.Write(console_id_hash); |
|||
packet.Write(preferred_mac); |
|||
packet.Write(network_version); |
|||
packet.Write(password); |
|||
packet.Write(token); |
|||
Send(std::move(packet)); |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::HandleRoomInformationPacket(const ENetEvent* event) { |
|||
Packet packet; |
|||
packet.Append(event->packet->data, event->packet->dataLength); |
|||
|
|||
// Ignore the first byte, which is the message id.
|
|||
packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
|
|||
|
|||
RoomInformation info{}; |
|||
packet.Read(info.name); |
|||
packet.Read(info.description); |
|||
packet.Read(info.member_slots); |
|||
packet.Read(info.port); |
|||
packet.Read(info.preferred_game.name); |
|||
packet.Read(info.host_username); |
|||
room_information.name = info.name; |
|||
room_information.description = info.description; |
|||
room_information.member_slots = info.member_slots; |
|||
room_information.port = info.port; |
|||
room_information.preferred_game = info.preferred_game; |
|||
room_information.host_username = info.host_username; |
|||
|
|||
u32 num_members; |
|||
packet.Read(num_members); |
|||
member_information.resize(num_members); |
|||
|
|||
for (auto& member : member_information) { |
|||
packet.Read(member.nickname); |
|||
packet.Read(member.mac_address); |
|||
packet.Read(member.game_info.name); |
|||
packet.Read(member.game_info.id); |
|||
packet.Read(member.username); |
|||
packet.Read(member.display_name); |
|||
packet.Read(member.avatar_url); |
|||
|
|||
{ |
|||
std::lock_guard lock(username_mutex); |
|||
if (member.nickname == nickname) { |
|||
username = member.username; |
|||
} |
|||
} |
|||
} |
|||
Invoke(room_information); |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::HandleJoinPacket(const ENetEvent* event) { |
|||
Packet packet; |
|||
packet.Append(event->packet->data, event->packet->dataLength); |
|||
|
|||
// Ignore the first byte, which is the message id.
|
|||
packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
|
|||
|
|||
// Parse the MAC Address from the packet
|
|||
packet.Read(mac_address); |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::HandleWifiPackets(const ENetEvent* event) { |
|||
WifiPacket wifi_packet{}; |
|||
Packet packet; |
|||
packet.Append(event->packet->data, event->packet->dataLength); |
|||
|
|||
// Ignore the first byte, which is the message id.
|
|||
packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
|
|||
|
|||
// Parse the WifiPacket from the packet
|
|||
u8 frame_type; |
|||
packet.Read(frame_type); |
|||
WifiPacket::PacketType type = static_cast<WifiPacket::PacketType>(frame_type); |
|||
|
|||
wifi_packet.type = type; |
|||
packet.Read(wifi_packet.channel); |
|||
packet.Read(wifi_packet.transmitter_address); |
|||
packet.Read(wifi_packet.destination_address); |
|||
packet.Read(wifi_packet.data); |
|||
|
|||
Invoke<WifiPacket>(wifi_packet); |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::HandleChatPacket(const ENetEvent* event) { |
|||
Packet packet; |
|||
packet.Append(event->packet->data, event->packet->dataLength); |
|||
|
|||
// Ignore the first byte, which is the message id.
|
|||
packet.IgnoreBytes(sizeof(u8)); |
|||
|
|||
ChatEntry chat_entry{}; |
|||
packet.Read(chat_entry.nickname); |
|||
packet.Read(chat_entry.username); |
|||
packet.Read(chat_entry.message); |
|||
Invoke<ChatEntry>(chat_entry); |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::HandleStatusMessagePacket(const ENetEvent* event) { |
|||
Packet packet; |
|||
packet.Append(event->packet->data, event->packet->dataLength); |
|||
|
|||
// Ignore the first byte, which is the message id.
|
|||
packet.IgnoreBytes(sizeof(u8)); |
|||
|
|||
StatusMessageEntry status_message_entry{}; |
|||
u8 type{}; |
|||
packet.Read(type); |
|||
status_message_entry.type = static_cast<StatusMessageTypes>(type); |
|||
packet.Read(status_message_entry.nickname); |
|||
packet.Read(status_message_entry.username); |
|||
Invoke<StatusMessageEntry>(status_message_entry); |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::HandleModBanListResponsePacket(const ENetEvent* event) { |
|||
Packet packet; |
|||
packet.Append(event->packet->data, event->packet->dataLength); |
|||
|
|||
// Ignore the first byte, which is the message id.
|
|||
packet.IgnoreBytes(sizeof(u8)); |
|||
|
|||
Room::BanList ban_list = {}; |
|||
packet.Read(ban_list.first); |
|||
packet.Read(ban_list.second); |
|||
Invoke<Room::BanList>(ban_list); |
|||
} |
|||
|
|||
void RoomMember::RoomMemberImpl::Disconnect() { |
|||
member_information.clear(); |
|||
room_information.member_slots = 0; |
|||
room_information.name.clear(); |
|||
|
|||
if (!server) { |
|||
return; |
|||
} |
|||
enet_peer_disconnect(server, 0); |
|||
|
|||
ENetEvent event; |
|||
while (enet_host_service(client, &event, ConnectionTimeoutMs) > 0) { |
|||
switch (event.type) { |
|||
case ENET_EVENT_TYPE_RECEIVE: |
|||
enet_packet_destroy(event.packet); // Ignore all incoming data
|
|||
break; |
|||
case ENET_EVENT_TYPE_DISCONNECT: |
|||
server = nullptr; |
|||
return; |
|||
case ENET_EVENT_TYPE_NONE: |
|||
case ENET_EVENT_TYPE_CONNECT: |
|||
break; |
|||
} |
|||
} |
|||
// didn't disconnect gracefully force disconnect
|
|||
enet_peer_reset(server); |
|||
server = nullptr; |
|||
} |
|||
|
|||
template <> |
|||
RoomMember::RoomMemberImpl::CallbackSet<WifiPacket>& RoomMember::RoomMemberImpl::Callbacks::Get() { |
|||
return callback_set_wifi_packet; |
|||
} |
|||
|
|||
template <> |
|||
RoomMember::RoomMemberImpl::CallbackSet<RoomMember::State>& |
|||
RoomMember::RoomMemberImpl::Callbacks::Get() { |
|||
return callback_set_state; |
|||
} |
|||
|
|||
template <> |
|||
RoomMember::RoomMemberImpl::CallbackSet<RoomMember::Error>& |
|||
RoomMember::RoomMemberImpl::Callbacks::Get() { |
|||
return callback_set_error; |
|||
} |
|||
|
|||
template <> |
|||
RoomMember::RoomMemberImpl::CallbackSet<RoomInformation>& |
|||
RoomMember::RoomMemberImpl::Callbacks::Get() { |
|||
return callback_set_room_information; |
|||
} |
|||
|
|||
template <> |
|||
RoomMember::RoomMemberImpl::CallbackSet<ChatEntry>& RoomMember::RoomMemberImpl::Callbacks::Get() { |
|||
return callback_set_chat_messages; |
|||
} |
|||
|
|||
template <> |
|||
RoomMember::RoomMemberImpl::CallbackSet<StatusMessageEntry>& |
|||
RoomMember::RoomMemberImpl::Callbacks::Get() { |
|||
return callback_set_status_messages; |
|||
} |
|||
|
|||
template <> |
|||
RoomMember::RoomMemberImpl::CallbackSet<Room::BanList>& |
|||
RoomMember::RoomMemberImpl::Callbacks::Get() { |
|||
return callback_set_ban_list; |
|||
} |
|||
|
|||
template <typename T> |
|||
void RoomMember::RoomMemberImpl::Invoke(const T& data) { |
|||
std::lock_guard lock(callback_mutex); |
|||
CallbackSet<T> callback_set = callbacks.Get<T>(); |
|||
for (auto const& callback : callback_set) { |
|||
(*callback)(data); |
|||
} |
|||
} |
|||
|
|||
template <typename T> |
|||
RoomMember::CallbackHandle<T> RoomMember::RoomMemberImpl::Bind( |
|||
std::function<void(const T&)> callback) { |
|||
std::lock_guard lock(callback_mutex); |
|||
CallbackHandle<T> handle; |
|||
handle = std::make_shared<std::function<void(const T&)>>(callback); |
|||
callbacks.Get<T>().insert(handle); |
|||
return handle; |
|||
} |
|||
|
|||
// RoomMember
|
|||
RoomMember::RoomMember() : room_member_impl{std::make_unique<RoomMemberImpl>()} {} |
|||
|
|||
RoomMember::~RoomMember() { |
|||
ASSERT_MSG(!IsConnected(), "RoomMember is being destroyed while connected"); |
|||
if (room_member_impl->loop_thread) { |
|||
Leave(); |
|||
} |
|||
} |
|||
|
|||
RoomMember::State RoomMember::GetState() const { |
|||
return room_member_impl->state; |
|||
} |
|||
|
|||
const RoomMember::MemberList& RoomMember::GetMemberInformation() const { |
|||
return room_member_impl->member_information; |
|||
} |
|||
|
|||
const std::string& RoomMember::GetNickname() const { |
|||
return room_member_impl->nickname; |
|||
} |
|||
|
|||
const std::string& RoomMember::GetUsername() const { |
|||
std::lock_guard lock(room_member_impl->username_mutex); |
|||
return room_member_impl->username; |
|||
} |
|||
|
|||
const MacAddress& RoomMember::GetMacAddress() const { |
|||
ASSERT_MSG(IsConnected(), "Tried to get MAC address while not connected"); |
|||
return room_member_impl->mac_address; |
|||
} |
|||
|
|||
RoomInformation RoomMember::GetRoomInformation() const { |
|||
return room_member_impl->room_information; |
|||
} |
|||
|
|||
void RoomMember::Join(const std::string& nick, const std::string& console_id_hash, |
|||
const char* server_addr, u16 server_port, u16 client_port, |
|||
const MacAddress& preferred_mac, const std::string& password, |
|||
const std::string& token) { |
|||
// If the member is connected, kill the connection first
|
|||
if (room_member_impl->loop_thread && room_member_impl->loop_thread->joinable()) { |
|||
Leave(); |
|||
} |
|||
// If the thread isn't running but the ptr still exists, reset it
|
|||
else if (room_member_impl->loop_thread) { |
|||
room_member_impl->loop_thread.reset(); |
|||
} |
|||
|
|||
if (!room_member_impl->client) { |
|||
room_member_impl->client = enet_host_create(nullptr, 1, NumChannels, 0, 0); |
|||
ASSERT_MSG(room_member_impl->client != nullptr, "Could not create client"); |
|||
} |
|||
|
|||
room_member_impl->SetState(State::Joining); |
|||
|
|||
ENetAddress address{}; |
|||
enet_address_set_host(&address, server_addr); |
|||
address.port = server_port; |
|||
room_member_impl->server = |
|||
enet_host_connect(room_member_impl->client, &address, NumChannels, 0); |
|||
|
|||
if (!room_member_impl->server) { |
|||
room_member_impl->SetState(State::Idle); |
|||
room_member_impl->SetError(Error::UnknownError); |
|||
return; |
|||
} |
|||
|
|||
ENetEvent event{}; |
|||
int net = enet_host_service(room_member_impl->client, &event, ConnectionTimeoutMs); |
|||
if (net > 0 && event.type == ENET_EVENT_TYPE_CONNECT) { |
|||
room_member_impl->nickname = nick; |
|||
room_member_impl->StartLoop(); |
|||
room_member_impl->SendJoinRequest(nick, console_id_hash, preferred_mac, password, token); |
|||
SendGameInfo(room_member_impl->current_game_info); |
|||
} else { |
|||
enet_peer_disconnect(room_member_impl->server, 0); |
|||
room_member_impl->SetState(State::Idle); |
|||
room_member_impl->SetError(Error::CouldNotConnect); |
|||
} |
|||
} |
|||
|
|||
bool RoomMember::IsConnected() const { |
|||
return room_member_impl->IsConnected(); |
|||
} |
|||
|
|||
void RoomMember::SendWifiPacket(const WifiPacket& wifi_packet) { |
|||
Packet packet; |
|||
packet.Write(static_cast<u8>(IdWifiPacket)); |
|||
packet.Write(static_cast<u8>(wifi_packet.type)); |
|||
packet.Write(wifi_packet.channel); |
|||
packet.Write(wifi_packet.transmitter_address); |
|||
packet.Write(wifi_packet.destination_address); |
|||
packet.Write(wifi_packet.data); |
|||
room_member_impl->Send(std::move(packet)); |
|||
} |
|||
|
|||
void RoomMember::SendChatMessage(const std::string& message) { |
|||
Packet packet; |
|||
packet.Write(static_cast<u8>(IdChatMessage)); |
|||
packet.Write(message); |
|||
room_member_impl->Send(std::move(packet)); |
|||
} |
|||
|
|||
void RoomMember::SendGameInfo(const GameInfo& game_info) { |
|||
room_member_impl->current_game_info = game_info; |
|||
if (!IsConnected()) |
|||
return; |
|||
|
|||
Packet packet; |
|||
packet.Write(static_cast<u8>(IdSetGameInfo)); |
|||
packet.Write(game_info.name); |
|||
packet.Write(game_info.id); |
|||
room_member_impl->Send(std::move(packet)); |
|||
} |
|||
|
|||
void RoomMember::SendModerationRequest(RoomMessageTypes type, const std::string& nickname) { |
|||
ASSERT_MSG(type == IdModKick || type == IdModBan || type == IdModUnban, |
|||
"type is not a moderation request"); |
|||
if (!IsConnected()) |
|||
return; |
|||
|
|||
Packet packet; |
|||
packet.Write(static_cast<u8>(type)); |
|||
packet.Write(nickname); |
|||
room_member_impl->Send(std::move(packet)); |
|||
} |
|||
|
|||
void RoomMember::RequestBanList() { |
|||
if (!IsConnected()) |
|||
return; |
|||
|
|||
Packet packet; |
|||
packet.Write(static_cast<u8>(IdModGetBanList)); |
|||
room_member_impl->Send(std::move(packet)); |
|||
} |
|||
|
|||
RoomMember::CallbackHandle<RoomMember::State> RoomMember::BindOnStateChanged( |
|||
std::function<void(const RoomMember::State&)> callback) { |
|||
return room_member_impl->Bind(callback); |
|||
} |
|||
|
|||
RoomMember::CallbackHandle<RoomMember::Error> RoomMember::BindOnError( |
|||
std::function<void(const RoomMember::Error&)> callback) { |
|||
return room_member_impl->Bind(callback); |
|||
} |
|||
|
|||
RoomMember::CallbackHandle<WifiPacket> RoomMember::BindOnWifiPacketReceived( |
|||
std::function<void(const WifiPacket&)> callback) { |
|||
return room_member_impl->Bind(callback); |
|||
} |
|||
|
|||
RoomMember::CallbackHandle<RoomInformation> RoomMember::BindOnRoomInformationChanged( |
|||
std::function<void(const RoomInformation&)> callback) { |
|||
return room_member_impl->Bind(callback); |
|||
} |
|||
|
|||
RoomMember::CallbackHandle<ChatEntry> RoomMember::BindOnChatMessageRecieved( |
|||
std::function<void(const ChatEntry&)> callback) { |
|||
return room_member_impl->Bind(callback); |
|||
} |
|||
|
|||
RoomMember::CallbackHandle<StatusMessageEntry> RoomMember::BindOnStatusMessageReceived( |
|||
std::function<void(const StatusMessageEntry&)> callback) { |
|||
return room_member_impl->Bind(callback); |
|||
} |
|||
|
|||
RoomMember::CallbackHandle<Room::BanList> RoomMember::BindOnBanListReceived( |
|||
std::function<void(const Room::BanList&)> callback) { |
|||
return room_member_impl->Bind(callback); |
|||
} |
|||
|
|||
template <typename T> |
|||
void RoomMember::Unbind(CallbackHandle<T> handle) { |
|||
std::lock_guard lock(room_member_impl->callback_mutex); |
|||
room_member_impl->callbacks.Get<T>().erase(handle); |
|||
} |
|||
|
|||
void RoomMember::Leave() { |
|||
room_member_impl->SetState(State::Idle); |
|||
room_member_impl->loop_thread->join(); |
|||
room_member_impl->loop_thread.reset(); |
|||
|
|||
enet_host_destroy(room_member_impl->client); |
|||
room_member_impl->client = nullptr; |
|||
} |
|||
|
|||
template void RoomMember::Unbind(CallbackHandle<WifiPacket>); |
|||
template void RoomMember::Unbind(CallbackHandle<RoomMember::State>); |
|||
template void RoomMember::Unbind(CallbackHandle<RoomMember::Error>); |
|||
template void RoomMember::Unbind(CallbackHandle<RoomInformation>); |
|||
template void RoomMember::Unbind(CallbackHandle<ChatEntry>); |
|||
template void RoomMember::Unbind(CallbackHandle<StatusMessageEntry>); |
|||
template void RoomMember::Unbind(CallbackHandle<Room::BanList>); |
|||
|
|||
} // namespace Network
|
|||
@ -0,0 +1,318 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <functional> |
|||
#include <memory> |
|||
#include <string> |
|||
#include <vector> |
|||
#include "common/announce_multiplayer_room.h" |
|||
#include "common/common_types.h" |
|||
#include "network/room.h" |
|||
|
|||
namespace Network { |
|||
|
|||
using AnnounceMultiplayerRoom::GameInfo; |
|||
using AnnounceMultiplayerRoom::RoomInformation; |
|||
|
|||
/// Information about the received WiFi packets. |
|||
/// Acts as our own 802.11 header. |
|||
struct WifiPacket { |
|||
enum class PacketType : u8 { |
|||
Beacon, |
|||
Data, |
|||
Authentication, |
|||
AssociationResponse, |
|||
Deauthentication, |
|||
NodeMap |
|||
}; |
|||
PacketType type; ///< The type of 802.11 frame. |
|||
std::vector<u8> data; ///< Raw 802.11 frame data, starting at the management frame header |
|||
/// for management frames. |
|||
MacAddress transmitter_address; ///< Mac address of the transmitter. |
|||
MacAddress destination_address; ///< Mac address of the receiver. |
|||
u8 channel; ///< WiFi channel where this frame was transmitted. |
|||
}; |
|||
|
|||
/// Represents a chat message. |
|||
struct ChatEntry { |
|||
std::string nickname; ///< Nickname of the client who sent this message. |
|||
/// Web services username of the client who sent this message, can be empty. |
|||
std::string username; |
|||
std::string message; ///< Body of the message. |
|||
}; |
|||
|
|||
/// Represents a system status message. |
|||
struct StatusMessageEntry { |
|||
StatusMessageTypes type; ///< Type of the message |
|||
/// Subject of the message. i.e. the user who is joining/leaving/being banned, etc. |
|||
std::string nickname; |
|||
std::string username; |
|||
}; |
|||
|
|||
/** |
|||
* This is what a client [person joining a server] would use. |
|||
* It also has to be used if you host a game yourself (You'd create both, a Room and a |
|||
* RoomMembership for yourself) |
|||
*/ |
|||
class RoomMember final { |
|||
public: |
|||
enum class State : u8 { |
|||
Uninitialized, ///< Not initialized |
|||
Idle, ///< Default state (i.e. not connected) |
|||
Joining, ///< The client is attempting to join a room. |
|||
Joined, ///< The client is connected to the room and is ready to send/receive packets. |
|||
Moderator, ///< The client is connnected to the room and is granted mod permissions. |
|||
}; |
|||
|
|||
enum class Error : u8 { |
|||
// Reasons why connection was closed |
|||
LostConnection, ///< Connection closed |
|||
HostKicked, ///< Kicked by the host |
|||
|
|||
// Reasons why connection was rejected |
|||
UnknownError, ///< Some error [permissions to network device missing or something] |
|||
NameCollision, ///< Somebody is already using this name |
|||
MacCollision, ///< Somebody is already using that mac-address |
|||
ConsoleIdCollision, ///< Somebody in the room has the same Console ID |
|||
WrongVersion, ///< The room version is not the same as for this RoomMember |
|||
WrongPassword, ///< The password doesn't match the one from the Room |
|||
CouldNotConnect, ///< The room is not responding to a connection attempt |
|||
RoomIsFull, ///< Room is already at the maximum number of players |
|||
HostBanned, ///< The user is banned by the host |
|||
|
|||
// Reasons why moderation request failed |
|||
PermissionDenied, ///< The user does not have mod permissions |
|||
NoSuchUser, ///< The nickname the user attempts to kick/ban does not exist |
|||
}; |
|||
|
|||
struct MemberInformation { |
|||
std::string nickname; ///< Nickname of the member. |
|||
std::string username; ///< The web services username of the member. Can be empty. |
|||
std::string display_name; ///< The web services display name of the member. Can be empty. |
|||
std::string avatar_url; ///< Url to the member's avatar. Can be empty. |
|||
GameInfo game_info; ///< Name of the game they're currently playing, or empty if they're |
|||
/// not playing anything. |
|||
MacAddress mac_address; ///< MAC address associated with this member. |
|||
}; |
|||
using MemberList = std::vector<MemberInformation>; |
|||
|
|||
// The handle for the callback functions |
|||
template <typename T> |
|||
using CallbackHandle = std::shared_ptr<std::function<void(const T&)>>; |
|||
|
|||
/** |
|||
* Unbinds a callback function from the events. |
|||
* @param handle The connection handle to disconnect |
|||
*/ |
|||
template <typename T> |
|||
void Unbind(CallbackHandle<T> handle); |
|||
|
|||
RoomMember(); |
|||
~RoomMember(); |
|||
|
|||
/** |
|||
* Returns the status of our connection to the room. |
|||
*/ |
|||
State GetState() const; |
|||
|
|||
/** |
|||
* Returns information about the members in the room we're currently connected to. |
|||
*/ |
|||
const MemberList& GetMemberInformation() const; |
|||
|
|||
/** |
|||
* Returns the nickname of the RoomMember. |
|||
*/ |
|||
const std::string& GetNickname() const; |
|||
|
|||
/** |
|||
* Returns the username of the RoomMember. |
|||
*/ |
|||
const std::string& GetUsername() const; |
|||
|
|||
/** |
|||
* Returns the MAC address of the RoomMember. |
|||
*/ |
|||
const MacAddress& GetMacAddress() const; |
|||
|
|||
/** |
|||
* Returns information about the room we're currently connected to. |
|||
*/ |
|||
RoomInformation GetRoomInformation() const; |
|||
|
|||
/** |
|||
* Returns whether we're connected to a server or not. |
|||
*/ |
|||
bool IsConnected() const; |
|||
|
|||
/** |
|||
* Attempts to join a room at the specified address and port, using the specified nickname. |
|||
* A console ID hash is passed in to check console ID conflicts. |
|||
* This may fail if the username or console ID is already taken. |
|||
*/ |
|||
void Join(const std::string& nickname, const std::string& console_id_hash, |
|||
const char* server_addr = "127.0.0.1", u16 server_port = DefaultRoomPort, |
|||
u16 client_port = 0, const MacAddress& preferred_mac = NoPreferredMac, |
|||
const std::string& password = "", const std::string& token = ""); |
|||
|
|||
/** |
|||
* Sends a WiFi packet to the room. |
|||
* @param packet The WiFi packet to send. |
|||
*/ |
|||
void SendWifiPacket(const WifiPacket& packet); |
|||
|
|||
/** |
|||
* Sends a chat message to the room. |
|||
* @param message The contents of the message. |
|||
*/ |
|||
void SendChatMessage(const std::string& message); |
|||
|
|||
/** |
|||
* Sends the current game info to the room. |
|||
* @param game_info The game information. |
|||
*/ |
|||
void SendGameInfo(const GameInfo& game_info); |
|||
|
|||
/** |
|||
* Sends a moderation request to the room. |
|||
* @param type Moderation request type. |
|||
* @param nickname The subject of the request. (i.e. the user you want to kick/ban) |
|||
*/ |
|||
void SendModerationRequest(RoomMessageTypes type, const std::string& nickname); |
|||
|
|||
/** |
|||
* Attempts to retrieve ban list from the room. |
|||
* If success, the ban list callback would be called. Otherwise an error would be emitted. |
|||
*/ |
|||
void RequestBanList(); |
|||
|
|||
/** |
|||
* Binds a function to an event that will be triggered every time the State of the member |
|||
* changed. The function wil be called every time the event is triggered. The callback function |
|||
* must not bind or unbind a function. Doing so will cause a deadlock |
|||
* @param callback The function to call |
|||
* @return A handle used for removing the function from the registered list |
|||
*/ |
|||
CallbackHandle<State> BindOnStateChanged(std::function<void(const State&)> callback); |
|||
|
|||
/** |
|||
* Binds a function to an event that will be triggered every time an error happened. The |
|||
* function wil be called every time the event is triggered. The callback function must not bind |
|||
* or unbind a function. Doing so will cause a deadlock |
|||
* @param callback The function to call |
|||
* @return A handle used for removing the function from the registered list |
|||
*/ |
|||
CallbackHandle<Error> BindOnError(std::function<void(const Error&)> callback); |
|||
|
|||
/** |
|||
* Binds a function to an event that will be triggered every time a WifiPacket is received. |
|||
* The function wil be called everytime the event is triggered. |
|||
* The callback function must not bind or unbind a function. Doing so will cause a deadlock |
|||
* @param callback The function to call |
|||
* @return A handle used for removing the function from the registered list |
|||
*/ |
|||
CallbackHandle<WifiPacket> BindOnWifiPacketReceived( |
|||
std::function<void(const WifiPacket&)> callback); |
|||
|
|||
/** |
|||
* Binds a function to an event that will be triggered every time the RoomInformation changes. |
|||
* The function wil be called every time the event is triggered. |
|||
* The callback function must not bind or unbind a function. Doing so will cause a deadlock |
|||
* @param callback The function to call |
|||
* @return A handle used for removing the function from the registered list |
|||
*/ |
|||
CallbackHandle<RoomInformation> BindOnRoomInformationChanged( |
|||
std::function<void(const RoomInformation&)> callback); |
|||
|
|||
/** |
|||
* Binds a function to an event that will be triggered every time a ChatMessage is received. |
|||
* The function wil be called every time the event is triggered. |
|||
* The callback function must not bind or unbind a function. Doing so will cause a deadlock |
|||
* @param callback The function to call |
|||
* @return A handle used for removing the function from the registered list |
|||
*/ |
|||
CallbackHandle<ChatEntry> BindOnChatMessageRecieved( |
|||
std::function<void(const ChatEntry&)> callback); |
|||
|
|||
/** |
|||
* Binds a function to an event that will be triggered every time a StatusMessage is |
|||
* received. The function will be called every time the event is triggered. The callback |
|||
* function must not bind or unbind a function. Doing so will cause a deadlock |
|||
* @param callback The function to call |
|||
* @return A handle used for removing the function from the registered list |
|||
*/ |
|||
CallbackHandle<StatusMessageEntry> BindOnStatusMessageReceived( |
|||
std::function<void(const StatusMessageEntry&)> callback); |
|||
|
|||
/** |
|||
* Binds a function to an event that will be triggered every time a requested ban list |
|||
* received. The function will be called every time the event is triggered. The callback |
|||
* function must not bind or unbind a function. Doing so will cause a deadlock |
|||
* @param callback The function to call |
|||
* @return A handle used for removing the function from the registered list |
|||
*/ |
|||
CallbackHandle<Room::BanList> BindOnBanListReceived( |
|||
std::function<void(const Room::BanList&)> callback); |
|||
|
|||
/** |
|||
* Leaves the current room. |
|||
*/ |
|||
void Leave(); |
|||
|
|||
private: |
|||
class RoomMemberImpl; |
|||
std::unique_ptr<RoomMemberImpl> room_member_impl; |
|||
}; |
|||
|
|||
inline const char* GetStateStr(const RoomMember::State& s) { |
|||
switch (s) { |
|||
case RoomMember::State::Uninitialized: |
|||
return "Uninitialized"; |
|||
case RoomMember::State::Idle: |
|||
return "Idle"; |
|||
case RoomMember::State::Joining: |
|||
return "Joining"; |
|||
case RoomMember::State::Joined: |
|||
return "Joined"; |
|||
case RoomMember::State::Moderator: |
|||
return "Moderator"; |
|||
} |
|||
return "Unknown"; |
|||
} |
|||
|
|||
inline const char* GetErrorStr(const RoomMember::Error& e) { |
|||
switch (e) { |
|||
case RoomMember::Error::LostConnection: |
|||
return "LostConnection"; |
|||
case RoomMember::Error::HostKicked: |
|||
return "HostKicked"; |
|||
case RoomMember::Error::UnknownError: |
|||
return "UnknownError"; |
|||
case RoomMember::Error::NameCollision: |
|||
return "NameCollision"; |
|||
case RoomMember::Error::MacCollision: |
|||
return "MaxCollision"; |
|||
case RoomMember::Error::ConsoleIdCollision: |
|||
return "ConsoleIdCollision"; |
|||
case RoomMember::Error::WrongVersion: |
|||
return "WrongVersion"; |
|||
case RoomMember::Error::WrongPassword: |
|||
return "WrongPassword"; |
|||
case RoomMember::Error::CouldNotConnect: |
|||
return "CouldNotConnect"; |
|||
case RoomMember::Error::RoomIsFull: |
|||
return "RoomIsFull"; |
|||
case RoomMember::Error::HostBanned: |
|||
return "HostBanned"; |
|||
case RoomMember::Error::PermissionDenied: |
|||
return "PermissionDenied"; |
|||
case RoomMember::Error::NoSuchUser: |
|||
return "NoSuchUser"; |
|||
default: |
|||
return "Unknown"; |
|||
} |
|||
} |
|||
|
|||
} // namespace Network |
|||
@ -0,0 +1,17 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2018 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include "network/verify_user.h"
|
|||
|
|||
namespace Network::VerifyUser { |
|||
|
|||
Backend::~Backend() = default; |
|||
|
|||
NullBackend::~NullBackend() = default; |
|||
|
|||
UserData NullBackend::LoadUserData([[maybe_unused]] const std::string& verify_uid, |
|||
[[maybe_unused]] const std::string& token) { |
|||
return {}; |
|||
} |
|||
|
|||
} // namespace Network::VerifyUser
|
|||
@ -0,0 +1,45 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2018 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <string> |
|||
#include "common/logging/log.h" |
|||
|
|||
namespace Network::VerifyUser { |
|||
|
|||
struct UserData { |
|||
std::string username; |
|||
std::string display_name; |
|||
std::string avatar_url; |
|||
bool moderator = false; ///< Whether the user is a yuzu Moderator. |
|||
}; |
|||
|
|||
/** |
|||
* A backend used for verifying users and loading user data. |
|||
*/ |
|||
class Backend { |
|||
public: |
|||
virtual ~Backend(); |
|||
|
|||
/** |
|||
* Verifies the given token and loads the information into a UserData struct. |
|||
* @param verify_uid A GUID that may be used for verification. |
|||
* @param token A token that contains user data and verification data. The format and content is |
|||
* decided by backends. |
|||
*/ |
|||
virtual UserData LoadUserData(const std::string& verify_uid, const std::string& token) = 0; |
|||
}; |
|||
|
|||
/** |
|||
* A null backend where the token is ignored. |
|||
* No verification is performed here and the function returns an empty UserData. |
|||
*/ |
|||
class NullBackend final : public Backend { |
|||
public: |
|||
~NullBackend(); |
|||
|
|||
UserData LoadUserData(const std::string& verify_uid, const std::string& token) override; |
|||
}; |
|||
|
|||
} // namespace Network::VerifyUser |
|||
@ -1,12 +1,16 @@ |
|||
add_library(web_service STATIC |
|||
announce_room_json.cpp |
|||
announce_room_json.h |
|||
telemetry_json.cpp |
|||
telemetry_json.h |
|||
verify_login.cpp |
|||
verify_login.h |
|||
verify_user_jwt.cpp |
|||
verify_user_jwt.h |
|||
web_backend.cpp |
|||
web_backend.h |
|||
web_result.h |
|||
) |
|||
|
|||
create_target_directory_groups(web_service) |
|||
target_link_libraries(web_service PRIVATE common nlohmann_json::nlohmann_json httplib) |
|||
target_link_libraries(web_service PRIVATE common network nlohmann_json::nlohmann_json httplib cpp-jwt) |
|||
@ -0,0 +1,145 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <future>
|
|||
#include <nlohmann/json.hpp>
|
|||
#include "common/detached_tasks.h"
|
|||
#include "common/logging/log.h"
|
|||
#include "web_service/announce_room_json.h"
|
|||
#include "web_service/web_backend.h"
|
|||
|
|||
namespace AnnounceMultiplayerRoom { |
|||
|
|||
static void to_json(nlohmann::json& json, const Member& member) { |
|||
if (!member.username.empty()) { |
|||
json["username"] = member.username; |
|||
} |
|||
json["nickname"] = member.nickname; |
|||
if (!member.avatar_url.empty()) { |
|||
json["avatarUrl"] = member.avatar_url; |
|||
} |
|||
json["gameName"] = member.game.name; |
|||
json["gameId"] = member.game.id; |
|||
} |
|||
|
|||
static void from_json(const nlohmann::json& json, Member& member) { |
|||
member.nickname = json.at("nickname").get<std::string>(); |
|||
member.game.name = json.at("gameName").get<std::string>(); |
|||
member.game.id = json.at("gameId").get<u64>(); |
|||
try { |
|||
member.username = json.at("username").get<std::string>(); |
|||
member.avatar_url = json.at("avatarUrl").get<std::string>(); |
|||
} catch (const nlohmann::detail::out_of_range&) { |
|||
member.username = member.avatar_url = ""; |
|||
LOG_DEBUG(Network, "Member \'{}\' isn't authenticated", member.nickname); |
|||
} |
|||
} |
|||
|
|||
static void to_json(nlohmann::json& json, const Room& room) { |
|||
json["port"] = room.information.port; |
|||
json["name"] = room.information.name; |
|||
if (!room.information.description.empty()) { |
|||
json["description"] = room.information.description; |
|||
} |
|||
json["preferredGameName"] = room.information.preferred_game.name; |
|||
json["preferredGameId"] = room.information.preferred_game.id; |
|||
json["maxPlayers"] = room.information.member_slots; |
|||
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; |
|||
} |
|||
} |
|||
|
|||
static void from_json(const nlohmann::json& json, Room& room) { |
|||
room.verify_uid = json.at("externalGuid").get<std::string>(); |
|||
room.ip = json.at("address").get<std::string>(); |
|||
room.information.name = json.at("name").get<std::string>(); |
|||
try { |
|||
room.information.description = json.at("description").get<std::string>(); |
|||
} catch (const nlohmann::detail::out_of_range&) { |
|||
room.information.description = ""; |
|||
LOG_DEBUG(Network, "Room \'{}\' doesn't contain a description", room.information.name); |
|||
} |
|||
room.information.host_username = json.at("owner").get<std::string>(); |
|||
room.information.port = json.at("port").get<u16>(); |
|||
room.information.preferred_game.name = json.at("preferredGameName").get<std::string>(); |
|||
room.information.preferred_game.id = json.at("preferredGameId").get<u64>(); |
|||
room.information.member_slots = 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<Member>>(); |
|||
} catch (const nlohmann::detail::out_of_range& e) { |
|||
LOG_DEBUG(Network, "Out of range {}", e.what()); |
|||
} |
|||
} |
|||
|
|||
} // namespace AnnounceMultiplayerRoom
|
|||
|
|||
namespace WebService { |
|||
|
|||
void RoomJson::SetRoomInformation(const std::string& name, const std::string& description, |
|||
const u16 port, const u32 max_player, const u32 net_version, |
|||
const bool has_password, |
|||
const AnnounceMultiplayerRoom::GameInfo& preferred_game) { |
|||
room.information.name = name; |
|||
room.information.description = description; |
|||
room.information.port = port; |
|||
room.information.member_slots = max_player; |
|||
room.net_version = net_version; |
|||
room.has_password = has_password; |
|||
room.information.preferred_game = preferred_game; |
|||
} |
|||
void RoomJson::AddPlayer(const AnnounceMultiplayerRoom::Member& member) { |
|||
room.members.push_back(member); |
|||
} |
|||
|
|||
WebService::WebResult RoomJson::Update() { |
|||
if (room_id.empty()) { |
|||
LOG_ERROR(WebService, "Room must be registered to be updated"); |
|||
return WebService::WebResult{WebService::WebResult::Code::LibError, |
|||
"Room is not registered", ""}; |
|||
} |
|||
nlohmann::json json{{"players", room.members}}; |
|||
return client.PostJson(fmt::format("/lobby/{}", room_id), json.dump(), false); |
|||
} |
|||
|
|||
WebService::WebResult RoomJson::Register() { |
|||
nlohmann::json json = room; |
|||
auto result = client.PostJson("/lobby", json.dump(), false); |
|||
if (result.result_code != WebService::WebResult::Code::Success) { |
|||
return result; |
|||
} |
|||
auto reply_json = nlohmann::json::parse(result.returned_data); |
|||
room = reply_json.get<AnnounceMultiplayerRoom::Room>(); |
|||
room_id = reply_json.at("id").get<std::string>(); |
|||
return WebService::WebResult{WebService::WebResult::Code::Success, "", room.verify_uid}; |
|||
} |
|||
|
|||
void RoomJson::ClearPlayers() { |
|||
room.members.clear(); |
|||
} |
|||
|
|||
AnnounceMultiplayerRoom::RoomList RoomJson::GetRoomList() { |
|||
auto reply = client.GetJson("/lobby", true).returned_data; |
|||
if (reply.empty()) { |
|||
return {}; |
|||
} |
|||
return nlohmann::json::parse(reply).at("rooms").get<AnnounceMultiplayerRoom::RoomList>(); |
|||
} |
|||
|
|||
void RoomJson::Delete() { |
|||
if (room_id.empty()) { |
|||
LOG_ERROR(WebService, "Room must be registered to be deleted"); |
|||
return; |
|||
} |
|||
Common::DetachedTasks::AddTask( |
|||
[host{this->host}, username{this->username}, token{this->token}, room_id{this->room_id}]() { |
|||
// create a new client here because the this->client might be destroyed.
|
|||
Client{host, username, token}.DeleteJson(fmt::format("/lobby/{}", room_id), "", false); |
|||
}); |
|||
} |
|||
|
|||
} // namespace WebService
|
|||
@ -0,0 +1,41 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <functional> |
|||
#include <string> |
|||
#include "common/announce_multiplayer_room.h" |
|||
#include "web_service/web_backend.h" |
|||
|
|||
namespace WebService { |
|||
|
|||
/** |
|||
* Implementation of AnnounceMultiplayerRoom::Backend that (de)serializes room information into/from |
|||
* JSON, and submits/gets it to/from the yuzu web service |
|||
*/ |
|||
class RoomJson : public AnnounceMultiplayerRoom::Backend { |
|||
public: |
|||
RoomJson(const std::string& host_, const std::string& username_, const std::string& token_) |
|||
: client(host_, username_, token_), host(host_), username(username_), token(token_) {} |
|||
~RoomJson() = default; |
|||
void SetRoomInformation(const std::string& name, const std::string& description, const u16 port, |
|||
const u32 max_player, const u32 net_version, const bool has_password, |
|||
const AnnounceMultiplayerRoom::GameInfo& preferred_game) override; |
|||
void AddPlayer(const AnnounceMultiplayerRoom::Member& member) override; |
|||
WebResult Update() override; |
|||
WebResult Register() override; |
|||
void ClearPlayers() override; |
|||
AnnounceMultiplayerRoom::RoomList GetRoomList() override; |
|||
void Delete() override; |
|||
|
|||
private: |
|||
AnnounceMultiplayerRoom::Room room; |
|||
Client client; |
|||
std::string host; |
|||
std::string username; |
|||
std::string token; |
|||
std::string room_id; |
|||
}; |
|||
|
|||
} // namespace WebService |
|||
@ -0,0 +1,67 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2018 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#if defined(__GNUC__) || defined(__clang__)
|
|||
#pragma GCC diagnostic push
|
|||
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
|
|||
#endif
|
|||
#include <jwt/jwt.hpp>
|
|||
#if defined(__GNUC__) || defined(__clang__)
|
|||
#pragma GCC diagnostic pop
|
|||
#endif
|
|||
|
|||
#include <system_error>
|
|||
#include "common/logging/log.h"
|
|||
#include "web_service/verify_user_jwt.h"
|
|||
#include "web_service/web_backend.h"
|
|||
#include "web_service/web_result.h"
|
|||
|
|||
namespace WebService { |
|||
|
|||
static std::string public_key; |
|||
std::string GetPublicKey(const std::string& host) { |
|||
if (public_key.empty()) { |
|||
Client client(host, "", ""); // no need for credentials here
|
|||
public_key = client.GetPlain("/jwt/external/key.pem", true).returned_data; |
|||
if (public_key.empty()) { |
|||
LOG_ERROR(WebService, "Could not fetch external JWT public key, verification may fail"); |
|||
} else { |
|||
LOG_INFO(WebService, "Fetched external JWT public key (size={})", public_key.size()); |
|||
} |
|||
} |
|||
return public_key; |
|||
} |
|||
|
|||
VerifyUserJWT::VerifyUserJWT(const std::string& host) : pub_key(GetPublicKey(host)) {} |
|||
|
|||
Network::VerifyUser::UserData VerifyUserJWT::LoadUserData(const std::string& verify_uid, |
|||
const std::string& token) { |
|||
const std::string audience = fmt::format("external-{}", verify_uid); |
|||
using namespace jwt::params; |
|||
std::error_code error; |
|||
auto decoded = |
|||
jwt::decode(token, algorithms({"rs256"}), error, secret(pub_key), issuer("yuzu-core"), |
|||
aud(audience), validate_iat(true), validate_jti(true)); |
|||
if (error) { |
|||
LOG_INFO(WebService, "Verification failed: category={}, code={}, message={}", |
|||
error.category().name(), error.value(), error.message()); |
|||
return {}; |
|||
} |
|||
Network::VerifyUser::UserData user_data{}; |
|||
if (decoded.payload().has_claim("username")) { |
|||
user_data.username = decoded.payload().get_claim_value<std::string>("username"); |
|||
} |
|||
if (decoded.payload().has_claim("displayName")) { |
|||
user_data.display_name = decoded.payload().get_claim_value<std::string>("displayName"); |
|||
} |
|||
if (decoded.payload().has_claim("avatarUrl")) { |
|||
user_data.avatar_url = decoded.payload().get_claim_value<std::string>("avatarUrl"); |
|||
} |
|||
if (decoded.payload().has_claim("roles")) { |
|||
auto roles = decoded.payload().get_claim_value<std::vector<std::string>>("roles"); |
|||
user_data.moderator = std::find(roles.begin(), roles.end(), "moderator") != roles.end(); |
|||
} |
|||
return user_data; |
|||
} |
|||
|
|||
} // namespace WebService
|
|||
@ -0,0 +1,26 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2018 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <fmt/format.h> |
|||
#include "network/verify_user.h" |
|||
#include "web_service/web_backend.h" |
|||
|
|||
namespace WebService { |
|||
|
|||
std::string GetPublicKey(const std::string& host); |
|||
|
|||
class VerifyUserJWT final : public Network::VerifyUser::Backend { |
|||
public: |
|||
VerifyUserJWT(const std::string& host); |
|||
~VerifyUserJWT() = default; |
|||
|
|||
Network::VerifyUser::UserData LoadUserData(const std::string& verify_uid, |
|||
const std::string& token) override; |
|||
|
|||
private: |
|||
std::string pub_key; |
|||
}; |
|||
|
|||
} // namespace WebService |
|||
@ -0,0 +1,491 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <array>
|
|||
#include <future>
|
|||
#include <QColor>
|
|||
#include <QDesktopServices>
|
|||
#include <QFutureWatcher>
|
|||
#include <QImage>
|
|||
#include <QList>
|
|||
#include <QLocale>
|
|||
#include <QMenu>
|
|||
#include <QMessageBox>
|
|||
#include <QMetaType>
|
|||
#include <QTime>
|
|||
#include <QUrl>
|
|||
#include <QtConcurrent/QtConcurrentRun>
|
|||
#include "common/logging/log.h"
|
|||
#include "core/announce_multiplayer_session.h"
|
|||
#include "ui_chat_room.h"
|
|||
#include "yuzu/game_list_p.h"
|
|||
#include "yuzu/multiplayer/chat_room.h"
|
|||
#include "yuzu/multiplayer/message.h"
|
|||
#ifdef ENABLE_WEB_SERVICE
|
|||
#include "web_service/web_backend.h"
|
|||
#endif
|
|||
|
|||
class ChatMessage { |
|||
public: |
|||
explicit ChatMessage(const Network::ChatEntry& chat, Network::RoomNetwork& room_network, |
|||
QTime ts = {}) { |
|||
/// Convert the time to their default locale defined format
|
|||
QLocale locale; |
|||
timestamp = locale.toString(ts.isValid() ? ts : QTime::currentTime(), QLocale::ShortFormat); |
|||
nickname = QString::fromStdString(chat.nickname); |
|||
username = QString::fromStdString(chat.username); |
|||
message = QString::fromStdString(chat.message); |
|||
|
|||
// Check for user pings
|
|||
QString cur_nickname, cur_username; |
|||
if (auto room = room_network.GetRoomMember().lock()) { |
|||
cur_nickname = QString::fromStdString(room->GetNickname()); |
|||
cur_username = QString::fromStdString(room->GetUsername()); |
|||
} |
|||
|
|||
// Handle pings at the beginning and end of message
|
|||
QString fixed_message = QStringLiteral(" %1 ").arg(message); |
|||
if (fixed_message.contains(QStringLiteral(" @%1 ").arg(cur_nickname)) || |
|||
(!cur_username.isEmpty() && |
|||
fixed_message.contains(QStringLiteral(" @%1 ").arg(cur_username)))) { |
|||
|
|||
contains_ping = true; |
|||
} else { |
|||
contains_ping = false; |
|||
} |
|||
} |
|||
|
|||
bool ContainsPing() const { |
|||
return contains_ping; |
|||
} |
|||
|
|||
/// Format the message using the players color
|
|||
QString GetPlayerChatMessage(u16 player) const { |
|||
auto color = player_color[player % 16]; |
|||
QString name; |
|||
if (username.isEmpty() || username == nickname) { |
|||
name = nickname; |
|||
} else { |
|||
name = QStringLiteral("%1 (%2)").arg(nickname, username); |
|||
} |
|||
|
|||
QString style, text_color; |
|||
if (ContainsPing()) { |
|||
// Add a background color to these messages
|
|||
style = QStringLiteral("background-color: %1").arg(QString::fromStdString(ping_color)); |
|||
// Add a font color
|
|||
text_color = QStringLiteral("color='#000000'"); |
|||
} |
|||
|
|||
return QStringLiteral("[%1] <font color='%2'><%3></font> <font style='%4' " |
|||
"%5>%6</font>") |
|||
.arg(timestamp, QString::fromStdString(color), name.toHtmlEscaped(), style, text_color, |
|||
message.toHtmlEscaped()); |
|||
} |
|||
|
|||
private: |
|||
static constexpr std::array<const char*, 16> player_color = { |
|||
{"#0000FF", "#FF0000", "#8A2BE2", "#FF69B4", "#1E90FF", "#008000", "#00FF7F", "#B22222", |
|||
"#DAA520", "#FF4500", "#2E8B57", "#5F9EA0", "#D2691E", "#9ACD32", "#FF7F50", "FFFF00"}}; |
|||
static constexpr char ping_color[] = "#FFFF00"; |
|||
|
|||
QString timestamp; |
|||
QString nickname; |
|||
QString username; |
|||
QString message; |
|||
bool contains_ping; |
|||
}; |
|||
|
|||
class StatusMessage { |
|||
public: |
|||
explicit StatusMessage(const QString& msg, QTime ts = {}) { |
|||
/// Convert the time to their default locale defined format
|
|||
QLocale locale; |
|||
timestamp = locale.toString(ts.isValid() ? ts : QTime::currentTime(), QLocale::ShortFormat); |
|||
message = msg; |
|||
} |
|||
|
|||
QString GetSystemChatMessage() const { |
|||
return QStringLiteral("[%1] <font color='%2'>* %3</font>") |
|||
.arg(timestamp, QString::fromStdString(system_color), message); |
|||
} |
|||
|
|||
private: |
|||
static constexpr const char system_color[] = "#FF8C00"; |
|||
QString timestamp; |
|||
QString message; |
|||
}; |
|||
|
|||
class PlayerListItem : public QStandardItem { |
|||
public: |
|||
static const int NicknameRole = Qt::UserRole + 1; |
|||
static const int UsernameRole = Qt::UserRole + 2; |
|||
static const int AvatarUrlRole = Qt::UserRole + 3; |
|||
static const int GameNameRole = Qt::UserRole + 4; |
|||
|
|||
PlayerListItem() = default; |
|||
explicit PlayerListItem(const std::string& nickname, const std::string& username, |
|||
const std::string& avatar_url, const std::string& game_name) { |
|||
setEditable(false); |
|||
setData(QString::fromStdString(nickname), NicknameRole); |
|||
setData(QString::fromStdString(username), UsernameRole); |
|||
setData(QString::fromStdString(avatar_url), AvatarUrlRole); |
|||
if (game_name.empty()) { |
|||
setData(QObject::tr("Not playing a game"), GameNameRole); |
|||
} else { |
|||
setData(QString::fromStdString(game_name), GameNameRole); |
|||
} |
|||
} |
|||
|
|||
QVariant data(int role) const override { |
|||
if (role != Qt::DisplayRole) { |
|||
return QStandardItem::data(role); |
|||
} |
|||
QString name; |
|||
const QString nickname = data(NicknameRole).toString(); |
|||
const QString username = data(UsernameRole).toString(); |
|||
if (username.isEmpty() || username == nickname) { |
|||
name = nickname; |
|||
} else { |
|||
name = QStringLiteral("%1 (%2)").arg(nickname, username); |
|||
} |
|||
return QStringLiteral("%1\n %2").arg(name, data(GameNameRole).toString()); |
|||
} |
|||
}; |
|||
|
|||
ChatRoom::ChatRoom(QWidget* parent) : QWidget(parent), ui(std::make_unique<Ui::ChatRoom>()) { |
|||
ui->setupUi(this); |
|||
|
|||
// set the item_model for player_view
|
|||
|
|||
player_list = new QStandardItemModel(ui->player_view); |
|||
ui->player_view->setModel(player_list); |
|||
ui->player_view->setContextMenuPolicy(Qt::CustomContextMenu); |
|||
// set a header to make it look better though there is only one column
|
|||
player_list->insertColumns(0, 1); |
|||
player_list->setHeaderData(0, Qt::Horizontal, tr("Members")); |
|||
|
|||
ui->chat_history->document()->setMaximumBlockCount(max_chat_lines); |
|||
|
|||
// register the network structs to use in slots and signals
|
|||
qRegisterMetaType<Network::ChatEntry>(); |
|||
qRegisterMetaType<Network::StatusMessageEntry>(); |
|||
qRegisterMetaType<Network::RoomInformation>(); |
|||
qRegisterMetaType<Network::RoomMember::State>(); |
|||
|
|||
// Connect all the widgets to the appropriate events
|
|||
connect(ui->player_view, &QTreeView::customContextMenuRequested, this, |
|||
&ChatRoom::PopupContextMenu); |
|||
connect(ui->chat_message, &QLineEdit::returnPressed, this, &ChatRoom::OnSendChat); |
|||
connect(ui->chat_message, &QLineEdit::textChanged, this, &ChatRoom::OnChatTextChanged); |
|||
connect(ui->send_message, &QPushButton::clicked, this, &ChatRoom::OnSendChat); |
|||
} |
|||
|
|||
ChatRoom::~ChatRoom() = default; |
|||
|
|||
void ChatRoom::Initialize(Network::RoomNetwork* room_network_) { |
|||
room_network = room_network_; |
|||
// setup the callbacks for network updates
|
|||
if (auto member = room_network->GetRoomMember().lock()) { |
|||
member->BindOnChatMessageRecieved( |
|||
[this](const Network::ChatEntry& chat) { emit ChatReceived(chat); }); |
|||
member->BindOnStatusMessageReceived( |
|||
[this](const Network::StatusMessageEntry& status_message) { |
|||
emit StatusMessageReceived(status_message); |
|||
}); |
|||
connect(this, &ChatRoom::ChatReceived, this, &ChatRoom::OnChatReceive); |
|||
connect(this, &ChatRoom::StatusMessageReceived, this, &ChatRoom::OnStatusMessageReceive); |
|||
} |
|||
} |
|||
|
|||
void ChatRoom::SetModPerms(bool is_mod) { |
|||
has_mod_perms = is_mod; |
|||
} |
|||
|
|||
void ChatRoom::RetranslateUi() { |
|||
ui->retranslateUi(this); |
|||
} |
|||
|
|||
void ChatRoom::Clear() { |
|||
ui->chat_history->clear(); |
|||
block_list.clear(); |
|||
} |
|||
|
|||
void ChatRoom::AppendStatusMessage(const QString& msg) { |
|||
ui->chat_history->append(StatusMessage(msg).GetSystemChatMessage()); |
|||
} |
|||
|
|||
void ChatRoom::AppendChatMessage(const QString& msg) { |
|||
ui->chat_history->append(msg); |
|||
} |
|||
|
|||
void ChatRoom::SendModerationRequest(Network::RoomMessageTypes type, const std::string& nickname) { |
|||
if (auto room = room_network->GetRoomMember().lock()) { |
|||
auto members = room->GetMemberInformation(); |
|||
auto it = std::find_if(members.begin(), members.end(), |
|||
[&nickname](const Network::RoomMember::MemberInformation& member) { |
|||
return member.nickname == nickname; |
|||
}); |
|||
if (it == members.end()) { |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::NO_SUCH_USER); |
|||
return; |
|||
} |
|||
room->SendModerationRequest(type, nickname); |
|||
} |
|||
} |
|||
|
|||
bool ChatRoom::ValidateMessage(const std::string& msg) { |
|||
return !msg.empty(); |
|||
} |
|||
|
|||
void ChatRoom::OnRoomUpdate(const Network::RoomInformation& info) { |
|||
// TODO(B3N30): change title
|
|||
if (auto room_member = room_network->GetRoomMember().lock()) { |
|||
SetPlayerList(room_member->GetMemberInformation()); |
|||
} |
|||
} |
|||
|
|||
void ChatRoom::Disable() { |
|||
ui->send_message->setDisabled(true); |
|||
ui->chat_message->setDisabled(true); |
|||
} |
|||
|
|||
void ChatRoom::Enable() { |
|||
ui->send_message->setEnabled(true); |
|||
ui->chat_message->setEnabled(true); |
|||
} |
|||
|
|||
void ChatRoom::OnChatReceive(const Network::ChatEntry& chat) { |
|||
if (!ValidateMessage(chat.message)) { |
|||
return; |
|||
} |
|||
if (auto room = room_network->GetRoomMember().lock()) { |
|||
// get the id of the player
|
|||
auto members = room->GetMemberInformation(); |
|||
auto it = std::find_if(members.begin(), members.end(), |
|||
[&chat](const Network::RoomMember::MemberInformation& member) { |
|||
return member.nickname == chat.nickname && |
|||
member.username == chat.username; |
|||
}); |
|||
if (it == members.end()) { |
|||
LOG_INFO(Network, "Chat message received from unknown player. Ignoring it."); |
|||
return; |
|||
} |
|||
if (block_list.count(chat.nickname)) { |
|||
LOG_INFO(Network, "Chat message received from blocked player {}. Ignoring it.", |
|||
chat.nickname); |
|||
return; |
|||
} |
|||
auto player = std::distance(members.begin(), it); |
|||
ChatMessage m(chat, *room_network); |
|||
if (m.ContainsPing()) { |
|||
emit UserPinged(); |
|||
} |
|||
AppendChatMessage(m.GetPlayerChatMessage(player)); |
|||
} |
|||
} |
|||
|
|||
void ChatRoom::OnStatusMessageReceive(const Network::StatusMessageEntry& status_message) { |
|||
QString name; |
|||
if (status_message.username.empty() || status_message.username == status_message.nickname) { |
|||
name = QString::fromStdString(status_message.nickname); |
|||
} else { |
|||
name = QStringLiteral("%1 (%2)").arg(QString::fromStdString(status_message.nickname), |
|||
QString::fromStdString(status_message.username)); |
|||
} |
|||
QString message; |
|||
switch (status_message.type) { |
|||
case Network::IdMemberJoin: |
|||
message = tr("%1 has joined").arg(name); |
|||
break; |
|||
case Network::IdMemberLeave: |
|||
message = tr("%1 has left").arg(name); |
|||
break; |
|||
case Network::IdMemberKicked: |
|||
message = tr("%1 has been kicked").arg(name); |
|||
break; |
|||
case Network::IdMemberBanned: |
|||
message = tr("%1 has been banned").arg(name); |
|||
break; |
|||
case Network::IdAddressUnbanned: |
|||
message = tr("%1 has been unbanned").arg(name); |
|||
break; |
|||
} |
|||
if (!message.isEmpty()) |
|||
AppendStatusMessage(message); |
|||
} |
|||
|
|||
void ChatRoom::OnSendChat() { |
|||
if (auto room = room_network->GetRoomMember().lock()) { |
|||
if (room->GetState() != Network::RoomMember::State::Joined && |
|||
room->GetState() != Network::RoomMember::State::Moderator) { |
|||
|
|||
return; |
|||
} |
|||
auto message = ui->chat_message->text().toStdString(); |
|||
if (!ValidateMessage(message)) { |
|||
return; |
|||
} |
|||
auto nick = room->GetNickname(); |
|||
auto username = room->GetUsername(); |
|||
Network::ChatEntry chat{nick, username, message}; |
|||
|
|||
auto members = room->GetMemberInformation(); |
|||
auto it = std::find_if(members.begin(), members.end(), |
|||
[&chat](const Network::RoomMember::MemberInformation& member) { |
|||
return member.nickname == chat.nickname && |
|||
member.username == chat.username; |
|||
}); |
|||
if (it == members.end()) { |
|||
LOG_INFO(Network, "Cannot find self in the player list when sending a message."); |
|||
} |
|||
auto player = std::distance(members.begin(), it); |
|||
ChatMessage m(chat, *room_network); |
|||
room->SendChatMessage(message); |
|||
AppendChatMessage(m.GetPlayerChatMessage(player)); |
|||
ui->chat_message->clear(); |
|||
} |
|||
} |
|||
|
|||
void ChatRoom::UpdateIconDisplay() { |
|||
for (int row = 0; row < player_list->invisibleRootItem()->rowCount(); ++row) { |
|||
QStandardItem* item = player_list->invisibleRootItem()->child(row); |
|||
const std::string avatar_url = |
|||
item->data(PlayerListItem::AvatarUrlRole).toString().toStdString(); |
|||
if (icon_cache.count(avatar_url)) { |
|||
item->setData(icon_cache.at(avatar_url), Qt::DecorationRole); |
|||
} else { |
|||
item->setData(QIcon::fromTheme(QStringLiteral("no_avatar")).pixmap(48), |
|||
Qt::DecorationRole); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void ChatRoom::SetPlayerList(const Network::RoomMember::MemberList& member_list) { |
|||
// TODO(B3N30): Remember which row is selected
|
|||
player_list->removeRows(0, player_list->rowCount()); |
|||
for (const auto& member : member_list) { |
|||
if (member.nickname.empty()) |
|||
continue; |
|||
QStandardItem* name_item = new PlayerListItem(member.nickname, member.username, |
|||
member.avatar_url, member.game_info.name); |
|||
|
|||
#ifdef ENABLE_WEB_SERVICE
|
|||
if (!icon_cache.count(member.avatar_url) && !member.avatar_url.empty()) { |
|||
// Start a request to get the member's avatar
|
|||
const QUrl url(QString::fromStdString(member.avatar_url)); |
|||
QFuture<std::string> future = QtConcurrent::run([url] { |
|||
WebService::Client client( |
|||
QStringLiteral("%1://%2").arg(url.scheme(), url.host()).toStdString(), "", ""); |
|||
auto result = client.GetImage(url.path().toStdString(), true); |
|||
if (result.returned_data.empty()) { |
|||
LOG_ERROR(WebService, "Failed to get avatar"); |
|||
} |
|||
return result.returned_data; |
|||
}); |
|||
auto* future_watcher = new QFutureWatcher<std::string>(this); |
|||
connect(future_watcher, &QFutureWatcher<std::string>::finished, this, |
|||
[this, future_watcher, avatar_url = member.avatar_url] { |
|||
const std::string result = future_watcher->result(); |
|||
if (result.empty()) |
|||
return; |
|||
QPixmap pixmap; |
|||
if (!pixmap.loadFromData(reinterpret_cast<const u8*>(result.data()), |
|||
static_cast<uint>(result.size()))) |
|||
return; |
|||
icon_cache[avatar_url] = |
|||
pixmap.scaled(48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); |
|||
// Update all the displayed icons with the new icon_cache
|
|||
UpdateIconDisplay(); |
|||
}); |
|||
future_watcher->setFuture(future); |
|||
} |
|||
#endif
|
|||
|
|||
player_list->invisibleRootItem()->appendRow(name_item); |
|||
} |
|||
UpdateIconDisplay(); |
|||
// TODO(B3N30): Restore row selection
|
|||
} |
|||
|
|||
void ChatRoom::OnChatTextChanged() { |
|||
if (ui->chat_message->text().length() > static_cast<int>(Network::MaxMessageSize)) |
|||
ui->chat_message->setText( |
|||
ui->chat_message->text().left(static_cast<int>(Network::MaxMessageSize))); |
|||
} |
|||
|
|||
void ChatRoom::PopupContextMenu(const QPoint& menu_location) { |
|||
QModelIndex item = ui->player_view->indexAt(menu_location); |
|||
if (!item.isValid()) |
|||
return; |
|||
|
|||
std::string nickname = |
|||
player_list->item(item.row())->data(PlayerListItem::NicknameRole).toString().toStdString(); |
|||
|
|||
QMenu context_menu; |
|||
|
|||
QString username = player_list->item(item.row())->data(PlayerListItem::UsernameRole).toString(); |
|||
if (!username.isEmpty()) { |
|||
QAction* view_profile_action = context_menu.addAction(tr("View Profile")); |
|||
connect(view_profile_action, &QAction::triggered, [username] { |
|||
QDesktopServices::openUrl( |
|||
QUrl(QStringLiteral("https://community.citra-emu.org/u/%1").arg(username))); |
|||
}); |
|||
} |
|||
|
|||
std::string cur_nickname; |
|||
if (auto room = room_network->GetRoomMember().lock()) { |
|||
cur_nickname = room->GetNickname(); |
|||
} |
|||
|
|||
if (nickname != cur_nickname) { // You can't block yourself
|
|||
QAction* block_action = context_menu.addAction(tr("Block Player")); |
|||
|
|||
block_action->setCheckable(true); |
|||
block_action->setChecked(block_list.count(nickname) > 0); |
|||
|
|||
connect(block_action, &QAction::triggered, [this, nickname] { |
|||
if (block_list.count(nickname)) { |
|||
block_list.erase(nickname); |
|||
} else { |
|||
QMessageBox::StandardButton result = QMessageBox::question( |
|||
this, tr("Block Player"), |
|||
tr("When you block a player, you will no longer receive chat messages from " |
|||
"them.<br><br>Are you sure you would like to block %1?") |
|||
.arg(QString::fromStdString(nickname)), |
|||
QMessageBox::Yes | QMessageBox::No); |
|||
if (result == QMessageBox::Yes) |
|||
block_list.emplace(nickname); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
if (has_mod_perms && nickname != cur_nickname) { // You can't kick or ban yourself
|
|||
context_menu.addSeparator(); |
|||
|
|||
QAction* kick_action = context_menu.addAction(tr("Kick")); |
|||
QAction* ban_action = context_menu.addAction(tr("Ban")); |
|||
|
|||
connect(kick_action, &QAction::triggered, [this, nickname] { |
|||
QMessageBox::StandardButton result = |
|||
QMessageBox::question(this, tr("Kick Player"), |
|||
tr("Are you sure you would like to <b>kick</b> %1?") |
|||
.arg(QString::fromStdString(nickname)), |
|||
QMessageBox::Yes | QMessageBox::No); |
|||
if (result == QMessageBox::Yes) |
|||
SendModerationRequest(Network::IdModKick, nickname); |
|||
}); |
|||
connect(ban_action, &QAction::triggered, [this, nickname] { |
|||
QMessageBox::StandardButton result = QMessageBox::question( |
|||
this, tr("Ban Player"), |
|||
tr("Are you sure you would like to <b>kick and ban</b> %1?\n\nThis would " |
|||
"ban both their forum username and their IP address.") |
|||
.arg(QString::fromStdString(nickname)), |
|||
QMessageBox::Yes | QMessageBox::No); |
|||
if (result == QMessageBox::Yes) |
|||
SendModerationRequest(Network::IdModBan, nickname); |
|||
}); |
|||
} |
|||
|
|||
context_menu.exec(ui->player_view->viewport()->mapToGlobal(menu_location)); |
|||
} |
|||
@ -0,0 +1,75 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <unordered_set> |
|||
#include <QDialog> |
|||
#include <QSortFilterProxyModel> |
|||
#include <QStandardItemModel> |
|||
#include <QVariant> |
|||
#include "network/network.h" |
|||
|
|||
namespace Ui { |
|||
class ChatRoom; |
|||
} |
|||
|
|||
namespace Core { |
|||
class AnnounceMultiplayerSession; |
|||
} |
|||
|
|||
class ConnectionError; |
|||
class ComboBoxProxyModel; |
|||
|
|||
class ChatMessage; |
|||
|
|||
class ChatRoom : public QWidget { |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
explicit ChatRoom(QWidget* parent); |
|||
void Initialize(Network::RoomNetwork* room_network); |
|||
void RetranslateUi(); |
|||
void SetPlayerList(const Network::RoomMember::MemberList& member_list); |
|||
void Clear(); |
|||
void AppendStatusMessage(const QString& msg); |
|||
~ChatRoom(); |
|||
|
|||
void SetModPerms(bool is_mod); |
|||
void UpdateIconDisplay(); |
|||
|
|||
public slots: |
|||
void OnRoomUpdate(const Network::RoomInformation& info); |
|||
void OnChatReceive(const Network::ChatEntry&); |
|||
void OnStatusMessageReceive(const Network::StatusMessageEntry&); |
|||
void OnSendChat(); |
|||
void OnChatTextChanged(); |
|||
void PopupContextMenu(const QPoint& menu_location); |
|||
void Disable(); |
|||
void Enable(); |
|||
|
|||
signals: |
|||
void ChatReceived(const Network::ChatEntry&); |
|||
void StatusMessageReceived(const Network::StatusMessageEntry&); |
|||
void UserPinged(); |
|||
|
|||
private: |
|||
static constexpr u32 max_chat_lines = 1000; |
|||
void AppendChatMessage(const QString&); |
|||
bool ValidateMessage(const std::string&); |
|||
void SendModerationRequest(Network::RoomMessageTypes type, const std::string& nickname); |
|||
|
|||
bool has_mod_perms = false; |
|||
QStandardItemModel* player_list; |
|||
std::unique_ptr<Ui::ChatRoom> ui; |
|||
std::unordered_set<std::string> block_list; |
|||
std::unordered_map<std::string, QPixmap> icon_cache; |
|||
Network::RoomNetwork* room_network; |
|||
}; |
|||
|
|||
Q_DECLARE_METATYPE(Network::ChatEntry); |
|||
Q_DECLARE_METATYPE(Network::StatusMessageEntry); |
|||
Q_DECLARE_METATYPE(Network::RoomInformation); |
|||
Q_DECLARE_METATYPE(Network::RoomMember::State); |
|||
Q_DECLARE_METATYPE(Network::RoomMember::Error); |
|||
@ -0,0 +1,59 @@ |
|||
<?xml version="1.0" encoding="UTF-8"?> |
|||
<ui version="4.0"> |
|||
<class>ChatRoom</class> |
|||
<widget class="QWidget" name="ChatRoom"> |
|||
<property name="geometry"> |
|||
<rect> |
|||
<x>0</x> |
|||
<y>0</y> |
|||
<width>807</width> |
|||
<height>432</height> |
|||
</rect> |
|||
</property> |
|||
<property name="windowTitle"> |
|||
<string>Room Window</string> |
|||
</property> |
|||
<layout class="QHBoxLayout" name="horizontalLayout"> |
|||
<item> |
|||
<widget class="QTreeView" name="player_view"/> |
|||
</item> |
|||
<item> |
|||
<layout class="QVBoxLayout" name="verticalLayout_4"> |
|||
<item> |
|||
<widget class="QTextEdit" name="chat_history"> |
|||
<property name="undoRedoEnabled"> |
|||
<bool>false</bool> |
|||
</property> |
|||
<property name="readOnly"> |
|||
<bool>true</bool> |
|||
</property> |
|||
<property name="textInteractionFlags"> |
|||
<set>Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse</set> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<layout class="QHBoxLayout" name="horizontalLayout_3"> |
|||
<item> |
|||
<widget class="QLineEdit" name="chat_message"> |
|||
<property name="placeholderText"> |
|||
<string>Send Chat Message</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QPushButton" name="send_message"> |
|||
<property name="text"> |
|||
<string>Send Message</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
</layout> |
|||
</widget> |
|||
<resources/> |
|||
<connections/> |
|||
</ui> |
|||
@ -0,0 +1,115 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <future>
|
|||
#include <QColor>
|
|||
#include <QImage>
|
|||
#include <QList>
|
|||
#include <QLocale>
|
|||
#include <QMetaType>
|
|||
#include <QTime>
|
|||
#include <QtConcurrent/QtConcurrentRun>
|
|||
#include "common/logging/log.h"
|
|||
#include "core/announce_multiplayer_session.h"
|
|||
#include "ui_client_room.h"
|
|||
#include "yuzu/game_list_p.h"
|
|||
#include "yuzu/multiplayer/client_room.h"
|
|||
#include "yuzu/multiplayer/message.h"
|
|||
#include "yuzu/multiplayer/moderation_dialog.h"
|
|||
#include "yuzu/multiplayer/state.h"
|
|||
|
|||
ClientRoomWindow::ClientRoomWindow(QWidget* parent, Network::RoomNetwork& room_network_) |
|||
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint), |
|||
ui(std::make_unique<Ui::ClientRoom>()), room_network{room_network_} { |
|||
ui->setupUi(this); |
|||
ui->chat->Initialize(&room_network); |
|||
|
|||
// setup the callbacks for network updates
|
|||
if (auto member = room_network.GetRoomMember().lock()) { |
|||
member->BindOnRoomInformationChanged( |
|||
[this](const Network::RoomInformation& info) { emit RoomInformationChanged(info); }); |
|||
member->BindOnStateChanged( |
|||
[this](const Network::RoomMember::State& state) { emit StateChanged(state); }); |
|||
|
|||
connect(this, &ClientRoomWindow::RoomInformationChanged, this, |
|||
&ClientRoomWindow::OnRoomUpdate); |
|||
connect(this, &ClientRoomWindow::StateChanged, this, &::ClientRoomWindow::OnStateChange); |
|||
// Update the state
|
|||
OnStateChange(member->GetState()); |
|||
} else { |
|||
// TODO (jroweboy) network was not initialized?
|
|||
} |
|||
|
|||
connect(ui->disconnect, &QPushButton::clicked, this, &ClientRoomWindow::Disconnect); |
|||
ui->disconnect->setDefault(false); |
|||
ui->disconnect->setAutoDefault(false); |
|||
connect(ui->moderation, &QPushButton::clicked, [this] { |
|||
ModerationDialog dialog(room_network, this); |
|||
dialog.exec(); |
|||
}); |
|||
ui->moderation->setDefault(false); |
|||
ui->moderation->setAutoDefault(false); |
|||
connect(ui->chat, &ChatRoom::UserPinged, this, &ClientRoomWindow::ShowNotification); |
|||
UpdateView(); |
|||
} |
|||
|
|||
ClientRoomWindow::~ClientRoomWindow() = default; |
|||
|
|||
void ClientRoomWindow::SetModPerms(bool is_mod) { |
|||
ui->chat->SetModPerms(is_mod); |
|||
ui->moderation->setVisible(is_mod); |
|||
ui->moderation->setDefault(false); |
|||
ui->moderation->setAutoDefault(false); |
|||
} |
|||
|
|||
void ClientRoomWindow::RetranslateUi() { |
|||
ui->retranslateUi(this); |
|||
ui->chat->RetranslateUi(); |
|||
} |
|||
|
|||
void ClientRoomWindow::OnRoomUpdate(const Network::RoomInformation& info) { |
|||
UpdateView(); |
|||
} |
|||
|
|||
void ClientRoomWindow::OnStateChange(const Network::RoomMember::State& state) { |
|||
if (state == Network::RoomMember::State::Joined || |
|||
state == Network::RoomMember::State::Moderator) { |
|||
|
|||
ui->chat->Clear(); |
|||
ui->chat->AppendStatusMessage(tr("Connected")); |
|||
SetModPerms(state == Network::RoomMember::State::Moderator); |
|||
} |
|||
UpdateView(); |
|||
} |
|||
|
|||
void ClientRoomWindow::Disconnect() { |
|||
auto parent = static_cast<MultiplayerState*>(parentWidget()); |
|||
if (parent->OnCloseRoom()) { |
|||
ui->chat->AppendStatusMessage(tr("Disconnected")); |
|||
close(); |
|||
} |
|||
} |
|||
|
|||
void ClientRoomWindow::UpdateView() { |
|||
if (auto member = room_network.GetRoomMember().lock()) { |
|||
if (member->IsConnected()) { |
|||
ui->chat->Enable(); |
|||
ui->disconnect->setEnabled(true); |
|||
auto memberlist = member->GetMemberInformation(); |
|||
ui->chat->SetPlayerList(memberlist); |
|||
const auto information = member->GetRoomInformation(); |
|||
setWindowTitle(QString(tr("%1 (%2/%3 members) - connected")) |
|||
.arg(QString::fromStdString(information.name)) |
|||
.arg(memberlist.size()) |
|||
.arg(information.member_slots)); |
|||
ui->description->setText(QString::fromStdString(information.description)); |
|||
return; |
|||
} |
|||
} |
|||
// TODO(B3N30): can't get RoomMember*, show error and close window
|
|||
close(); |
|||
} |
|||
|
|||
void ClientRoomWindow::UpdateIconDisplay() { |
|||
ui->chat->UpdateIconDisplay(); |
|||
} |
|||
@ -0,0 +1,39 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include "yuzu/multiplayer/chat_room.h" |
|||
|
|||
namespace Ui { |
|||
class ClientRoom; |
|||
} |
|||
|
|||
class ClientRoomWindow : public QDialog { |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
explicit ClientRoomWindow(QWidget* parent, Network::RoomNetwork& room_network_); |
|||
~ClientRoomWindow(); |
|||
|
|||
void RetranslateUi(); |
|||
void UpdateIconDisplay(); |
|||
|
|||
public slots: |
|||
void OnRoomUpdate(const Network::RoomInformation&); |
|||
void OnStateChange(const Network::RoomMember::State&); |
|||
|
|||
signals: |
|||
void RoomInformationChanged(const Network::RoomInformation&); |
|||
void StateChanged(const Network::RoomMember::State&); |
|||
void ShowNotification(); |
|||
|
|||
private: |
|||
void Disconnect(); |
|||
void UpdateView(); |
|||
void SetModPerms(bool is_mod); |
|||
|
|||
QStandardItemModel* player_list; |
|||
std::unique_ptr<Ui::ClientRoom> ui; |
|||
Network::RoomNetwork& room_network; |
|||
}; |
|||
@ -0,0 +1,80 @@ |
|||
<?xml version="1.0" encoding="UTF-8"?> |
|||
<ui version="4.0"> |
|||
<class>ClientRoom</class> |
|||
<widget class="QWidget" name="ClientRoom"> |
|||
<property name="geometry"> |
|||
<rect> |
|||
<x>0</x> |
|||
<y>0</y> |
|||
<width>807</width> |
|||
<height>432</height> |
|||
</rect> |
|||
</property> |
|||
<property name="windowTitle"> |
|||
<string>Room Window</string> |
|||
</property> |
|||
<layout class="QVBoxLayout" name="verticalLayout"> |
|||
<item> |
|||
<layout class="QVBoxLayout" name="verticalLayout_3"> |
|||
<item> |
|||
<layout class="QHBoxLayout" name="horizontalLayout"> |
|||
<property name="rightMargin"> |
|||
<number>0</number> |
|||
</property> |
|||
<item> |
|||
<widget class="QLabel" name="description"> |
|||
<property name="text"> |
|||
<string>Room Description</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<spacer name="horizontalSpacer"> |
|||
<property name="orientation"> |
|||
<enum>Qt::Horizontal</enum> |
|||
</property> |
|||
<property name="sizeHint" stdset="0"> |
|||
<size> |
|||
<width>40</width> |
|||
<height>20</height> |
|||
</size> |
|||
</property> |
|||
</spacer> |
|||
</item> |
|||
<item> |
|||
<widget class="QPushButton" name="moderation"> |
|||
<property name="text"> |
|||
<string>Moderation...</string> |
|||
</property> |
|||
<property name="visible"> |
|||
<bool>false</bool> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QPushButton" name="disconnect"> |
|||
<property name="text"> |
|||
<string>Leave Room</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
<item> |
|||
<widget class="ChatRoom" name="chat" native="true"/> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
</layout> |
|||
</widget> |
|||
<customwidgets> |
|||
<customwidget> |
|||
<class>ChatRoom</class> |
|||
<extends>QWidget</extends> |
|||
<header>multiplayer/chat_room.h</header> |
|||
<container>1</container> |
|||
</customwidget> |
|||
</customwidgets> |
|||
<resources/> |
|||
<connections/> |
|||
</ui> |
|||
@ -0,0 +1,130 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <QComboBox>
|
|||
#include <QFuture>
|
|||
#include <QIntValidator>
|
|||
#include <QRegExpValidator>
|
|||
#include <QString>
|
|||
#include <QtConcurrent/QtConcurrentRun>
|
|||
#include "common/settings.h"
|
|||
#include "network/network.h"
|
|||
#include "ui_direct_connect.h"
|
|||
#include "yuzu/main.h"
|
|||
#include "yuzu/multiplayer/client_room.h"
|
|||
#include "yuzu/multiplayer/direct_connect.h"
|
|||
#include "yuzu/multiplayer/message.h"
|
|||
#include "yuzu/multiplayer/state.h"
|
|||
#include "yuzu/multiplayer/validation.h"
|
|||
#include "yuzu/uisettings.h"
|
|||
|
|||
enum class ConnectionType : u8 { TraversalServer, IP }; |
|||
|
|||
DirectConnectWindow::DirectConnectWindow(Network::RoomNetwork& room_network_, QWidget* parent) |
|||
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint), |
|||
ui(std::make_unique<Ui::DirectConnect>()), room_network{room_network_} { |
|||
|
|||
ui->setupUi(this); |
|||
|
|||
// setup the watcher for background connections
|
|||
watcher = new QFutureWatcher<void>; |
|||
connect(watcher, &QFutureWatcher<void>::finished, this, &DirectConnectWindow::OnConnection); |
|||
|
|||
ui->nickname->setValidator(validation.GetNickname()); |
|||
ui->nickname->setText(UISettings::values.multiplayer_nickname.GetValue()); |
|||
if (ui->nickname->text().isEmpty() && !Settings::values.yuzu_username.GetValue().empty()) { |
|||
// Use yuzu Web Service user name as nickname by default
|
|||
ui->nickname->setText(QString::fromStdString(Settings::values.yuzu_username.GetValue())); |
|||
} |
|||
ui->ip->setValidator(validation.GetIP()); |
|||
ui->ip->setText(UISettings::values.multiplayer_ip.GetValue()); |
|||
ui->port->setValidator(validation.GetPort()); |
|||
ui->port->setText(QString::number(UISettings::values.multiplayer_port.GetValue())); |
|||
|
|||
// TODO(jroweboy): Show or hide the connection options based on the current value of the combo
|
|||
// box. Add this back in when the traversal server support is added.
|
|||
connect(ui->connect, &QPushButton::clicked, this, &DirectConnectWindow::Connect); |
|||
} |
|||
|
|||
DirectConnectWindow::~DirectConnectWindow() = default; |
|||
|
|||
void DirectConnectWindow::RetranslateUi() { |
|||
ui->retranslateUi(this); |
|||
} |
|||
|
|||
void DirectConnectWindow::Connect() { |
|||
if (!ui->nickname->hasAcceptableInput()) { |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::USERNAME_NOT_VALID); |
|||
return; |
|||
} |
|||
if (const auto member = room_network.GetRoomMember().lock()) { |
|||
// Prevent the user from trying to join a room while they are already joining.
|
|||
if (member->GetState() == Network::RoomMember::State::Joining) { |
|||
return; |
|||
} else if (member->IsConnected()) { |
|||
// And ask if they want to leave the room if they are already in one.
|
|||
if (!NetworkMessage::WarnDisconnect()) { |
|||
return; |
|||
} |
|||
} |
|||
} |
|||
switch (static_cast<ConnectionType>(ui->connection_type->currentIndex())) { |
|||
case ConnectionType::TraversalServer: |
|||
break; |
|||
case ConnectionType::IP: |
|||
if (!ui->ip->hasAcceptableInput()) { |
|||
NetworkMessage::ErrorManager::ShowError( |
|||
NetworkMessage::ErrorManager::IP_ADDRESS_NOT_VALID); |
|||
return; |
|||
} |
|||
if (!ui->port->hasAcceptableInput()) { |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::PORT_NOT_VALID); |
|||
return; |
|||
} |
|||
break; |
|||
} |
|||
|
|||
// Store settings
|
|||
UISettings::values.multiplayer_nickname = ui->nickname->text(); |
|||
UISettings::values.multiplayer_ip = ui->ip->text(); |
|||
if (ui->port->isModified() && !ui->port->text().isEmpty()) { |
|||
UISettings::values.multiplayer_port = ui->port->text().toInt(); |
|||
} else { |
|||
UISettings::values.multiplayer_port = UISettings::values.multiplayer_port.GetDefault(); |
|||
} |
|||
|
|||
// attempt to connect in a different thread
|
|||
QFuture<void> f = QtConcurrent::run([&] { |
|||
if (auto room_member = room_network.GetRoomMember().lock()) { |
|||
auto port = UISettings::values.multiplayer_port.GetValue(); |
|||
room_member->Join(ui->nickname->text().toStdString(), "", |
|||
ui->ip->text().toStdString().c_str(), port, 0, |
|||
Network::NoPreferredMac, ui->password->text().toStdString().c_str()); |
|||
} |
|||
}); |
|||
watcher->setFuture(f); |
|||
// and disable widgets and display a connecting while we wait
|
|||
BeginConnecting(); |
|||
} |
|||
|
|||
void DirectConnectWindow::BeginConnecting() { |
|||
ui->connect->setEnabled(false); |
|||
ui->connect->setText(tr("Connecting")); |
|||
} |
|||
|
|||
void DirectConnectWindow::EndConnecting() { |
|||
ui->connect->setEnabled(true); |
|||
ui->connect->setText(tr("Connect")); |
|||
} |
|||
|
|||
void DirectConnectWindow::OnConnection() { |
|||
EndConnecting(); |
|||
|
|||
if (auto room_member = room_network.GetRoomMember().lock()) { |
|||
if (room_member->GetState() == Network::RoomMember::State::Joined || |
|||
room_member->GetState() == Network::RoomMember::State::Moderator) { |
|||
|
|||
close(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,43 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <QDialog> |
|||
#include <QFutureWatcher> |
|||
#include "yuzu/multiplayer/validation.h" |
|||
|
|||
namespace Ui { |
|||
class DirectConnect; |
|||
} |
|||
|
|||
class DirectConnectWindow : public QDialog { |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
explicit DirectConnectWindow(Network::RoomNetwork& room_network_, QWidget* parent = nullptr); |
|||
~DirectConnectWindow(); |
|||
|
|||
void RetranslateUi(); |
|||
|
|||
signals: |
|||
/** |
|||
* Signalled by this widget when it is closing itself and destroying any state such as |
|||
* connections that it might have. |
|||
*/ |
|||
void Closed(); |
|||
|
|||
private slots: |
|||
void OnConnection(); |
|||
|
|||
private: |
|||
void Connect(); |
|||
void BeginConnecting(); |
|||
void EndConnecting(); |
|||
|
|||
QFutureWatcher<void>* watcher; |
|||
std::unique_ptr<Ui::DirectConnect> ui; |
|||
Validation validation; |
|||
Network::RoomNetwork& room_network; |
|||
}; |
|||
@ -0,0 +1,168 @@ |
|||
<?xml version="1.0" encoding="UTF-8"?> |
|||
<ui version="4.0"> |
|||
<class>DirectConnect</class> |
|||
<widget class="QWidget" name="DirectConnect"> |
|||
<property name="geometry"> |
|||
<rect> |
|||
<x>0</x> |
|||
<y>0</y> |
|||
<width>455</width> |
|||
<height>161</height> |
|||
</rect> |
|||
</property> |
|||
<property name="windowTitle"> |
|||
<string>Direct Connect</string> |
|||
</property> |
|||
<layout class="QVBoxLayout" name="verticalLayout"> |
|||
<item> |
|||
<layout class="QVBoxLayout" name="verticalLayout_3"> |
|||
<item> |
|||
<layout class="QVBoxLayout" name="verticalLayout_2"> |
|||
<item> |
|||
<layout class="QHBoxLayout" name="horizontalLayout"> |
|||
<property name="spacing"> |
|||
<number>0</number> |
|||
</property> |
|||
<property name="leftMargin"> |
|||
<number>0</number> |
|||
</property> |
|||
<item> |
|||
<widget class="QComboBox" name="connection_type"> |
|||
<item> |
|||
<property name="text"> |
|||
<string>IP Address</string> |
|||
</property> |
|||
</item> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QWidget" name="ip_container" native="true"> |
|||
<layout class="QHBoxLayout" name="ip_layout"> |
|||
<property name="leftMargin"> |
|||
<number>5</number> |
|||
</property> |
|||
<property name="topMargin"> |
|||
<number>0</number> |
|||
</property> |
|||
<property name="rightMargin"> |
|||
<number>0</number> |
|||
</property> |
|||
<property name="bottomMargin"> |
|||
<number>0</number> |
|||
</property> |
|||
<item> |
|||
<widget class="QLabel" name="label_2"> |
|||
<property name="text"> |
|||
<string>IP</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QLineEdit" name="ip"> |
|||
<property name="toolTip"> |
|||
<string><html><head/><body><p>IPv4 address of the host</p></body></html></string> |
|||
</property> |
|||
<property name="maxLength"> |
|||
<number>16</number> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QLabel" name="label_3"> |
|||
<property name="text"> |
|||
<string>Port</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QLineEdit" name="port"> |
|||
<property name="toolTip"> |
|||
<string><html><head/><body><p>Port number the host is listening on</p></body></html></string> |
|||
</property> |
|||
<property name="maxLength"> |
|||
<number>5</number> |
|||
</property> |
|||
<property name="placeholderText"> |
|||
<string>24872</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
<item> |
|||
<layout class="QHBoxLayout" name="horizontalLayout_2"> |
|||
<item> |
|||
<widget class="QLabel" name="label_5"> |
|||
<property name="text"> |
|||
<string>Nickname</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QLineEdit" name="nickname"> |
|||
<property name="maxLength"> |
|||
<number>20</number> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QLabel" name="label"> |
|||
<property name="text"> |
|||
<string>Password</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QLineEdit" name="password"/> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
<item> |
|||
<spacer name="verticalSpacer"> |
|||
<property name="orientation"> |
|||
<enum>Qt::Vertical</enum> |
|||
</property> |
|||
<property name="sizeHint" stdset="0"> |
|||
<size> |
|||
<width>20</width> |
|||
<height>20</height> |
|||
</size> |
|||
</property> |
|||
</spacer> |
|||
</item> |
|||
<item> |
|||
<layout class="QHBoxLayout" name="horizontalLayout_3"> |
|||
<item> |
|||
<spacer name="horizontalSpacer"> |
|||
<property name="orientation"> |
|||
<enum>Qt::Horizontal</enum> |
|||
</property> |
|||
<property name="sizeHint" stdset="0"> |
|||
<size> |
|||
<width>40</width> |
|||
<height>20</height> |
|||
</size> |
|||
</property> |
|||
</spacer> |
|||
</item> |
|||
<item> |
|||
<widget class="QPushButton" name="connect"> |
|||
<property name="text"> |
|||
<string>Connect</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
</layout> |
|||
</widget> |
|||
<resources/> |
|||
<connections/> |
|||
</ui> |
|||
@ -0,0 +1,246 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <future>
|
|||
#include <QColor>
|
|||
#include <QImage>
|
|||
#include <QList>
|
|||
#include <QLocale>
|
|||
#include <QMessageBox>
|
|||
#include <QMetaType>
|
|||
#include <QTime>
|
|||
#include <QtConcurrent/QtConcurrentRun>
|
|||
#include "common/logging/log.h"
|
|||
#include "common/settings.h"
|
|||
#include "core/announce_multiplayer_session.h"
|
|||
#include "ui_host_room.h"
|
|||
#include "yuzu/game_list_p.h"
|
|||
#include "yuzu/main.h"
|
|||
#include "yuzu/multiplayer/host_room.h"
|
|||
#include "yuzu/multiplayer/message.h"
|
|||
#include "yuzu/multiplayer/state.h"
|
|||
#include "yuzu/multiplayer/validation.h"
|
|||
#include "yuzu/uisettings.h"
|
|||
#ifdef ENABLE_WEB_SERVICE
|
|||
#include "web_service/verify_user_jwt.h"
|
|||
#endif
|
|||
|
|||
HostRoomWindow::HostRoomWindow(QWidget* parent, QStandardItemModel* list, |
|||
std::shared_ptr<Core::AnnounceMultiplayerSession> session, |
|||
Network::RoomNetwork& room_network_) |
|||
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint), |
|||
ui(std::make_unique<Ui::HostRoom>()), |
|||
announce_multiplayer_session(session), room_network{room_network_} { |
|||
ui->setupUi(this); |
|||
|
|||
// set up validation for all of the fields
|
|||
ui->room_name->setValidator(validation.GetRoomName()); |
|||
ui->username->setValidator(validation.GetNickname()); |
|||
ui->port->setValidator(validation.GetPort()); |
|||
ui->port->setPlaceholderText(QString::number(Network::DefaultRoomPort)); |
|||
|
|||
// Create a proxy to the game list to display the list of preferred games
|
|||
game_list = new QStandardItemModel; |
|||
UpdateGameList(list); |
|||
|
|||
proxy = new ComboBoxProxyModel; |
|||
proxy->setSourceModel(game_list); |
|||
proxy->sort(0, Qt::AscendingOrder); |
|||
ui->game_list->setModel(proxy); |
|||
|
|||
// Connect all the widgets to the appropriate events
|
|||
connect(ui->host, &QPushButton::clicked, this, &HostRoomWindow::Host); |
|||
|
|||
// Restore the settings:
|
|||
ui->username->setText(UISettings::values.multiplayer_room_nickname.GetValue()); |
|||
if (ui->username->text().isEmpty() && !Settings::values.yuzu_username.GetValue().empty()) { |
|||
// Use yuzu Web Service user name as nickname by default
|
|||
ui->username->setText(QString::fromStdString(Settings::values.yuzu_username.GetValue())); |
|||
} |
|||
ui->room_name->setText(UISettings::values.multiplayer_room_name.GetValue()); |
|||
ui->port->setText(QString::number(UISettings::values.multiplayer_room_port.GetValue())); |
|||
ui->max_player->setValue(UISettings::values.multiplayer_max_player.GetValue()); |
|||
int index = UISettings::values.multiplayer_host_type.GetValue(); |
|||
if (index < ui->host_type->count()) { |
|||
ui->host_type->setCurrentIndex(index); |
|||
} |
|||
index = ui->game_list->findData(UISettings::values.multiplayer_game_id.GetValue(), |
|||
GameListItemPath::ProgramIdRole); |
|||
if (index != -1) { |
|||
ui->game_list->setCurrentIndex(index); |
|||
} |
|||
ui->room_description->setText(UISettings::values.multiplayer_room_description.GetValue()); |
|||
} |
|||
|
|||
HostRoomWindow::~HostRoomWindow() = default; |
|||
|
|||
void HostRoomWindow::UpdateGameList(QStandardItemModel* list) { |
|||
game_list->clear(); |
|||
for (int i = 0; i < list->rowCount(); i++) { |
|||
auto parent = list->item(i, 0); |
|||
for (int j = 0; j < parent->rowCount(); j++) { |
|||
game_list->appendRow(parent->child(j)->clone()); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void HostRoomWindow::RetranslateUi() { |
|||
ui->retranslateUi(this); |
|||
} |
|||
|
|||
std::unique_ptr<Network::VerifyUser::Backend> HostRoomWindow::CreateVerifyBackend( |
|||
bool use_validation) const { |
|||
std::unique_ptr<Network::VerifyUser::Backend> verify_backend; |
|||
if (use_validation) { |
|||
#ifdef ENABLE_WEB_SERVICE
|
|||
verify_backend = |
|||
std::make_unique<WebService::VerifyUserJWT>(Settings::values.web_api_url.GetValue()); |
|||
#else
|
|||
verify_backend = std::make_unique<Network::VerifyUser::NullBackend>(); |
|||
#endif
|
|||
} else { |
|||
verify_backend = std::make_unique<Network::VerifyUser::NullBackend>(); |
|||
} |
|||
return verify_backend; |
|||
} |
|||
|
|||
void HostRoomWindow::Host() { |
|||
if (!ui->username->hasAcceptableInput()) { |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::USERNAME_NOT_VALID); |
|||
return; |
|||
} |
|||
if (!ui->room_name->hasAcceptableInput()) { |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::ROOMNAME_NOT_VALID); |
|||
return; |
|||
} |
|||
if (!ui->port->hasAcceptableInput()) { |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::PORT_NOT_VALID); |
|||
return; |
|||
} |
|||
if (ui->game_list->currentIndex() == -1) { |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::GAME_NOT_SELECTED); |
|||
return; |
|||
} |
|||
if (auto member = room_network.GetRoomMember().lock()) { |
|||
if (member->GetState() == Network::RoomMember::State::Joining) { |
|||
return; |
|||
} else if (member->IsConnected()) { |
|||
auto parent = static_cast<MultiplayerState*>(parentWidget()); |
|||
if (!parent->OnCloseRoom()) { |
|||
close(); |
|||
return; |
|||
} |
|||
} |
|||
ui->host->setDisabled(true); |
|||
|
|||
const AnnounceMultiplayerRoom::GameInfo game{ |
|||
.name = ui->game_list->currentData(Qt::DisplayRole).toString().toStdString(), |
|||
.id = ui->game_list->currentData(GameListItemPath::ProgramIdRole).toULongLong(), |
|||
}; |
|||
const auto port = |
|||
ui->port->isModified() ? ui->port->text().toInt() : Network::DefaultRoomPort; |
|||
const auto password = ui->password->text().toStdString(); |
|||
const bool is_public = ui->host_type->currentIndex() == 0; |
|||
Network::Room::BanList ban_list{}; |
|||
if (ui->load_ban_list->isChecked()) { |
|||
ban_list = UISettings::values.multiplayer_ban_list; |
|||
} |
|||
if (auto room = room_network.GetRoom().lock()) { |
|||
const bool created = |
|||
room->Create(ui->room_name->text().toStdString(), |
|||
ui->room_description->toPlainText().toStdString(), "", port, password, |
|||
ui->max_player->value(), Settings::values.yuzu_username.GetValue(), |
|||
game, CreateVerifyBackend(is_public), ban_list); |
|||
if (!created) { |
|||
NetworkMessage::ErrorManager::ShowError( |
|||
NetworkMessage::ErrorManager::COULD_NOT_CREATE_ROOM); |
|||
LOG_ERROR(Network, "Could not create room!"); |
|||
ui->host->setEnabled(true); |
|||
return; |
|||
} |
|||
} |
|||
// Start the announce session if they chose Public
|
|||
if (is_public) { |
|||
if (auto session = announce_multiplayer_session.lock()) { |
|||
// Register the room first to ensure verify_uid is present when we connect
|
|||
WebService::WebResult result = session->Register(); |
|||
if (result.result_code != WebService::WebResult::Code::Success) { |
|||
QMessageBox::warning( |
|||
this, tr("Error"), |
|||
tr("Failed to announce the room to the public lobby. In order to host a " |
|||
"room publicly, you must have a valid yuzu account configured in " |
|||
"Emulation -> Configure -> Web. If you do not want to publish a room in " |
|||
"the public lobby, then select Unlisted instead.\nDebug Message: ") + |
|||
QString::fromStdString(result.result_string), |
|||
QMessageBox::Ok); |
|||
ui->host->setEnabled(true); |
|||
if (auto room = room_network.GetRoom().lock()) { |
|||
room->Destroy(); |
|||
} |
|||
return; |
|||
} |
|||
session->Start(); |
|||
} else { |
|||
LOG_ERROR(Network, "Starting announce session failed"); |
|||
} |
|||
} |
|||
std::string token; |
|||
#ifdef ENABLE_WEB_SERVICE
|
|||
if (is_public) { |
|||
WebService::Client client(Settings::values.web_api_url.GetValue(), |
|||
Settings::values.yuzu_username.GetValue(), |
|||
Settings::values.yuzu_token.GetValue()); |
|||
if (auto room = room_network.GetRoom().lock()) { |
|||
token = client.GetExternalJWT(room->GetVerifyUID()).returned_data; |
|||
} |
|||
if (token.empty()) { |
|||
LOG_ERROR(WebService, "Could not get external JWT, verification may fail"); |
|||
} else { |
|||
LOG_INFO(WebService, "Successfully requested external JWT: size={}", token.size()); |
|||
} |
|||
} |
|||
#endif
|
|||
// TODO: Check what to do with this
|
|||
member->Join(ui->username->text().toStdString(), "", "127.0.0.1", port, 0, |
|||
Network::NoPreferredMac, password, token); |
|||
|
|||
// Store settings
|
|||
UISettings::values.multiplayer_room_nickname = ui->username->text(); |
|||
UISettings::values.multiplayer_room_name = ui->room_name->text(); |
|||
UISettings::values.multiplayer_game_id = |
|||
ui->game_list->currentData(GameListItemPath::ProgramIdRole).toLongLong(); |
|||
UISettings::values.multiplayer_max_player = ui->max_player->value(); |
|||
|
|||
UISettings::values.multiplayer_host_type = ui->host_type->currentIndex(); |
|||
if (ui->port->isModified() && !ui->port->text().isEmpty()) { |
|||
UISettings::values.multiplayer_room_port = ui->port->text().toInt(); |
|||
} else { |
|||
UISettings::values.multiplayer_room_port = Network::DefaultRoomPort; |
|||
} |
|||
UISettings::values.multiplayer_room_description = ui->room_description->toPlainText(); |
|||
ui->host->setEnabled(true); |
|||
close(); |
|||
} |
|||
} |
|||
|
|||
QVariant ComboBoxProxyModel::data(const QModelIndex& idx, int role) const { |
|||
if (role != Qt::DisplayRole) { |
|||
auto val = QSortFilterProxyModel::data(idx, role); |
|||
// If its the icon, shrink it to 16x16
|
|||
if (role == Qt::DecorationRole) |
|||
val = val.value<QImage>().scaled(16, 16, Qt::KeepAspectRatio); |
|||
return val; |
|||
} |
|||
std::string filename; |
|||
Common::SplitPath( |
|||
QSortFilterProxyModel::data(idx, GameListItemPath::FullPathRole).toString().toStdString(), |
|||
nullptr, &filename, nullptr); |
|||
QString title = QSortFilterProxyModel::data(idx, GameListItemPath::TitleRole).toString(); |
|||
return title.isEmpty() ? QString::fromStdString(filename) : title; |
|||
} |
|||
|
|||
bool ComboBoxProxyModel::lessThan(const QModelIndex& left, const QModelIndex& right) const { |
|||
auto leftData = left.data(GameListItemPath::TitleRole).toString(); |
|||
auto rightData = right.data(GameListItemPath::TitleRole).toString(); |
|||
return leftData.compare(rightData) < 0; |
|||
} |
|||
@ -0,0 +1,75 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <QDialog> |
|||
#include <QSortFilterProxyModel> |
|||
#include <QStandardItemModel> |
|||
#include <QVariant> |
|||
#include "network/network.h" |
|||
#include "yuzu/multiplayer/chat_room.h" |
|||
#include "yuzu/multiplayer/validation.h" |
|||
|
|||
namespace Ui { |
|||
class HostRoom; |
|||
} |
|||
|
|||
namespace Core { |
|||
class AnnounceMultiplayerSession; |
|||
} |
|||
|
|||
class ConnectionError; |
|||
class ComboBoxProxyModel; |
|||
|
|||
class ChatMessage; |
|||
|
|||
namespace Network::VerifyUser { |
|||
class Backend; |
|||
}; |
|||
|
|||
class HostRoomWindow : public QDialog { |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
explicit HostRoomWindow(QWidget* parent, QStandardItemModel* list, |
|||
std::shared_ptr<Core::AnnounceMultiplayerSession> session, |
|||
Network::RoomNetwork& room_network_); |
|||
~HostRoomWindow(); |
|||
|
|||
/** |
|||
* Updates the dialog with a new game list model. |
|||
* This model should be the original model of the game list. |
|||
*/ |
|||
void UpdateGameList(QStandardItemModel* list); |
|||
void RetranslateUi(); |
|||
|
|||
private: |
|||
void Host(); |
|||
std::unique_ptr<Network::VerifyUser::Backend> CreateVerifyBackend(bool use_validation) const; |
|||
|
|||
std::unique_ptr<Ui::HostRoom> ui; |
|||
std::weak_ptr<Core::AnnounceMultiplayerSession> announce_multiplayer_session; |
|||
QStandardItemModel* game_list; |
|||
ComboBoxProxyModel* proxy; |
|||
Validation validation; |
|||
Network::RoomNetwork& room_network; |
|||
}; |
|||
|
|||
/** |
|||
* Proxy Model for the game list combo box so we can reuse the game list model while still |
|||
* displaying the fields slightly differently |
|||
*/ |
|||
class ComboBoxProxyModel : public QSortFilterProxyModel { |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
int columnCount(const QModelIndex& idx) const override { |
|||
return 1; |
|||
} |
|||
|
|||
QVariant data(const QModelIndex& idx, int role) const override; |
|||
|
|||
bool lessThan(const QModelIndex& left, const QModelIndex& right) const override; |
|||
}; |
|||
@ -0,0 +1,207 @@ |
|||
<?xml version="1.0" encoding="UTF-8"?> |
|||
<ui version="4.0"> |
|||
<class>HostRoom</class> |
|||
<widget class="QWidget" name="HostRoom"> |
|||
<property name="geometry"> |
|||
<rect> |
|||
<x>0</x> |
|||
<y>0</y> |
|||
<width>607</width> |
|||
<height>211</height> |
|||
</rect> |
|||
</property> |
|||
<property name="windowTitle"> |
|||
<string>Create Room</string> |
|||
</property> |
|||
<layout class="QVBoxLayout" name="verticalLayout_3"> |
|||
<item> |
|||
<widget class="QWidget" name="settings" native="true"> |
|||
<layout class="QHBoxLayout"> |
|||
<property name="leftMargin"> |
|||
<number>0</number> |
|||
</property> |
|||
<property name="topMargin"> |
|||
<number>0</number> |
|||
</property> |
|||
<property name="rightMargin"> |
|||
<number>0</number> |
|||
</property> |
|||
<item> |
|||
<layout class="QFormLayout" name="formLayout_2"> |
|||
<property name="labelAlignment"> |
|||
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set> |
|||
</property> |
|||
<item row="0" column="0"> |
|||
<widget class="QLabel" name="label"> |
|||
<property name="text"> |
|||
<string>Room Name</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item row="0" column="1"> |
|||
<widget class="QLineEdit" name="room_name"> |
|||
<property name="maxLength"> |
|||
<number>50</number> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item row="1" column="0"> |
|||
<widget class="QLabel" name="label_3"> |
|||
<property name="text"> |
|||
<string>Preferred Game</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item row="1" column="1"> |
|||
<widget class="QComboBox" name="game_list"/> |
|||
</item> |
|||
<item row="2" column="0"> |
|||
<widget class="QLabel" name="label_2"> |
|||
<property name="text"> |
|||
<string>Max Players</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item row="2" column="1"> |
|||
<widget class="QSpinBox" name="max_player"> |
|||
<property name="minimum"> |
|||
<number>2</number> |
|||
</property> |
|||
<property name="maximum"> |
|||
<number>16</number> |
|||
</property> |
|||
<property name="value"> |
|||
<number>8</number> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
<item> |
|||
<layout class="QFormLayout" name="formLayout"> |
|||
<property name="labelAlignment"> |
|||
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set> |
|||
</property> |
|||
<item row="0" column="1"> |
|||
<widget class="QLineEdit" name="username"/> |
|||
</item> |
|||
<item row="0" column="0"> |
|||
<widget class="QLabel" name="label_6"> |
|||
<property name="text"> |
|||
<string>Username</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item row="1" column="1"> |
|||
<widget class="QLineEdit" name="password"> |
|||
<property name="echoMode"> |
|||
<enum>QLineEdit::PasswordEchoOnEdit</enum> |
|||
</property> |
|||
<property name="placeholderText"> |
|||
<string>(Leave blank for open game)</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item row="2" column="1"> |
|||
<widget class="QLineEdit" name="port"> |
|||
<property name="inputMethodHints"> |
|||
<set>Qt::ImhDigitsOnly</set> |
|||
</property> |
|||
<property name="maxLength"> |
|||
<number>5</number> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item row="1" column="0"> |
|||
<widget class="QLabel" name="label_5"> |
|||
<property name="text"> |
|||
<string>Password</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item row="2" column="0"> |
|||
<widget class="QLabel" name="label_4"> |
|||
<property name="text"> |
|||
<string>Port</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
</layout> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<layout class="QHBoxLayout" name="horizontalLayout_3"> |
|||
<item> |
|||
<widget class="QLabel" name="label_7"> |
|||
<property name="text"> |
|||
<string>Room Description</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QTextEdit" name="room_description"/> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
<item> |
|||
<layout class="QHBoxLayout"> |
|||
<item> |
|||
<widget class="QCheckBox" name="load_ban_list"> |
|||
<property name="text"> |
|||
<string>Load Previous Ban List</string> |
|||
</property> |
|||
<property name="checked"> |
|||
<bool>true</bool> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
<item> |
|||
<layout class="QHBoxLayout" name="horizontalLayout"> |
|||
<property name="rightMargin"> |
|||
<number>0</number> |
|||
</property> |
|||
<item> |
|||
<spacer name="horizontalSpacer"> |
|||
<property name="orientation"> |
|||
<enum>Qt::Horizontal</enum> |
|||
</property> |
|||
<property name="sizeHint" stdset="0"> |
|||
<size> |
|||
<width>40</width> |
|||
<height>20</height> |
|||
</size> |
|||
</property> |
|||
</spacer> |
|||
</item> |
|||
<item> |
|||
<widget class="QComboBox" name="host_type"> |
|||
<item> |
|||
<property name="text"> |
|||
<string>Public</string> |
|||
</property> |
|||
</item> |
|||
<item> |
|||
<property name="text"> |
|||
<string>Unlisted</string> |
|||
</property> |
|||
</item> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QPushButton" name="host"> |
|||
<property name="text"> |
|||
<string>Host Room</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
</layout> |
|||
</widget> |
|||
<resources/> |
|||
<connections/> |
|||
</ui> |
|||
@ -0,0 +1,367 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <QInputDialog>
|
|||
#include <QList>
|
|||
#include <QtConcurrent/QtConcurrentRun>
|
|||
#include "common/logging/log.h"
|
|||
#include "common/settings.h"
|
|||
#include "network/network.h"
|
|||
#include "ui_lobby.h"
|
|||
#include "yuzu/game_list_p.h"
|
|||
#include "yuzu/main.h"
|
|||
#include "yuzu/multiplayer/client_room.h"
|
|||
#include "yuzu/multiplayer/lobby.h"
|
|||
#include "yuzu/multiplayer/lobby_p.h"
|
|||
#include "yuzu/multiplayer/message.h"
|
|||
#include "yuzu/multiplayer/state.h"
|
|||
#include "yuzu/multiplayer/validation.h"
|
|||
#include "yuzu/uisettings.h"
|
|||
#ifdef ENABLE_WEB_SERVICE
|
|||
#include "web_service/web_backend.h"
|
|||
#endif
|
|||
|
|||
Lobby::Lobby(QWidget* parent, QStandardItemModel* list, |
|||
std::shared_ptr<Core::AnnounceMultiplayerSession> session, |
|||
Network::RoomNetwork& room_network_) |
|||
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint), |
|||
ui(std::make_unique<Ui::Lobby>()), |
|||
announce_multiplayer_session(session), room_network{room_network_} { |
|||
ui->setupUi(this); |
|||
|
|||
// setup the watcher for background connections
|
|||
watcher = new QFutureWatcher<void>; |
|||
|
|||
model = new QStandardItemModel(ui->room_list); |
|||
|
|||
// Create a proxy to the game list to get the list of games owned
|
|||
game_list = new QStandardItemModel; |
|||
UpdateGameList(list); |
|||
|
|||
proxy = new LobbyFilterProxyModel(this, game_list); |
|||
proxy->setSourceModel(model); |
|||
proxy->setDynamicSortFilter(true); |
|||
proxy->setFilterCaseSensitivity(Qt::CaseInsensitive); |
|||
proxy->setSortLocaleAware(true); |
|||
ui->room_list->setModel(proxy); |
|||
ui->room_list->header()->setSectionResizeMode(QHeaderView::Interactive); |
|||
ui->room_list->header()->stretchLastSection(); |
|||
ui->room_list->setAlternatingRowColors(true); |
|||
ui->room_list->setSelectionMode(QHeaderView::SingleSelection); |
|||
ui->room_list->setSelectionBehavior(QHeaderView::SelectRows); |
|||
ui->room_list->setVerticalScrollMode(QHeaderView::ScrollPerPixel); |
|||
ui->room_list->setHorizontalScrollMode(QHeaderView::ScrollPerPixel); |
|||
ui->room_list->setSortingEnabled(true); |
|||
ui->room_list->setEditTriggers(QHeaderView::NoEditTriggers); |
|||
ui->room_list->setExpandsOnDoubleClick(false); |
|||
ui->room_list->setContextMenuPolicy(Qt::CustomContextMenu); |
|||
|
|||
ui->nickname->setValidator(validation.GetNickname()); |
|||
ui->nickname->setText(UISettings::values.multiplayer_nickname.GetValue()); |
|||
if (ui->nickname->text().isEmpty() && !Settings::values.yuzu_username.GetValue().empty()) { |
|||
// Use yuzu Web Service user name as nickname by default
|
|||
ui->nickname->setText(QString::fromStdString(Settings::values.yuzu_username.GetValue())); |
|||
} |
|||
|
|||
// UI Buttons
|
|||
connect(ui->refresh_list, &QPushButton::clicked, this, &Lobby::RefreshLobby); |
|||
connect(ui->games_owned, &QCheckBox::toggled, proxy, &LobbyFilterProxyModel::SetFilterOwned); |
|||
connect(ui->hide_full, &QCheckBox::toggled, proxy, &LobbyFilterProxyModel::SetFilterFull); |
|||
connect(ui->search, &QLineEdit::textChanged, proxy, &LobbyFilterProxyModel::SetFilterSearch); |
|||
connect(ui->room_list, &QTreeView::doubleClicked, this, &Lobby::OnJoinRoom); |
|||
connect(ui->room_list, &QTreeView::clicked, this, &Lobby::OnExpandRoom); |
|||
|
|||
// Actions
|
|||
connect(&room_list_watcher, &QFutureWatcher<AnnounceMultiplayerRoom::RoomList>::finished, this, |
|||
&Lobby::OnRefreshLobby); |
|||
|
|||
// manually start a refresh when the window is opening
|
|||
// TODO(jroweboy): if this refresh is slow for people with bad internet, then don't do it as
|
|||
// part of the constructor, but offload the refresh until after the window shown. perhaps emit a
|
|||
// refreshroomlist signal from places that open the lobby
|
|||
RefreshLobby(); |
|||
} |
|||
|
|||
Lobby::~Lobby() = default; |
|||
|
|||
void Lobby::UpdateGameList(QStandardItemModel* list) { |
|||
game_list->clear(); |
|||
for (int i = 0; i < list->rowCount(); i++) { |
|||
auto parent = list->item(i, 0); |
|||
for (int j = 0; j < parent->rowCount(); j++) { |
|||
game_list->appendRow(parent->child(j)->clone()); |
|||
} |
|||
} |
|||
if (proxy) |
|||
proxy->UpdateGameList(game_list); |
|||
} |
|||
|
|||
void Lobby::RetranslateUi() { |
|||
ui->retranslateUi(this); |
|||
} |
|||
|
|||
QString Lobby::PasswordPrompt() { |
|||
bool ok; |
|||
const QString text = |
|||
QInputDialog::getText(this, tr("Password Required to Join"), tr("Password:"), |
|||
QLineEdit::Password, QString(), &ok); |
|||
return ok ? text : QString(); |
|||
} |
|||
|
|||
void Lobby::OnExpandRoom(const QModelIndex& index) { |
|||
QModelIndex member_index = proxy->index(index.row(), Column::MEMBER); |
|||
auto member_list = proxy->data(member_index, LobbyItemMemberList::MemberListRole).toList(); |
|||
} |
|||
|
|||
void Lobby::OnJoinRoom(const QModelIndex& source) { |
|||
if (const auto member = room_network.GetRoomMember().lock()) { |
|||
// Prevent the user from trying to join a room while they are already joining.
|
|||
if (member->GetState() == Network::RoomMember::State::Joining) { |
|||
return; |
|||
} else if (member->IsConnected()) { |
|||
// And ask if they want to leave the room if they are already in one.
|
|||
if (!NetworkMessage::WarnDisconnect()) { |
|||
return; |
|||
} |
|||
} |
|||
} |
|||
QModelIndex index = source; |
|||
// If the user double clicks on a child row (aka the player list) then use the parent instead
|
|||
if (source.parent() != QModelIndex()) { |
|||
index = source.parent(); |
|||
} |
|||
if (!ui->nickname->hasAcceptableInput()) { |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::USERNAME_NOT_VALID); |
|||
return; |
|||
} |
|||
|
|||
// Get a password to pass if the room is password protected
|
|||
QModelIndex password_index = proxy->index(index.row(), Column::ROOM_NAME); |
|||
bool has_password = proxy->data(password_index, LobbyItemName::PasswordRole).toBool(); |
|||
const std::string password = has_password ? PasswordPrompt().toStdString() : ""; |
|||
if (has_password && password.empty()) { |
|||
return; |
|||
} |
|||
|
|||
QModelIndex connection_index = proxy->index(index.row(), Column::HOST); |
|||
const std::string nickname = ui->nickname->text().toStdString(); |
|||
const std::string ip = |
|||
proxy->data(connection_index, LobbyItemHost::HostIPRole).toString().toStdString(); |
|||
int port = proxy->data(connection_index, LobbyItemHost::HostPortRole).toInt(); |
|||
const std::string verify_uid = |
|||
proxy->data(connection_index, LobbyItemHost::HostVerifyUIDRole).toString().toStdString(); |
|||
|
|||
// attempt to connect in a different thread
|
|||
QFuture<void> f = QtConcurrent::run([nickname, ip, port, password, verify_uid, this] { |
|||
std::string token; |
|||
#ifdef ENABLE_WEB_SERVICE
|
|||
if (!Settings::values.yuzu_username.GetValue().empty() && |
|||
!Settings::values.yuzu_token.GetValue().empty()) { |
|||
WebService::Client client(Settings::values.web_api_url.GetValue(), |
|||
Settings::values.yuzu_username.GetValue(), |
|||
Settings::values.yuzu_token.GetValue()); |
|||
token = client.GetExternalJWT(verify_uid).returned_data; |
|||
if (token.empty()) { |
|||
LOG_ERROR(WebService, "Could not get external JWT, verification may fail"); |
|||
} else { |
|||
LOG_INFO(WebService, "Successfully requested external JWT: size={}", token.size()); |
|||
} |
|||
} |
|||
#endif
|
|||
if (auto room_member = room_network.GetRoomMember().lock()) { |
|||
room_member->Join(nickname, "", ip.c_str(), port, 0, Network::NoPreferredMac, password, |
|||
token); |
|||
} |
|||
}); |
|||
watcher->setFuture(f); |
|||
|
|||
// TODO(jroweboy): disable widgets and display a connecting while we wait
|
|||
|
|||
// Save settings
|
|||
UISettings::values.multiplayer_nickname = ui->nickname->text(); |
|||
UISettings::values.multiplayer_ip = |
|||
proxy->data(connection_index, LobbyItemHost::HostIPRole).toString(); |
|||
UISettings::values.multiplayer_port = |
|||
proxy->data(connection_index, LobbyItemHost::HostPortRole).toInt(); |
|||
} |
|||
|
|||
void Lobby::ResetModel() { |
|||
model->clear(); |
|||
model->insertColumns(0, Column::TOTAL); |
|||
model->setHeaderData(Column::EXPAND, Qt::Horizontal, QString(), Qt::DisplayRole); |
|||
model->setHeaderData(Column::ROOM_NAME, Qt::Horizontal, tr("Room Name"), Qt::DisplayRole); |
|||
model->setHeaderData(Column::GAME_NAME, Qt::Horizontal, tr("Preferred Game"), Qt::DisplayRole); |
|||
model->setHeaderData(Column::HOST, Qt::Horizontal, tr("Host"), Qt::DisplayRole); |
|||
model->setHeaderData(Column::MEMBER, Qt::Horizontal, tr("Players"), Qt::DisplayRole); |
|||
} |
|||
|
|||
void Lobby::RefreshLobby() { |
|||
if (auto session = announce_multiplayer_session.lock()) { |
|||
ResetModel(); |
|||
ui->refresh_list->setEnabled(false); |
|||
ui->refresh_list->setText(tr("Refreshing")); |
|||
room_list_watcher.setFuture( |
|||
QtConcurrent::run([session]() { return session->GetRoomList(); })); |
|||
} else { |
|||
// TODO(jroweboy): Display an error box about announce couldn't be started
|
|||
} |
|||
} |
|||
|
|||
void Lobby::OnRefreshLobby() { |
|||
AnnounceMultiplayerRoom::RoomList new_room_list = room_list_watcher.result(); |
|||
for (auto room : new_room_list) { |
|||
// find the icon for the game if this person owns that game.
|
|||
QPixmap smdh_icon; |
|||
for (int r = 0; r < game_list->rowCount(); ++r) { |
|||
auto index = game_list->index(r, 0); |
|||
auto game_id = game_list->data(index, GameListItemPath::ProgramIdRole).toULongLong(); |
|||
if (game_id != 0 && room.information.preferred_game.id == game_id) { |
|||
smdh_icon = game_list->data(index, Qt::DecorationRole).value<QPixmap>(); |
|||
} |
|||
} |
|||
|
|||
QList<QVariant> members; |
|||
for (auto member : room.members) { |
|||
QVariant var; |
|||
var.setValue(LobbyMember{QString::fromStdString(member.username), |
|||
QString::fromStdString(member.nickname), member.game.id, |
|||
QString::fromStdString(member.game.name)}); |
|||
members.append(var); |
|||
} |
|||
|
|||
auto first_item = new LobbyItem(); |
|||
auto row = QList<QStandardItem*>({ |
|||
first_item, |
|||
new LobbyItemName(room.has_password, QString::fromStdString(room.information.name)), |
|||
new LobbyItemGame(room.information.preferred_game.id, |
|||
QString::fromStdString(room.information.preferred_game.name), |
|||
smdh_icon), |
|||
new LobbyItemHost(QString::fromStdString(room.information.host_username), |
|||
QString::fromStdString(room.ip), room.information.port, |
|||
QString::fromStdString(room.verify_uid)), |
|||
new LobbyItemMemberList(members, room.information.member_slots), |
|||
}); |
|||
model->appendRow(row); |
|||
// To make the rows expandable, add the member data as a child of the first column of the
|
|||
// rows with people in them and have qt set them to colspan after the model is finished
|
|||
// resetting
|
|||
if (!room.information.description.empty()) { |
|||
first_item->appendRow( |
|||
new LobbyItemDescription(QString::fromStdString(room.information.description))); |
|||
} |
|||
if (!room.members.empty()) { |
|||
first_item->appendRow(new LobbyItemExpandedMemberList(members)); |
|||
} |
|||
} |
|||
|
|||
// Reenable the refresh button and resize the columns
|
|||
ui->refresh_list->setEnabled(true); |
|||
ui->refresh_list->setText(tr("Refresh List")); |
|||
ui->room_list->header()->stretchLastSection(); |
|||
for (int i = 0; i < Column::TOTAL - 1; ++i) { |
|||
ui->room_list->resizeColumnToContents(i); |
|||
} |
|||
|
|||
// Set the member list child items to span all columns
|
|||
for (int i = 0; i < proxy->rowCount(); i++) { |
|||
auto parent = model->item(i, 0); |
|||
for (int j = 0; j < parent->rowCount(); j++) { |
|||
ui->room_list->setFirstColumnSpanned(j, proxy->index(i, 0), true); |
|||
} |
|||
} |
|||
} |
|||
|
|||
LobbyFilterProxyModel::LobbyFilterProxyModel(QWidget* parent, QStandardItemModel* list) |
|||
: QSortFilterProxyModel(parent), game_list(list) {} |
|||
|
|||
void LobbyFilterProxyModel::UpdateGameList(QStandardItemModel* list) { |
|||
game_list = list; |
|||
} |
|||
|
|||
bool LobbyFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const { |
|||
// Prioritize filters by fastest to compute
|
|||
|
|||
// pass over any child rows (aka row that shows the players in the room)
|
|||
if (sourceParent != QModelIndex()) { |
|||
return true; |
|||
} |
|||
|
|||
// filter by filled rooms
|
|||
if (filter_full) { |
|||
QModelIndex member_list = sourceModel()->index(sourceRow, Column::MEMBER, sourceParent); |
|||
int player_count = |
|||
sourceModel()->data(member_list, LobbyItemMemberList::MemberListRole).toList().size(); |
|||
int max_players = |
|||
sourceModel()->data(member_list, LobbyItemMemberList::MaxPlayerRole).toInt(); |
|||
if (player_count >= max_players) { |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
// filter by search parameters
|
|||
if (!filter_search.isEmpty()) { |
|||
QModelIndex game_name = sourceModel()->index(sourceRow, Column::GAME_NAME, sourceParent); |
|||
QModelIndex room_name = sourceModel()->index(sourceRow, Column::ROOM_NAME, sourceParent); |
|||
QModelIndex host_name = sourceModel()->index(sourceRow, Column::HOST, sourceParent); |
|||
bool preferred_game_match = sourceModel() |
|||
->data(game_name, LobbyItemGame::GameNameRole) |
|||
.toString() |
|||
.contains(filter_search, filterCaseSensitivity()); |
|||
bool room_name_match = sourceModel() |
|||
->data(room_name, LobbyItemName::NameRole) |
|||
.toString() |
|||
.contains(filter_search, filterCaseSensitivity()); |
|||
bool username_match = sourceModel() |
|||
->data(host_name, LobbyItemHost::HostUsernameRole) |
|||
.toString() |
|||
.contains(filter_search, filterCaseSensitivity()); |
|||
if (!preferred_game_match && !room_name_match && !username_match) { |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
// filter by game owned
|
|||
if (filter_owned) { |
|||
QModelIndex game_name = sourceModel()->index(sourceRow, Column::GAME_NAME, sourceParent); |
|||
QList<QModelIndex> owned_games; |
|||
for (int r = 0; r < game_list->rowCount(); ++r) { |
|||
owned_games.append(QModelIndex(game_list->index(r, 0))); |
|||
} |
|||
auto current_id = sourceModel()->data(game_name, LobbyItemGame::TitleIDRole).toLongLong(); |
|||
if (current_id == 0) { |
|||
// TODO(jroweboy): homebrew often doesn't have a game id and this hides them
|
|||
return false; |
|||
} |
|||
bool owned = false; |
|||
for (const auto& game : owned_games) { |
|||
auto game_id = game_list->data(game, GameListItemPath::ProgramIdRole).toLongLong(); |
|||
if (current_id == game_id) { |
|||
owned = true; |
|||
} |
|||
} |
|||
if (!owned) { |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
void LobbyFilterProxyModel::sort(int column, Qt::SortOrder order) { |
|||
sourceModel()->sort(column, order); |
|||
} |
|||
|
|||
void LobbyFilterProxyModel::SetFilterOwned(bool filter) { |
|||
filter_owned = filter; |
|||
invalidate(); |
|||
} |
|||
|
|||
void LobbyFilterProxyModel::SetFilterFull(bool filter) { |
|||
filter_full = filter; |
|||
invalidate(); |
|||
} |
|||
|
|||
void LobbyFilterProxyModel::SetFilterSearch(const QString& filter) { |
|||
filter_search = filter; |
|||
invalidate(); |
|||
} |
|||
@ -0,0 +1,128 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <QDialog> |
|||
#include <QFutureWatcher> |
|||
#include <QSortFilterProxyModel> |
|||
#include <QStandardItemModel> |
|||
#include "common/announce_multiplayer_room.h" |
|||
#include "core/announce_multiplayer_session.h" |
|||
#include "network/network.h" |
|||
#include "yuzu/multiplayer/validation.h" |
|||
|
|||
namespace Ui { |
|||
class Lobby; |
|||
} |
|||
|
|||
class LobbyModel; |
|||
class LobbyFilterProxyModel; |
|||
|
|||
/** |
|||
* Listing of all public games pulled from services. The lobby should be simple enough for users to |
|||
* find the game they want to play, and join it. |
|||
*/ |
|||
class Lobby : public QDialog { |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
explicit Lobby(QWidget* parent, QStandardItemModel* list, |
|||
std::shared_ptr<Core::AnnounceMultiplayerSession> session, |
|||
Network::RoomNetwork& room_network_); |
|||
~Lobby() override; |
|||
|
|||
/** |
|||
* Updates the lobby with a new game list model. |
|||
* This model should be the original model of the game list. |
|||
*/ |
|||
void UpdateGameList(QStandardItemModel* list); |
|||
void RetranslateUi(); |
|||
|
|||
public slots: |
|||
/** |
|||
* Begin the process to pull the latest room list from web services. After the listing is |
|||
* returned from web services, `LobbyRefreshed` will be signalled |
|||
*/ |
|||
void RefreshLobby(); |
|||
|
|||
private slots: |
|||
/** |
|||
* Pulls the list of rooms from network and fills out the lobby model with the results |
|||
*/ |
|||
void OnRefreshLobby(); |
|||
|
|||
/** |
|||
* Handler for single clicking on a room in the list. Expands the treeitem to show player |
|||
* information for the people in the room |
|||
* |
|||
* index - The row of the proxy model that the user wants to join. |
|||
*/ |
|||
void OnExpandRoom(const QModelIndex&); |
|||
|
|||
/** |
|||
* Handler for double clicking on a room in the list. Gathers the host ip and port and attempts |
|||
* to connect. Will also prompt for a password in case one is required. |
|||
* |
|||
* index - The row of the proxy model that the user wants to join. |
|||
*/ |
|||
void OnJoinRoom(const QModelIndex&); |
|||
|
|||
signals: |
|||
void StateChanged(const Network::RoomMember::State&); |
|||
|
|||
private: |
|||
/** |
|||
* Removes all entries in the Lobby before refreshing. |
|||
*/ |
|||
void ResetModel(); |
|||
|
|||
/** |
|||
* Prompts for a password. Returns an empty QString if the user either did not provide a |
|||
* password or if the user closed the window. |
|||
*/ |
|||
QString PasswordPrompt(); |
|||
|
|||
std::unique_ptr<Ui::Lobby> ui; |
|||
|
|||
QStandardItemModel* model{}; |
|||
QStandardItemModel* game_list{}; |
|||
LobbyFilterProxyModel* proxy{}; |
|||
|
|||
QFutureWatcher<AnnounceMultiplayerRoom::RoomList> room_list_watcher; |
|||
std::weak_ptr<Core::AnnounceMultiplayerSession> announce_multiplayer_session; |
|||
QFutureWatcher<void>* watcher; |
|||
Validation validation; |
|||
Network::RoomNetwork& room_network; |
|||
}; |
|||
|
|||
/** |
|||
* Proxy Model for filtering the lobby |
|||
*/ |
|||
class LobbyFilterProxyModel : public QSortFilterProxyModel { |
|||
Q_OBJECT; |
|||
|
|||
public: |
|||
explicit LobbyFilterProxyModel(QWidget* parent, QStandardItemModel* list); |
|||
|
|||
/** |
|||
* Updates the filter with a new game list model. |
|||
* This model should be the processed one created by the Lobby. |
|||
*/ |
|||
void UpdateGameList(QStandardItemModel* list); |
|||
|
|||
bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const override; |
|||
void sort(int column, Qt::SortOrder order) override; |
|||
|
|||
public slots: |
|||
void SetFilterOwned(bool); |
|||
void SetFilterFull(bool); |
|||
void SetFilterSearch(const QString&); |
|||
|
|||
private: |
|||
QStandardItemModel* game_list; |
|||
bool filter_owned = false; |
|||
bool filter_full = false; |
|||
QString filter_search; |
|||
}; |
|||
@ -0,0 +1,123 @@ |
|||
<?xml version="1.0" encoding="UTF-8"?> |
|||
<ui version="4.0"> |
|||
<class>Lobby</class> |
|||
<widget class="QWidget" name="Lobby"> |
|||
<property name="geometry"> |
|||
<rect> |
|||
<x>0</x> |
|||
<y>0</y> |
|||
<width>903</width> |
|||
<height>487</height> |
|||
</rect> |
|||
</property> |
|||
<property name="windowTitle"> |
|||
<string>Public Room Browser</string> |
|||
</property> |
|||
<layout class="QVBoxLayout" name="verticalLayout"> |
|||
<item> |
|||
<layout class="QVBoxLayout" name="verticalLayout_2"> |
|||
<property name="spacing"> |
|||
<number>3</number> |
|||
</property> |
|||
<item> |
|||
<layout class="QHBoxLayout" name="horizontalLayout_3"> |
|||
<property name="spacing"> |
|||
<number>6</number> |
|||
</property> |
|||
<item> |
|||
<layout class="QHBoxLayout" name="horizontalLayout_5"> |
|||
<item> |
|||
<widget class="QLabel" name="label"> |
|||
<property name="text"> |
|||
<string>Nickname</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QLineEdit" name="nickname"> |
|||
<property name="placeholderText"> |
|||
<string>Nickname</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<spacer name="horizontalSpacer_2"> |
|||
<property name="orientation"> |
|||
<enum>Qt::Horizontal</enum> |
|||
</property> |
|||
<property name="sizeHint" stdset="0"> |
|||
<size> |
|||
<width>40</width> |
|||
<height>20</height> |
|||
</size> |
|||
</property> |
|||
</spacer> |
|||
</item> |
|||
<item> |
|||
<widget class="QLabel" name="label_2"> |
|||
<property name="text"> |
|||
<string>Filters</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QLineEdit" name="search"> |
|||
<property name="placeholderText"> |
|||
<string>Search</string> |
|||
</property> |
|||
<property name="clearButtonEnabled"> |
|||
<bool>true</bool> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QCheckBox" name="games_owned"> |
|||
<property name="text"> |
|||
<string>Games I Own</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QCheckBox" name="hide_full"> |
|||
<property name="text"> |
|||
<string>Hide Full Rooms</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<spacer name="horizontalSpacer"> |
|||
<property name="orientation"> |
|||
<enum>Qt::Horizontal</enum> |
|||
</property> |
|||
<property name="sizeHint" stdset="0"> |
|||
<size> |
|||
<width>40</width> |
|||
<height>20</height> |
|||
</size> |
|||
</property> |
|||
</spacer> |
|||
</item> |
|||
<item> |
|||
<widget class="QPushButton" name="refresh_list"> |
|||
<property name="text"> |
|||
<string>Refresh Lobby</string> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
<item> |
|||
<widget class="QTreeView" name="room_list"/> |
|||
</item> |
|||
<item> |
|||
<widget class="QWidget" name="widget" native="true"/> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
</layout> |
|||
</widget> |
|||
<resources/> |
|||
<connections/> |
|||
</ui> |
|||
@ -0,0 +1,238 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <utility> |
|||
#include <QPixmap> |
|||
#include <QStandardItem> |
|||
#include <QStandardItemModel> |
|||
#include "common/common_types.h" |
|||
|
|||
namespace Column { |
|||
enum List { |
|||
EXPAND, |
|||
ROOM_NAME, |
|||
GAME_NAME, |
|||
HOST, |
|||
MEMBER, |
|||
TOTAL, |
|||
}; |
|||
} |
|||
|
|||
class LobbyItem : public QStandardItem { |
|||
public: |
|||
LobbyItem() = default; |
|||
explicit LobbyItem(const QString& string) : QStandardItem(string) {} |
|||
virtual ~LobbyItem() override = default; |
|||
}; |
|||
|
|||
class LobbyItemName : public LobbyItem { |
|||
public: |
|||
static const int NameRole = Qt::UserRole + 1; |
|||
static const int PasswordRole = Qt::UserRole + 2; |
|||
|
|||
LobbyItemName() = default; |
|||
explicit LobbyItemName(bool has_password, QString name) : LobbyItem() { |
|||
setData(name, NameRole); |
|||
setData(has_password, PasswordRole); |
|||
} |
|||
|
|||
QVariant data(int role) const override { |
|||
if (role == Qt::DecorationRole) { |
|||
bool has_password = data(PasswordRole).toBool(); |
|||
return has_password ? QIcon::fromTheme(QStringLiteral("lock")).pixmap(16) : QIcon(); |
|||
} |
|||
if (role != Qt::DisplayRole) { |
|||
return LobbyItem::data(role); |
|||
} |
|||
return data(NameRole).toString(); |
|||
} |
|||
|
|||
bool operator<(const QStandardItem& other) const override { |
|||
return data(NameRole).toString().localeAwareCompare(other.data(NameRole).toString()) < 0; |
|||
} |
|||
}; |
|||
|
|||
class LobbyItemDescription : public LobbyItem { |
|||
public: |
|||
static const int DescriptionRole = Qt::UserRole + 1; |
|||
|
|||
LobbyItemDescription() = default; |
|||
explicit LobbyItemDescription(QString description) { |
|||
setData(description, DescriptionRole); |
|||
} |
|||
|
|||
QVariant data(int role) const override { |
|||
if (role != Qt::DisplayRole) { |
|||
return LobbyItem::data(role); |
|||
} |
|||
auto description = data(DescriptionRole).toString(); |
|||
description.prepend(QStringLiteral("Description: ")); |
|||
return description; |
|||
} |
|||
|
|||
bool operator<(const QStandardItem& other) const override { |
|||
return data(DescriptionRole) |
|||
.toString() |
|||
.localeAwareCompare(other.data(DescriptionRole).toString()) < 0; |
|||
} |
|||
}; |
|||
|
|||
class LobbyItemGame : public LobbyItem { |
|||
public: |
|||
static const int TitleIDRole = Qt::UserRole + 1; |
|||
static const int GameNameRole = Qt::UserRole + 2; |
|||
static const int GameIconRole = Qt::UserRole + 3; |
|||
|
|||
LobbyItemGame() = default; |
|||
explicit LobbyItemGame(u64 title_id, QString game_name, QPixmap smdh_icon) { |
|||
setData(static_cast<unsigned long long>(title_id), TitleIDRole); |
|||
setData(game_name, GameNameRole); |
|||
if (!smdh_icon.isNull()) { |
|||
setData(smdh_icon, GameIconRole); |
|||
} |
|||
} |
|||
|
|||
QVariant data(int role) const override { |
|||
if (role == Qt::DecorationRole) { |
|||
auto val = data(GameIconRole); |
|||
if (val.isValid()) { |
|||
val = val.value<QPixmap>().scaled(16, 16, Qt::KeepAspectRatio); |
|||
} |
|||
return val; |
|||
} else if (role != Qt::DisplayRole) { |
|||
return LobbyItem::data(role); |
|||
} |
|||
return data(GameNameRole).toString(); |
|||
} |
|||
|
|||
bool operator<(const QStandardItem& other) const override { |
|||
return data(GameNameRole) |
|||
.toString() |
|||
.localeAwareCompare(other.data(GameNameRole).toString()) < 0; |
|||
} |
|||
}; |
|||
|
|||
class LobbyItemHost : public LobbyItem { |
|||
public: |
|||
static const int HostUsernameRole = Qt::UserRole + 1; |
|||
static const int HostIPRole = Qt::UserRole + 2; |
|||
static const int HostPortRole = Qt::UserRole + 3; |
|||
static const int HostVerifyUIDRole = Qt::UserRole + 4; |
|||
|
|||
LobbyItemHost() = default; |
|||
explicit LobbyItemHost(QString username, QString ip, u16 port, QString verify_uid) { |
|||
setData(username, HostUsernameRole); |
|||
setData(ip, HostIPRole); |
|||
setData(port, HostPortRole); |
|||
setData(verify_uid, HostVerifyUIDRole); |
|||
} |
|||
|
|||
QVariant data(int role) const override { |
|||
if (role != Qt::DisplayRole) { |
|||
return LobbyItem::data(role); |
|||
} |
|||
return data(HostUsernameRole).toString(); |
|||
} |
|||
|
|||
bool operator<(const QStandardItem& other) const override { |
|||
return data(HostUsernameRole) |
|||
.toString() |
|||
.localeAwareCompare(other.data(HostUsernameRole).toString()) < 0; |
|||
} |
|||
}; |
|||
|
|||
class LobbyMember { |
|||
public: |
|||
LobbyMember() = default; |
|||
LobbyMember(const LobbyMember& other) = default; |
|||
explicit LobbyMember(QString username_, QString nickname_, u64 title_id_, QString game_name_) |
|||
: username(std::move(username_)), nickname(std::move(nickname_)), title_id(title_id_), |
|||
game_name(std::move(game_name_)) {} |
|||
~LobbyMember() = default; |
|||
|
|||
QString GetName() const { |
|||
if (username.isEmpty() || username == nickname) { |
|||
return nickname; |
|||
} else { |
|||
return QStringLiteral("%1 (%2)").arg(nickname, username); |
|||
} |
|||
} |
|||
u64 GetTitleId() const { |
|||
return title_id; |
|||
} |
|||
QString GetGameName() const { |
|||
return game_name; |
|||
} |
|||
|
|||
private: |
|||
QString username; |
|||
QString nickname; |
|||
u64 title_id; |
|||
QString game_name; |
|||
}; |
|||
|
|||
Q_DECLARE_METATYPE(LobbyMember); |
|||
|
|||
class LobbyItemMemberList : public LobbyItem { |
|||
public: |
|||
static const int MemberListRole = Qt::UserRole + 1; |
|||
static const int MaxPlayerRole = Qt::UserRole + 2; |
|||
|
|||
LobbyItemMemberList() = default; |
|||
explicit LobbyItemMemberList(QList<QVariant> members, u32 max_players) { |
|||
setData(members, MemberListRole); |
|||
setData(max_players, MaxPlayerRole); |
|||
} |
|||
|
|||
QVariant data(int role) const override { |
|||
if (role != Qt::DisplayRole) { |
|||
return LobbyItem::data(role); |
|||
} |
|||
auto members = data(MemberListRole).toList(); |
|||
return QStringLiteral("%1 / %2").arg(QString::number(members.size()), |
|||
data(MaxPlayerRole).toString()); |
|||
} |
|||
|
|||
bool operator<(const QStandardItem& other) const override { |
|||
// sort by rooms that have the most players |
|||
int left_members = data(MemberListRole).toList().size(); |
|||
int right_members = other.data(MemberListRole).toList().size(); |
|||
return left_members < right_members; |
|||
} |
|||
}; |
|||
|
|||
/** |
|||
* Member information for when a lobby is expanded in the UI |
|||
*/ |
|||
class LobbyItemExpandedMemberList : public LobbyItem { |
|||
public: |
|||
static const int MemberListRole = Qt::UserRole + 1; |
|||
|
|||
LobbyItemExpandedMemberList() = default; |
|||
explicit LobbyItemExpandedMemberList(QList<QVariant> members) { |
|||
setData(members, MemberListRole); |
|||
} |
|||
|
|||
QVariant data(int role) const override { |
|||
if (role != Qt::DisplayRole) { |
|||
return LobbyItem::data(role); |
|||
} |
|||
auto members = data(MemberListRole).toList(); |
|||
QString out; |
|||
bool first = true; |
|||
for (const auto& member : members) { |
|||
if (!first) |
|||
out.append(QStringLiteral("\n")); |
|||
const auto& m = member.value<LobbyMember>(); |
|||
if (m.GetGameName().isEmpty()) { |
|||
out += QString(QObject::tr("%1 is not playing a game")).arg(m.GetName()); |
|||
} else { |
|||
out += QString(QObject::tr("%1 is playing %2")).arg(m.GetName(), m.GetGameName()); |
|||
} |
|||
first = false; |
|||
} |
|||
return out; |
|||
} |
|||
}; |
|||
@ -0,0 +1,78 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <QMessageBox>
|
|||
#include <QString>
|
|||
|
|||
#include "yuzu/multiplayer/message.h"
|
|||
|
|||
namespace NetworkMessage { |
|||
const ConnectionError ErrorManager::USERNAME_NOT_VALID( |
|||
QT_TR_NOOP("Username is not valid. Must be 4 to 20 alphanumeric characters.")); |
|||
const ConnectionError ErrorManager::ROOMNAME_NOT_VALID( |
|||
QT_TR_NOOP("Room name is not valid. Must be 4 to 20 alphanumeric characters.")); |
|||
const ConnectionError ErrorManager::USERNAME_NOT_VALID_SERVER( |
|||
QT_TR_NOOP("Username is already in use or not valid. Please choose another.")); |
|||
const ConnectionError ErrorManager::IP_ADDRESS_NOT_VALID( |
|||
QT_TR_NOOP("IP is not a valid IPv4 address.")); |
|||
const ConnectionError ErrorManager::PORT_NOT_VALID( |
|||
QT_TR_NOOP("Port must be a number between 0 to 65535.")); |
|||
const ConnectionError ErrorManager::GAME_NOT_SELECTED(QT_TR_NOOP( |
|||
"You must choose a Preferred Game to host a room. If you do not have any games in your game " |
|||
"list yet, add a game folder by clicking on the plus icon in the game list.")); |
|||
const ConnectionError ErrorManager::NO_INTERNET( |
|||
QT_TR_NOOP("Unable to find an internet connection. Check your internet settings.")); |
|||
const ConnectionError ErrorManager::UNABLE_TO_CONNECT( |
|||
QT_TR_NOOP("Unable to connect to the host. Verify that the connection settings are correct. If " |
|||
"you still cannot connect, contact the room host and verify that the host is " |
|||
"properly configured with the external port forwarded.")); |
|||
const ConnectionError ErrorManager::ROOM_IS_FULL( |
|||
QT_TR_NOOP("Unable to connect to the room because it is already full.")); |
|||
const ConnectionError ErrorManager::COULD_NOT_CREATE_ROOM( |
|||
QT_TR_NOOP("Creating a room failed. Please retry. Restarting yuzu might be necessary.")); |
|||
const ConnectionError ErrorManager::HOST_BANNED( |
|||
QT_TR_NOOP("The host of the room has banned you. Speak with the host to unban you " |
|||
"or try a different room.")); |
|||
const ConnectionError ErrorManager::WRONG_VERSION( |
|||
QT_TR_NOOP("Version mismatch! Please update to the latest version of yuzu. If the problem " |
|||
"persists, contact the room host and ask them to update the server.")); |
|||
const ConnectionError ErrorManager::WRONG_PASSWORD(QT_TR_NOOP("Incorrect password.")); |
|||
const ConnectionError ErrorManager::GENERIC_ERROR(QT_TR_NOOP( |
|||
"An unknown error occurred. If this error continues to occur, please open an issue")); |
|||
const ConnectionError ErrorManager::LOST_CONNECTION( |
|||
QT_TR_NOOP("Connection to room lost. Try to reconnect.")); |
|||
const ConnectionError ErrorManager::HOST_KICKED( |
|||
QT_TR_NOOP("You have been kicked by the room host.")); |
|||
const ConnectionError ErrorManager::MAC_COLLISION( |
|||
QT_TR_NOOP("MAC address is already in use. Please choose another.")); |
|||
const ConnectionError ErrorManager::CONSOLE_ID_COLLISION(QT_TR_NOOP( |
|||
"Your Console ID conflicted with someone else's in the room.\n\nPlease go to Emulation " |
|||
"> Configure > System to regenerate your Console ID.")); |
|||
const ConnectionError ErrorManager::PERMISSION_DENIED( |
|||
QT_TR_NOOP("You do not have enough permission to perform this action.")); |
|||
const ConnectionError ErrorManager::NO_SUCH_USER(QT_TR_NOOP( |
|||
"The user you are trying to kick/ban could not be found.\nThey may have left the room.")); |
|||
|
|||
static bool WarnMessage(const std::string& title, const std::string& text) { |
|||
return QMessageBox::Ok == QMessageBox::warning(nullptr, QObject::tr(title.c_str()), |
|||
QObject::tr(text.c_str()), |
|||
QMessageBox::Ok | QMessageBox::Cancel); |
|||
} |
|||
|
|||
void ErrorManager::ShowError(const ConnectionError& e) { |
|||
QMessageBox::critical(nullptr, tr("Error"), tr(e.GetString().c_str())); |
|||
} |
|||
|
|||
bool WarnCloseRoom() { |
|||
return WarnMessage( |
|||
QT_TR_NOOP("Leave Room"), |
|||
QT_TR_NOOP("You are about to close the room. Any network connections will be closed.")); |
|||
} |
|||
|
|||
bool WarnDisconnect() { |
|||
return WarnMessage( |
|||
QT_TR_NOOP("Disconnect"), |
|||
QT_TR_NOOP("You are about to leave the room. Any network connections will be closed.")); |
|||
} |
|||
|
|||
} // namespace NetworkMessage
|
|||
@ -0,0 +1,64 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <utility> |
|||
|
|||
namespace NetworkMessage { |
|||
|
|||
class ConnectionError { |
|||
|
|||
public: |
|||
explicit ConnectionError(std::string str) : err(std::move(str)) {} |
|||
const std::string& GetString() const { |
|||
return err; |
|||
} |
|||
|
|||
private: |
|||
std::string err; |
|||
}; |
|||
|
|||
class ErrorManager : QObject { |
|||
Q_OBJECT |
|||
public: |
|||
/// When the nickname is considered invalid by the client |
|||
static const ConnectionError USERNAME_NOT_VALID; |
|||
static const ConnectionError ROOMNAME_NOT_VALID; |
|||
/// When the nickname is considered invalid by the room server |
|||
static const ConnectionError USERNAME_NOT_VALID_SERVER; |
|||
static const ConnectionError IP_ADDRESS_NOT_VALID; |
|||
static const ConnectionError PORT_NOT_VALID; |
|||
static const ConnectionError GAME_NOT_SELECTED; |
|||
static const ConnectionError NO_INTERNET; |
|||
static const ConnectionError UNABLE_TO_CONNECT; |
|||
static const ConnectionError ROOM_IS_FULL; |
|||
static const ConnectionError COULD_NOT_CREATE_ROOM; |
|||
static const ConnectionError HOST_BANNED; |
|||
static const ConnectionError WRONG_VERSION; |
|||
static const ConnectionError WRONG_PASSWORD; |
|||
static const ConnectionError GENERIC_ERROR; |
|||
static const ConnectionError LOST_CONNECTION; |
|||
static const ConnectionError HOST_KICKED; |
|||
static const ConnectionError MAC_COLLISION; |
|||
static const ConnectionError CONSOLE_ID_COLLISION; |
|||
static const ConnectionError PERMISSION_DENIED; |
|||
static const ConnectionError NO_SUCH_USER; |
|||
/** |
|||
* Shows a standard QMessageBox with a error message |
|||
*/ |
|||
static void ShowError(const ConnectionError& e); |
|||
}; |
|||
/** |
|||
* Show a standard QMessageBox with a warning message about leaving the room |
|||
* return true if the user wants to close the network connection |
|||
*/ |
|||
bool WarnCloseRoom(); |
|||
|
|||
/** |
|||
* Show a standard QMessageBox with a warning message about disconnecting from the room |
|||
* return true if the user wants to disconnect |
|||
*/ |
|||
bool WarnDisconnect(); |
|||
|
|||
} // namespace NetworkMessage |
|||
@ -0,0 +1,112 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2018 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <QStandardItem>
|
|||
#include <QStandardItemModel>
|
|||
#include "network/network.h"
|
|||
#include "network/room_member.h"
|
|||
#include "ui_moderation_dialog.h"
|
|||
#include "yuzu/multiplayer/moderation_dialog.h"
|
|||
|
|||
namespace Column { |
|||
enum { |
|||
SUBJECT, |
|||
TYPE, |
|||
COUNT, |
|||
}; |
|||
} |
|||
|
|||
ModerationDialog::ModerationDialog(Network::RoomNetwork& room_network_, QWidget* parent) |
|||
: QDialog(parent), ui(std::make_unique<Ui::ModerationDialog>()), room_network{room_network_} { |
|||
ui->setupUi(this); |
|||
|
|||
qRegisterMetaType<Network::Room::BanList>(); |
|||
|
|||
if (auto member = room_network.GetRoomMember().lock()) { |
|||
callback_handle_status_message = member->BindOnStatusMessageReceived( |
|||
[this](const Network::StatusMessageEntry& status_message) { |
|||
emit StatusMessageReceived(status_message); |
|||
}); |
|||
connect(this, &ModerationDialog::StatusMessageReceived, this, |
|||
&ModerationDialog::OnStatusMessageReceived); |
|||
callback_handle_ban_list = member->BindOnBanListReceived( |
|||
[this](const Network::Room::BanList& ban_list) { emit BanListReceived(ban_list); }); |
|||
connect(this, &ModerationDialog::BanListReceived, this, &ModerationDialog::PopulateBanList); |
|||
} |
|||
|
|||
// Initialize the UI
|
|||
model = new QStandardItemModel(ui->ban_list_view); |
|||
model->insertColumns(0, Column::COUNT); |
|||
model->setHeaderData(Column::SUBJECT, Qt::Horizontal, tr("Subject")); |
|||
model->setHeaderData(Column::TYPE, Qt::Horizontal, tr("Type")); |
|||
|
|||
ui->ban_list_view->setModel(model); |
|||
|
|||
// Load the ban list in background
|
|||
LoadBanList(); |
|||
|
|||
connect(ui->refresh, &QPushButton::clicked, this, [this] { LoadBanList(); }); |
|||
connect(ui->unban, &QPushButton::clicked, this, [this] { |
|||
auto index = ui->ban_list_view->currentIndex(); |
|||
SendUnbanRequest(model->item(index.row(), 0)->text()); |
|||
}); |
|||
connect(ui->ban_list_view, &QTreeView::clicked, [this] { ui->unban->setEnabled(true); }); |
|||
} |
|||
|
|||
ModerationDialog::~ModerationDialog() { |
|||
if (callback_handle_status_message) { |
|||
if (auto room = room_network.GetRoomMember().lock()) { |
|||
room->Unbind(callback_handle_status_message); |
|||
} |
|||
} |
|||
|
|||
if (callback_handle_ban_list) { |
|||
if (auto room = room_network.GetRoomMember().lock()) { |
|||
room->Unbind(callback_handle_ban_list); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void ModerationDialog::LoadBanList() { |
|||
if (auto room = room_network.GetRoomMember().lock()) { |
|||
ui->refresh->setEnabled(false); |
|||
ui->refresh->setText(tr("Refreshing")); |
|||
ui->unban->setEnabled(false); |
|||
room->RequestBanList(); |
|||
} |
|||
} |
|||
|
|||
void ModerationDialog::PopulateBanList(const Network::Room::BanList& ban_list) { |
|||
model->removeRows(0, model->rowCount()); |
|||
for (const auto& username : ban_list.first) { |
|||
QStandardItem* subject_item = new QStandardItem(QString::fromStdString(username)); |
|||
QStandardItem* type_item = new QStandardItem(tr("Forum Username")); |
|||
model->invisibleRootItem()->appendRow({subject_item, type_item}); |
|||
} |
|||
for (const auto& ip : ban_list.second) { |
|||
QStandardItem* subject_item = new QStandardItem(QString::fromStdString(ip)); |
|||
QStandardItem* type_item = new QStandardItem(tr("IP Address")); |
|||
model->invisibleRootItem()->appendRow({subject_item, type_item}); |
|||
} |
|||
for (int i = 0; i < Column::COUNT - 1; ++i) { |
|||
ui->ban_list_view->resizeColumnToContents(i); |
|||
} |
|||
ui->refresh->setEnabled(true); |
|||
ui->refresh->setText(tr("Refresh")); |
|||
ui->unban->setEnabled(false); |
|||
} |
|||
|
|||
void ModerationDialog::SendUnbanRequest(const QString& subject) { |
|||
if (auto room = room_network.GetRoomMember().lock()) { |
|||
room->SendModerationRequest(Network::IdModUnban, subject.toStdString()); |
|||
} |
|||
} |
|||
|
|||
void ModerationDialog::OnStatusMessageReceived(const Network::StatusMessageEntry& status_message) { |
|||
if (status_message.type != Network::IdMemberBanned && |
|||
status_message.type != Network::IdAddressUnbanned) |
|||
return; |
|||
|
|||
// Update the ban list for ban/unban
|
|||
LoadBanList(); |
|||
} |
|||
@ -0,0 +1,43 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2018 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <optional> |
|||
#include <QDialog> |
|||
#include "network/room.h" |
|||
#include "network/room_member.h" |
|||
|
|||
namespace Ui { |
|||
class ModerationDialog; |
|||
} |
|||
|
|||
class QStandardItemModel; |
|||
|
|||
class ModerationDialog : public QDialog { |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
explicit ModerationDialog(Network::RoomNetwork& room_network_, QWidget* parent = nullptr); |
|||
~ModerationDialog(); |
|||
|
|||
signals: |
|||
void StatusMessageReceived(const Network::StatusMessageEntry&); |
|||
void BanListReceived(const Network::Room::BanList&); |
|||
|
|||
private: |
|||
void LoadBanList(); |
|||
void PopulateBanList(const Network::Room::BanList& ban_list); |
|||
void SendUnbanRequest(const QString& subject); |
|||
void OnStatusMessageReceived(const Network::StatusMessageEntry& status_message); |
|||
|
|||
std::unique_ptr<Ui::ModerationDialog> ui; |
|||
QStandardItemModel* model; |
|||
Network::RoomMember::CallbackHandle<Network::StatusMessageEntry> callback_handle_status_message; |
|||
Network::RoomMember::CallbackHandle<Network::Room::BanList> callback_handle_ban_list; |
|||
|
|||
Network::RoomNetwork& room_network; |
|||
}; |
|||
|
|||
Q_DECLARE_METATYPE(Network::Room::BanList); |
|||
@ -0,0 +1,84 @@ |
|||
<?xml version="1.0" encoding="UTF-8"?> |
|||
<ui version="4.0"> |
|||
<class>ModerationDialog</class> |
|||
<widget class="QDialog" name="ModerationDialog"> |
|||
<property name="windowTitle"> |
|||
<string>Moderation</string> |
|||
</property> |
|||
<property name="geometry"> |
|||
<rect> |
|||
<x>0</x> |
|||
<y>0</y> |
|||
<width>500</width> |
|||
<height>300</height> |
|||
</rect> |
|||
</property> |
|||
<layout class="QVBoxLayout"> |
|||
<item> |
|||
<widget class="QGroupBox" name="ban_list_group_box"> |
|||
<property name="title"> |
|||
<string>Ban List</string> |
|||
</property> |
|||
<layout class="QVBoxLayout"> |
|||
<item> |
|||
<layout class="QHBoxLayout"> |
|||
<item> |
|||
<spacer name="horizontalSpacer"> |
|||
<property name="orientation"> |
|||
<enum>Qt::Horizontal</enum> |
|||
</property> |
|||
<property name="sizeHint" stdset="0"> |
|||
<size> |
|||
<width>40</width> |
|||
<height>20</height> |
|||
</size> |
|||
</property> |
|||
</spacer> |
|||
</item> |
|||
<item> |
|||
<widget class="QPushButton" name="refresh"> |
|||
<property name="text"> |
|||
<string>Refreshing</string> |
|||
</property> |
|||
<property name="enabled"> |
|||
<bool>false</bool> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QPushButton" name="unban"> |
|||
<property name="text"> |
|||
<string>Unban</string> |
|||
</property> |
|||
<property name="enabled"> |
|||
<bool>false</bool> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</item> |
|||
<item> |
|||
<widget class="QTreeView" name="ban_list_view"/> |
|||
</item> |
|||
</layout> |
|||
</widget> |
|||
</item> |
|||
<item> |
|||
<widget class="QDialogButtonBox" name="buttonBox"> |
|||
<property name="standardButtons"> |
|||
<set>QDialogButtonBox::Ok</set> |
|||
</property> |
|||
</widget> |
|||
</item> |
|||
</layout> |
|||
</widget> |
|||
<connections> |
|||
<connection> |
|||
<sender>buttonBox</sender> |
|||
<signal>accepted()</signal> |
|||
<receiver>ModerationDialog</receiver> |
|||
<slot>accept()</slot> |
|||
</connection> |
|||
</connections> |
|||
<resources/> |
|||
</ui> |
|||
@ -0,0 +1,308 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2018 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <QAction>
|
|||
#include <QApplication>
|
|||
#include <QIcon>
|
|||
#include <QMessageBox>
|
|||
#include <QStandardItemModel>
|
|||
#include "common/announce_multiplayer_room.h"
|
|||
#include "common/logging/log.h"
|
|||
#include "yuzu/game_list.h"
|
|||
#include "yuzu/multiplayer/client_room.h"
|
|||
#include "yuzu/multiplayer/direct_connect.h"
|
|||
#include "yuzu/multiplayer/host_room.h"
|
|||
#include "yuzu/multiplayer/lobby.h"
|
|||
#include "yuzu/multiplayer/message.h"
|
|||
#include "yuzu/multiplayer/state.h"
|
|||
#include "yuzu/uisettings.h"
|
|||
#include "yuzu/util/clickable_label.h"
|
|||
|
|||
MultiplayerState::MultiplayerState(QWidget* parent, QStandardItemModel* game_list_model_, |
|||
QAction* leave_room_, QAction* show_room_, |
|||
Network::RoomNetwork& room_network_) |
|||
: QWidget(parent), game_list_model(game_list_model_), leave_room(leave_room_), |
|||
show_room(show_room_), room_network{room_network_} { |
|||
if (auto member = room_network.GetRoomMember().lock()) { |
|||
// register the network structs to use in slots and signals
|
|||
state_callback_handle = member->BindOnStateChanged( |
|||
[this](const Network::RoomMember::State& state) { emit NetworkStateChanged(state); }); |
|||
connect(this, &MultiplayerState::NetworkStateChanged, this, |
|||
&MultiplayerState::OnNetworkStateChanged); |
|||
error_callback_handle = member->BindOnError( |
|||
[this](const Network::RoomMember::Error& error) { emit NetworkError(error); }); |
|||
connect(this, &MultiplayerState::NetworkError, this, &MultiplayerState::OnNetworkError); |
|||
} |
|||
|
|||
qRegisterMetaType<Network::RoomMember::State>(); |
|||
qRegisterMetaType<Network::RoomMember::Error>(); |
|||
qRegisterMetaType<WebService::WebResult>(); |
|||
announce_multiplayer_session = std::make_shared<Core::AnnounceMultiplayerSession>(room_network); |
|||
announce_multiplayer_session->BindErrorCallback( |
|||
[this](const WebService::WebResult& result) { emit AnnounceFailed(result); }); |
|||
connect(this, &MultiplayerState::AnnounceFailed, this, &MultiplayerState::OnAnnounceFailed); |
|||
|
|||
status_text = new ClickableLabel(this); |
|||
status_icon = new ClickableLabel(this); |
|||
status_text->setToolTip(tr("Current connection status")); |
|||
status_text->setText(tr("Not Connected. Click here to find a room!")); |
|||
status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("disconnected")).pixmap(16)); |
|||
|
|||
connect(status_text, &ClickableLabel::clicked, this, &MultiplayerState::OnOpenNetworkRoom); |
|||
connect(status_icon, &ClickableLabel::clicked, this, &MultiplayerState::OnOpenNetworkRoom); |
|||
|
|||
connect(static_cast<QApplication*>(QApplication::instance()), &QApplication::focusChanged, this, |
|||
[this](QWidget* /*old*/, QWidget* now) { |
|||
if (client_room && client_room->isAncestorOf(now)) { |
|||
HideNotification(); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
MultiplayerState::~MultiplayerState() { |
|||
if (state_callback_handle) { |
|||
if (auto member = room_network.GetRoomMember().lock()) { |
|||
member->Unbind(state_callback_handle); |
|||
} |
|||
} |
|||
|
|||
if (error_callback_handle) { |
|||
if (auto member = room_network.GetRoomMember().lock()) { |
|||
member->Unbind(error_callback_handle); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void MultiplayerState::Close() { |
|||
if (host_room) { |
|||
host_room->close(); |
|||
} |
|||
if (direct_connect) { |
|||
direct_connect->close(); |
|||
} |
|||
if (client_room) { |
|||
client_room->close(); |
|||
} |
|||
if (lobby) { |
|||
lobby->close(); |
|||
} |
|||
} |
|||
|
|||
void MultiplayerState::retranslateUi() { |
|||
status_text->setToolTip(tr("Current connection status")); |
|||
|
|||
if (current_state == Network::RoomMember::State::Uninitialized) { |
|||
status_text->setText(tr("Not Connected. Click here to find a room!")); |
|||
} else if (current_state == Network::RoomMember::State::Joined || |
|||
current_state == Network::RoomMember::State::Moderator) { |
|||
|
|||
status_text->setText(tr("Connected")); |
|||
} else { |
|||
status_text->setText(tr("Not Connected")); |
|||
} |
|||
|
|||
if (lobby) { |
|||
lobby->RetranslateUi(); |
|||
} |
|||
if (host_room) { |
|||
host_room->RetranslateUi(); |
|||
} |
|||
if (client_room) { |
|||
client_room->RetranslateUi(); |
|||
} |
|||
if (direct_connect) { |
|||
direct_connect->RetranslateUi(); |
|||
} |
|||
} |
|||
|
|||
void MultiplayerState::OnNetworkStateChanged(const Network::RoomMember::State& state) { |
|||
LOG_DEBUG(Frontend, "Network State: {}", Network::GetStateStr(state)); |
|||
if (state == Network::RoomMember::State::Joined || |
|||
state == Network::RoomMember::State::Moderator) { |
|||
|
|||
OnOpenNetworkRoom(); |
|||
status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("connected")).pixmap(16)); |
|||
status_text->setText(tr("Connected")); |
|||
leave_room->setEnabled(true); |
|||
show_room->setEnabled(true); |
|||
} else { |
|||
status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("disconnected")).pixmap(16)); |
|||
status_text->setText(tr("Not Connected")); |
|||
leave_room->setEnabled(false); |
|||
show_room->setEnabled(false); |
|||
} |
|||
|
|||
current_state = state; |
|||
} |
|||
|
|||
void MultiplayerState::OnNetworkError(const Network::RoomMember::Error& error) { |
|||
LOG_DEBUG(Frontend, "Network Error: {}", Network::GetErrorStr(error)); |
|||
switch (error) { |
|||
case Network::RoomMember::Error::LostConnection: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::LOST_CONNECTION); |
|||
break; |
|||
case Network::RoomMember::Error::HostKicked: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::HOST_KICKED); |
|||
break; |
|||
case Network::RoomMember::Error::CouldNotConnect: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::UNABLE_TO_CONNECT); |
|||
break; |
|||
case Network::RoomMember::Error::NameCollision: |
|||
NetworkMessage::ErrorManager::ShowError( |
|||
NetworkMessage::ErrorManager::USERNAME_NOT_VALID_SERVER); |
|||
break; |
|||
case Network::RoomMember::Error::MacCollision: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::MAC_COLLISION); |
|||
break; |
|||
case Network::RoomMember::Error::ConsoleIdCollision: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::CONSOLE_ID_COLLISION); |
|||
break; |
|||
case Network::RoomMember::Error::RoomIsFull: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::ROOM_IS_FULL); |
|||
break; |
|||
case Network::RoomMember::Error::WrongPassword: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::WRONG_PASSWORD); |
|||
break; |
|||
case Network::RoomMember::Error::WrongVersion: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::WRONG_VERSION); |
|||
break; |
|||
case Network::RoomMember::Error::HostBanned: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::HOST_BANNED); |
|||
break; |
|||
case Network::RoomMember::Error::UnknownError: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::UNABLE_TO_CONNECT); |
|||
break; |
|||
case Network::RoomMember::Error::PermissionDenied: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::PERMISSION_DENIED); |
|||
break; |
|||
case Network::RoomMember::Error::NoSuchUser: |
|||
NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::NO_SUCH_USER); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
void MultiplayerState::OnAnnounceFailed(const WebService::WebResult& result) { |
|||
announce_multiplayer_session->Stop(); |
|||
QMessageBox::warning(this, tr("Error"), |
|||
tr("Failed to update the room information. Please check your Internet " |
|||
"connection and try hosting the room again.\nDebug Message: ") + |
|||
QString::fromStdString(result.result_string), |
|||
QMessageBox::Ok); |
|||
} |
|||
|
|||
void MultiplayerState::UpdateThemedIcons() { |
|||
if (show_notification) { |
|||
status_icon->setPixmap( |
|||
QIcon::fromTheme(QStringLiteral("connected_notification")).pixmap(16)); |
|||
} else if (current_state == Network::RoomMember::State::Joined || |
|||
current_state == Network::RoomMember::State::Moderator) { |
|||
|
|||
status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("connected")).pixmap(16)); |
|||
} else { |
|||
status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("disconnected")).pixmap(16)); |
|||
} |
|||
if (client_room) |
|||
client_room->UpdateIconDisplay(); |
|||
} |
|||
|
|||
static void BringWidgetToFront(QWidget* widget) { |
|||
widget->show(); |
|||
widget->activateWindow(); |
|||
widget->raise(); |
|||
} |
|||
|
|||
void MultiplayerState::OnViewLobby() { |
|||
if (lobby == nullptr) { |
|||
lobby = new Lobby(this, game_list_model, announce_multiplayer_session, room_network); |
|||
} |
|||
BringWidgetToFront(lobby); |
|||
} |
|||
|
|||
void MultiplayerState::OnCreateRoom() { |
|||
if (host_room == nullptr) { |
|||
host_room = |
|||
new HostRoomWindow(this, game_list_model, announce_multiplayer_session, room_network); |
|||
} |
|||
BringWidgetToFront(host_room); |
|||
} |
|||
|
|||
bool MultiplayerState::OnCloseRoom() { |
|||
if (!NetworkMessage::WarnCloseRoom()) |
|||
return false; |
|||
if (auto room = room_network.GetRoom().lock()) { |
|||
// if you are in a room, leave it
|
|||
if (auto member = room_network.GetRoomMember().lock()) { |
|||
member->Leave(); |
|||
LOG_DEBUG(Frontend, "Left the room (as a client)"); |
|||
} |
|||
|
|||
// if you are hosting a room, also stop hosting
|
|||
if (room->GetState() != Network::Room::State::Open) { |
|||
return true; |
|||
} |
|||
// Save ban list
|
|||
UISettings::values.multiplayer_ban_list = std::move(room->GetBanList()); |
|||
|
|||
room->Destroy(); |
|||
announce_multiplayer_session->Stop(); |
|||
LOG_DEBUG(Frontend, "Closed the room (as a server)"); |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
void MultiplayerState::ShowNotification() { |
|||
if (client_room && client_room->isAncestorOf(QApplication::focusWidget())) |
|||
return; // Do not show notification if the chat window currently has focus
|
|||
show_notification = true; |
|||
QApplication::alert(nullptr); |
|||
status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("connected_notification")).pixmap(16)); |
|||
status_text->setText(tr("New Messages Received")); |
|||
} |
|||
|
|||
void MultiplayerState::HideNotification() { |
|||
show_notification = false; |
|||
status_icon->setPixmap(QIcon::fromTheme(QStringLiteral("connected")).pixmap(16)); |
|||
status_text->setText(tr("Connected")); |
|||
} |
|||
|
|||
void MultiplayerState::OnOpenNetworkRoom() { |
|||
if (auto member = room_network.GetRoomMember().lock()) { |
|||
if (member->IsConnected()) { |
|||
if (client_room == nullptr) { |
|||
client_room = new ClientRoomWindow(this, room_network); |
|||
connect(client_room, &ClientRoomWindow::ShowNotification, this, |
|||
&MultiplayerState::ShowNotification); |
|||
} |
|||
BringWidgetToFront(client_room); |
|||
return; |
|||
} |
|||
} |
|||
// If the user is not a member of a room, show the lobby instead.
|
|||
// This is currently only used on the clickable label in the status bar
|
|||
OnViewLobby(); |
|||
} |
|||
|
|||
void MultiplayerState::OnDirectConnectToRoom() { |
|||
if (direct_connect == nullptr) { |
|||
direct_connect = new DirectConnectWindow(room_network, this); |
|||
} |
|||
BringWidgetToFront(direct_connect); |
|||
} |
|||
|
|||
bool MultiplayerState::IsHostingPublicRoom() const { |
|||
return announce_multiplayer_session->IsRunning(); |
|||
} |
|||
|
|||
void MultiplayerState::UpdateCredentials() { |
|||
announce_multiplayer_session->UpdateCredentials(); |
|||
} |
|||
|
|||
void MultiplayerState::UpdateGameList(QStandardItemModel* game_list) { |
|||
game_list_model = game_list; |
|||
if (lobby) { |
|||
lobby->UpdateGameList(game_list); |
|||
} |
|||
if (host_room) { |
|||
host_room->UpdateGameList(game_list); |
|||
} |
|||
} |
|||
@ -0,0 +1,92 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2018 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <QWidget> |
|||
#include "core/announce_multiplayer_session.h" |
|||
#include "network/network.h" |
|||
|
|||
class QStandardItemModel; |
|||
class Lobby; |
|||
class HostRoomWindow; |
|||
class ClientRoomWindow; |
|||
class DirectConnectWindow; |
|||
class ClickableLabel; |
|||
|
|||
class MultiplayerState : public QWidget { |
|||
Q_OBJECT; |
|||
|
|||
public: |
|||
explicit MultiplayerState(QWidget* parent, QStandardItemModel* game_list, QAction* leave_room, |
|||
QAction* show_room, Network::RoomNetwork& room_network_); |
|||
~MultiplayerState(); |
|||
|
|||
/** |
|||
* Close all open multiplayer related dialogs |
|||
*/ |
|||
void Close(); |
|||
|
|||
ClickableLabel* GetStatusText() const { |
|||
return status_text; |
|||
} |
|||
|
|||
ClickableLabel* GetStatusIcon() const { |
|||
return status_icon; |
|||
} |
|||
|
|||
void retranslateUi(); |
|||
|
|||
/** |
|||
* Whether a public room is being hosted or not. |
|||
* When this is true, Web Services configuration should be disabled. |
|||
*/ |
|||
bool IsHostingPublicRoom() const; |
|||
|
|||
void UpdateCredentials(); |
|||
|
|||
/** |
|||
* Updates the multiplayer dialogs with a new game list model. |
|||
* This model should be the original model of the game list. |
|||
*/ |
|||
void UpdateGameList(QStandardItemModel* game_list); |
|||
|
|||
public slots: |
|||
void OnNetworkStateChanged(const Network::RoomMember::State& state); |
|||
void OnNetworkError(const Network::RoomMember::Error& error); |
|||
void OnViewLobby(); |
|||
void OnCreateRoom(); |
|||
bool OnCloseRoom(); |
|||
void OnOpenNetworkRoom(); |
|||
void OnDirectConnectToRoom(); |
|||
void OnAnnounceFailed(const WebService::WebResult&); |
|||
void UpdateThemedIcons(); |
|||
void ShowNotification(); |
|||
void HideNotification(); |
|||
|
|||
signals: |
|||
void NetworkStateChanged(const Network::RoomMember::State&); |
|||
void NetworkError(const Network::RoomMember::Error&); |
|||
void AnnounceFailed(const WebService::WebResult&); |
|||
|
|||
private: |
|||
Lobby* lobby = nullptr; |
|||
HostRoomWindow* host_room = nullptr; |
|||
ClientRoomWindow* client_room = nullptr; |
|||
DirectConnectWindow* direct_connect = nullptr; |
|||
ClickableLabel* status_icon = nullptr; |
|||
ClickableLabel* status_text = nullptr; |
|||
QStandardItemModel* game_list_model = nullptr; |
|||
QAction* leave_room; |
|||
QAction* show_room; |
|||
std::shared_ptr<Core::AnnounceMultiplayerSession> announce_multiplayer_session; |
|||
Network::RoomMember::State current_state = Network::RoomMember::State::Uninitialized; |
|||
bool has_mod_perms = false; |
|||
Network::RoomMember::CallbackHandle<Network::RoomMember::State> state_callback_handle; |
|||
Network::RoomMember::CallbackHandle<Network::RoomMember::Error> error_callback_handle; |
|||
|
|||
bool show_notification = false; |
|||
Network::RoomNetwork& room_network; |
|||
}; |
|||
|
|||
Q_DECLARE_METATYPE(WebService::WebResult); |
|||
@ -0,0 +1,48 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <QRegExp> |
|||
#include <QString> |
|||
#include <QValidator> |
|||
|
|||
class Validation { |
|||
public: |
|||
Validation() |
|||
: room_name(room_name_regex), nickname(nickname_regex), ip(ip_regex), port(0, 65535) {} |
|||
|
|||
~Validation() = default; |
|||
|
|||
const QValidator* GetRoomName() const { |
|||
return &room_name; |
|||
} |
|||
const QValidator* GetNickname() const { |
|||
return &nickname; |
|||
} |
|||
const QValidator* GetIP() const { |
|||
return &ip; |
|||
} |
|||
const QValidator* GetPort() const { |
|||
return &port; |
|||
} |
|||
|
|||
private: |
|||
/// room name can be alphanumeric and " " "_" "." and "-" and must have a size of 4-20 |
|||
QRegExp room_name_regex = QRegExp(QStringLiteral("^[a-zA-Z0-9._- ]{4,20}$")); |
|||
QRegExpValidator room_name; |
|||
|
|||
/// nickname can be alphanumeric and " " "_" "." and "-" and must have a size of 4-20 |
|||
QRegExp nickname_regex = QRegExp(QStringLiteral("^[a-zA-Z0-9._- ]{4,20}$")); |
|||
QRegExpValidator nickname; |
|||
|
|||
/// ipv4 address only |
|||
// TODO remove this when we support hostnames in direct connect |
|||
QRegExp ip_regex = QRegExp(QStringLiteral( |
|||
"(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|" |
|||
"2[0-4][0-9]|25[0-5])")); |
|||
QRegExpValidator ip; |
|||
|
|||
/// port must be between 0 and 65535 |
|||
QIntValidator port; |
|||
}; |
|||
@ -0,0 +1,11 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include "yuzu/util/clickable_label.h"
|
|||
|
|||
ClickableLabel::ClickableLabel(QWidget* parent, [[maybe_unused]] Qt::WindowFlags f) |
|||
: QLabel(parent) {} |
|||
|
|||
void ClickableLabel::mouseReleaseEvent([[maybe_unused]] QMouseEvent* event) { |
|||
emit clicked(); |
|||
} |
|||
@ -0,0 +1,21 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <QLabel> |
|||
#include <QWidget> |
|||
|
|||
class ClickableLabel : public QLabel { |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
explicit ClickableLabel(QWidget* parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags()); |
|||
~ClickableLabel() = default; |
|||
|
|||
signals: |
|||
void clicked(); |
|||
|
|||
protected: |
|||
void mouseReleaseEvent(QMouseEvent* event); |
|||
}; |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue