Mirrors/MissionControl
2
0
Fork 0
mirror of https://github.com/ndeadly/MissionControl synced 2025-02-17 05:38:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

mc.mitm: use shared_ptr for controller list and disconnect controller that fails to initialise instead of aborting

Browse source
This commit is contained in:
ndeadly 2022-03-30 16:09:08 +11:00
parent 0081027385
commit c2402888a6
1 changed files with 42 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

77
mc_mitm/source/controllers/controller_management.cpp
View file

@ -15,7 +15,6 @@
*/
#include "controller_management.hpp"
#include <stratosphere.hpp>
#include <memory>
#include <mutex>
#include <vector>
#include <cstring>
@ -42,7 +41,7 @@ namespace ams::controller {
constexpr auto cod_minor_keyboard = 0x40;
os::Mutex g_controller_lock(false);
std::vector<std::unique_ptr<SwitchController>> g_controllers;
std::vector<std::shared_ptr<SwitchController>> g_controllers;
inline bool bdcmp(const bluetooth::Address *addr1, const bluetooth::Address *addr2) {
return std::memcmp(addr1, addr2, sizeof(bluetooth::Address)) == 0;
@ -88,8 +87,8 @@ namespace ams::controller {
for (auto hwId : GamestickController::hardware_ids) {
if ( (device->vid == hwId.vid) && (device->pid == hwId.pid) ) {
return ControllerType_Gamestick;
}
}
}
}
for (auto hwId : GemboxController::hardware_ids) {
if ( (device->vid == hwId.vid) && (device->pid == hwId.pid) ) {
@ -199,86 +198,94 @@ namespace ams::controller {
}
void AttachHandler(const bluetooth::Address *address) {
std::scoped_lock lk(g_controller_lock);
bluetooth::DevicesSettings device_settings;
R_ABORT_UNLESS(btdrvGetPairedDeviceInfo(*address, &device_settings));
HardwareID id = { device_settings.vid, device_settings.pid };
std::shared_ptr<SwitchController> controller;
switch (Identify(&device_settings)) {
case ControllerType_Switch:
g_controllers.push_back(std::make_unique<SwitchController>(address, id));
controller = std::make_shared<SwitchController>(address, id);
break;
case ControllerType_Wii:
g_controllers.push_back(std::make_unique<WiiController>(address, id));
controller = std::make_shared<WiiController>(address, id);
break;
case ControllerType_Dualshock4:
g_controllers.push_back(std::make_unique<Dualshock4Controller>(address, id));
controller = std::make_shared<Dualshock4Controller>(address, id);
break;
case ControllerType_Dualsense:
g_controllers.push_back(std::make_unique<DualsenseController>(address, id));
controller = std::make_shared<DualsenseController>(address, id);
break;
case ControllerType_XboxOne:
g_controllers.push_back(std::make_unique<XboxOneController>(address, id));
controller = std::make_shared<XboxOneController>(address, id);
break;
case ControllerType_Ouya:
g_controllers.push_back(std::make_unique<OuyaController>(address, id));
controller = std::make_shared<OuyaController>(address, id);
break;
case ControllerType_Gamestick:
g_controllers.push_back(std::make_unique<GamestickController>(address, id));
break;
controller = std::make_shared<GamestickController>(address, id);
break;
case ControllerType_Gembox:
g_controllers.push_back(std::make_unique<GemboxController>(address, id));
controller = std::make_shared<GemboxController>(address, id);
break;
case ControllerType_Ipega:
g_controllers.push_back(std::make_unique<IpegaController>(address, id));
break;
controller = std::make_shared<IpegaController>(address, id);
break;
case ControllerType_Xiaomi:
g_controllers.push_back(std::make_unique<XiaomiController>(address, id));
controller = std::make_shared<XiaomiController>(address, id);
break;
case ControllerType_Gamesir:
g_controllers.push_back(std::make_unique<GamesirController>(address, id));
break;
controller = std::make_shared<GamesirController>(address, id);
break;
case ControllerType_Steelseries:
g_controllers.push_back(std::make_unique<SteelseriesController>(address, id));
controller = std::make_shared<SteelseriesController>(address, id);
break;
case ControllerType_NvidiaShield:
g_controllers.push_back(std::make_unique<NvidiaShieldController>(address, id));
break;
controller = std::make_shared<NvidiaShieldController>(address, id);
break;
case ControllerType_8BitDo:
g_controllers.push_back(std::make_unique<EightBitDoController>(address, id));
controller = std::make_shared<EightBitDoController>(address, id);
break;
case ControllerType_PowerA:
g_controllers.push_back(std::make_unique<PowerAController>(address, id));
controller = std::make_shared<PowerAController>(address, id);
break;
case ControllerType_MadCatz:
g_controllers.push_back(std::make_unique<MadCatzController>(address, id));
controller = std::make_shared<MadCatzController>(address, id);
break;
case ControllerType_Mocute:
g_controllers.push_back(std::make_unique<MocuteController>(address, id));
controller = std::make_shared<MocuteController>(address, id);
break;
case ControllerType_Razer:
g_controllers.push_back(std::make_unique<RazerController>(address, id));
controller = std::make_shared<RazerController>(address, id);
break;
case ControllerType_ICade:
g_controllers.push_back(std::make_unique<ICadeController>(address, id));
controller = std::make_shared<ICadeController>(address, id);
break;
case ControllerType_LanShen:
g_controllers.push_back(std::make_unique<LanShenController>(address, id));
case ControllerType_LanShen:
controller = std::make_shared<LanShenController>(address, id);
break;
case ControllerType_AtGames:
g_controllers.push_back(std::make_unique<AtGamesController>(address, id));
controller = std::make_shared<AtGamesController>(address, id);
break;
case ControllerType_Hyperkin:
g_controllers.push_back(std::make_unique<HyperkinController>(address, id));
controller = std::make_shared<HyperkinController>(address, id);
break;
default:
g_controllers.push_back(std::make_unique<UnknownController>(address, id));
controller = std::make_shared<UnknownController>(address, id);
break;
}
R_ABORT_UNLESS(g_controllers.back()->Initialize());
{
std::scoped_lock lk(g_controller_lock);
g_controllers.push_back(controller);
}
if (R_FAILED(controller->Initialize())) {
// Try to disconnect the controller
btdrvCloseHidConnection(controller->Address());
}
}
void RemoveHandler(const bluetooth::Address *address) {