1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/*
* Copyright (C) 2015-2018 Team Kodi
* This file is part of Kodi - https://kodi.tv
*
* SPDX-License-Identifier: GPL-2.0-or-later
* See LICENSES/README.md for more information.
*/
#include "Controller.h"
#include "ControllerDefinitions.h"
#include "ControllerLayout.h"
#include "URL.h"
#include "addons/addoninfo/AddonType.h"
#include "games/controllers/input/PhysicalTopology.h"
#include "utils/XBMCTinyXML.h"
#include "utils/XMLUtils.h"
#include "utils/log.h"
#include <algorithm>
using namespace KODI;
using namespace GAME;
// --- FeatureTypeEqual --------------------------------------------------------
struct FeatureTypeEqual
{
FeatureTypeEqual(FEATURE_TYPE type, JOYSTICK::INPUT_TYPE inputType)
: type(type), inputType(inputType)
{
}
bool operator()(const CPhysicalFeature& feature) const
{
if (type == FEATURE_TYPE::UNKNOWN)
return true; // Match all feature types
if (type == FEATURE_TYPE::SCALAR && feature.Type() == FEATURE_TYPE::SCALAR)
{
if (inputType == JOYSTICK::INPUT_TYPE::UNKNOWN)
return true; // Match all input types
return inputType == feature.InputType();
}
return type == feature.Type();
}
const FEATURE_TYPE type;
const JOYSTICK::INPUT_TYPE inputType;
};
// --- CController -------------------------------------------------------------
const ControllerPtr CController::EmptyPtr;
CController::CController(const ADDON::AddonInfoPtr& addonInfo)
: CAddon(addonInfo, ADDON::AddonType::GAME_CONTROLLER), m_layout(new CControllerLayout)
{
}
CController::~CController() = default;
const CPhysicalFeature& CController::GetFeature(const std::string& name) const
{
auto it =
std::find_if(m_features.begin(), m_features.end(),
[&name](const CPhysicalFeature& feature) { return name == feature.Name(); });
if (it != m_features.end())
return *it;
static const CPhysicalFeature invalid{};
return invalid;
}
unsigned int CController::FeatureCount(
FEATURE_TYPE type /* = FEATURE_TYPE::UNKNOWN */,
JOYSTICK::INPUT_TYPE inputType /* = JOYSTICK::INPUT_TYPE::UNKNOWN */) const
{
auto featureCount =
std::count_if(m_features.begin(), m_features.end(), FeatureTypeEqual(type, inputType));
return static_cast<unsigned int>(featureCount);
}
void CController::GetFeatures(std::vector<std::string>& features,
FEATURE_TYPE type /* = FEATURE_TYPE::UNKNOWN */) const
{
for (const CPhysicalFeature& feature : m_features)
{
if (type == FEATURE_TYPE::UNKNOWN || type == feature.Type())
features.push_back(feature.Name());
}
}
JOYSTICK::FEATURE_TYPE CController::FeatureType(const std::string& feature) const
{
for (auto it = m_features.begin(); it != m_features.end(); ++it)
{
if (feature == it->Name())
return it->Type();
}
return JOYSTICK::FEATURE_TYPE::UNKNOWN;
}
JOYSTICK::INPUT_TYPE CController::GetInputType(const std::string& feature) const
{
for (auto it = m_features.begin(); it != m_features.end(); ++it)
{
if (feature == it->Name())
return it->InputType();
}
return JOYSTICK::INPUT_TYPE::UNKNOWN;
}
bool CController::LoadLayout(void)
{
if (!m_bLoaded)
{
std::string strLayoutXmlPath = LibPath();
CLog::Log(LOGINFO, "Loading controller layout: {}", CURL::GetRedacted(strLayoutXmlPath));
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strLayoutXmlPath))
{
CLog::Log(LOGDEBUG, "Unable to load file: {} at line {}", xmlDoc.ErrorDesc(),
xmlDoc.ErrorRow());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement || pRootElement->NoChildren() || pRootElement->ValueStr() != LAYOUT_XML_ROOT)
{
CLog::Log(LOGERROR, "Can't find root <{}> tag", LAYOUT_XML_ROOT);
return false;
}
m_layout->Deserialize(pRootElement, this, m_features);
if (m_layout->IsValid(true))
{
m_bLoaded = true;
}
else
{
m_layout->Reset();
}
}
return m_bLoaded;
}
const CPhysicalTopology& CController::Topology() const
{
return m_layout->Topology();
}
|
