Skip to content

Commit

Permalink
refactor: feature flags
Browse files Browse the repository at this point in the history
  • Loading branch information
TheDevMinerTV committed Oct 1, 2023
1 parent ad07c98 commit dd21566
Show file tree
Hide file tree
Showing 3 changed files with 100 additions and 93 deletions.
14 changes: 9 additions & 5 deletions src/network/connection.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -118,7 +118,8 @@ bool Connection::beginBundle() {
memset(m_BundledPacket, 0, sizeof(m_BundledPacket));
m_BundlePacketInnerCount = 0;

MUST_TRANSFER_BOOL(m_ServerFeatures.has(ServerFeatures::PROTOCOL_BUNDLE_SUPPORT));
MUST_TRANSFER_BOOL(m_ServerFeatures.has(EServerFeatureFlags::PROTOCOL_BUNDLE_SUPPORT
));
MUST_TRANSFER_BOOL(m_Connected);
MUST_TRANSFER_BOOL(!m_IsBundle);
MUST_TRANSFER_BOOL(beginPacket());
Expand Down Expand Up @@ -378,7 +379,8 @@ void Connection::sendFeatureFlags() {

MUST(sendPacketType(PACKET_FEATURE_FLAGS));
MUST(sendPacketNumber());
MUST(write(FirmwareFeatures::flags.data(), FirmwareFeatures::flags.size()));
auto packedFeatures = m_FirmwareFeatures.pack();
MUST(write(packedFeatures.data(), packedFeatures.size()));

MUST(endPacket());
}
Expand Down Expand Up @@ -577,7 +579,7 @@ void Connection::searchForServer() {
m_Connected = true;

m_FeatureFlagsRequestAttempts = 0;
m_ServerFeatures = ServerFeatures{};
m_ServerFeatures = FeatureFlags<EServerFeatureFlags>();

statusManager.setStatus(SlimeVR::Status::SERVER_CONNECTING, false);
ledManager.off();
Expand Down Expand Up @@ -711,11 +713,13 @@ void Connection::update() {

bool hadFlags = m_ServerFeatures.isAvailable();
uint32_t flagsLength = len - 12;
m_ServerFeatures = ServerFeatures::from(&m_Packet[12], flagsLength);
m_ServerFeatures
= FeatureFlags<EServerFeatureFlags>(&m_Packet[12], flagsLength);

if (!hadFlags) {
#if PACKET_BUNDLING != PACKET_BUNDLING_DISABLED
if (m_ServerFeatures.has(ServerFeatures::PROTOCOL_BUNDLE_SUPPORT)) {
if (m_ServerFeatures.has(EServerFeatureFlags::PROTOCOL_BUNDLE_SUPPORT
)) {
m_Logger.debug("Server supports packet bundling");
}
#endif
Expand Down
11 changes: 9 additions & 2 deletions src/network/connection.h
Original file line number Diff line number Diff line change
Expand Up @@ -37,6 +37,9 @@ namespace Network {

class Connection {
public:
Connection()
: m_FirmwareFeatures(m_EnabledFirmwareFeatures) {}

void searchForServer();
void update();
void reset();
Expand Down Expand Up @@ -107,7 +110,7 @@ class Connection {
);
#endif

const ServerFeatures& getServerFeatureFlags() { return m_ServerFeatures; }
const auto getServerFeatureFlags() { return m_ServerFeatures; }

bool beginBundle();
bool endBundle();
Expand Down Expand Up @@ -166,7 +169,11 @@ class Connection {

uint8_t m_FeatureFlagsRequestAttempts = 0;
unsigned long m_FeatureFlagsRequestTimestamp = millis();
ServerFeatures m_ServerFeatures{};
FeatureFlags<EServerFeatureFlags> m_ServerFeatures;
std::unordered_map<EFirmwareFeatureFlags, bool, EnumClassHash>
m_EnabledFirmwareFeatures
= {{EFirmwareFeatureFlags::B64_WIFI_SCANNING, true}};
FeatureFlags<EFirmwareFeatureFlags> m_FirmwareFeatures;

bool m_IsBundle = false;
bool m_BundleFinished = false;
Expand Down
168 changes: 82 additions & 86 deletions src/network/featureflags.h
Original file line number Diff line number Diff line change
@@ -1,103 +1,99 @@

/*
SlimeVR Code is placed under the MIT license
Copyright (c) 2023 SlimeVR Contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
SlimeVR Code is placed under the MIT license
Copyright (c) 2023 SlimeVR Contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

#ifndef SLIMEVR_FEATURE_FLAGS_H_
#define SLIMEVR_FEATURE_FLAGS_H_

#include <cstring>
#include <algorithm>

/**
* Bit packed flags, enum values start with 0 and indicate which bit it is.
*
* Change the enums and `flagsEnabled` inside to extend.
*/
struct ServerFeatures {
public:
enum EServerFeatureFlags: uint32_t {
// Server can parse bundle packets: `PACKET_BUNDLE` = 100 (0x64).
PROTOCOL_BUNDLE_SUPPORT,

// Add new flags here

BITS_TOTAL,
};

bool has(EServerFeatureFlags flag) {
uint32_t bit = static_cast<uint32_t>(flag);
return m_Available && (m_Flags[bit / 8] & (1 << (bit % 8)));
}

/**
* Whether the server supports the "feature flags" feature,
* set to true when we've received flags packet from the server.
*/
bool isAvailable() {
return m_Available;
}

static ServerFeatures from(uint8_t* received, uint32_t length) {
ServerFeatures res;
res.m_Available = true;
memcpy(res.m_Flags, received, std::min(static_cast<uint32_t>(sizeof(res.m_Flags)), length));
return res;
}

private:
bool m_Available = false;

uint8_t m_Flags[static_cast<uint32_t>(EServerFeatureFlags::BITS_TOTAL) / 8 + 1];
#include <cinttypes>
#include <cstring>
#include <unordered_map>

// I hate C++11 - they fixed this in C++14, but our compilers are old as the iceage
struct EnumClassHash {
template <typename T>
std::size_t operator()(T t) const {
return static_cast<std::size_t>(t);
}
};

class FirmwareFeatures {
public:
enum EFirmwareFeatureFlags: uint32_t {
// EXAMPLE_FEATURE,
B64_WIFI_SCANNING = 1,

// Add new flags here

BITS_TOTAL,
};
enum EServerFeatureFlags : uint32_t {
// Server can parse bundle packets: `PACKET_BUNDLE` = 100 (0x64).
PROTOCOL_BUNDLE_SUPPORT,

// Flags to send
static constexpr const std::initializer_list<EFirmwareFeatureFlags> flagsEnabled = {
// EXAMPLE_FEATURE,
B64_WIFI_SCANNING,
BITS_TOTAL,
};

// Add enabled flags here
};
enum class EFirmwareFeatureFlags : uint32_t {
// EXAMPLE_FEATURE,
B64_WIFI_SCANNING = 1,

static constexpr auto flags = []{
constexpr uint32_t flagsLength = EFirmwareFeatureFlags::BITS_TOTAL / 8 + 1;
std::array<uint8_t, flagsLength> packed{};
BITS_TOTAL,
};

for (uint32_t bit : flagsEnabled) {
packed[bit / 8] |= 1 << (bit % 8);
}
template <typename Flags>
class FeatureFlags {
public:
static constexpr auto FLAG_BYTES
= ((static_cast<size_t>(Flags::BITS_TOTAL)) + 7) / 8;

FeatureFlags()
: m_Available(false) {}
FeatureFlags(uint8_t* packed, uint32_t length)
: m_Available(true) {
for (uint32_t bit = 0; bit < length * 8; bit++) {
auto posInPacked = bit / 8;
auto posInByte = bit % 8;

m_Flags[static_cast<Flags>(bit)] = packed[posInPacked] & (1 << posInByte);
}
}
FeatureFlags(std::unordered_map<Flags, bool, EnumClassHash> flags)
: m_Available(true)
, m_Flags(flags) {}

std::array<uint8_t, FLAG_BYTES> pack() {
std::array<uint8_t, FLAG_BYTES> packed{};

for (auto& [flag, value] : m_Flags) {
auto posInPacked = static_cast<size_t>(flag) / 8;
auto posInByte = static_cast<size_t>(flag) % 8;

if (value) {
packed[posInPacked] |= 1 << posInByte;
}
}

return packed;
};

bool has(Flags flag) { return m_Flags[flag]; }
bool isAvailable() { return m_Available; }

return packed;
}();
private:
bool m_Available = false;
std::unordered_map<Flags, bool, EnumClassHash> m_Flags{};
};

#endif

0 comments on commit dd21566

Please sign in to comment.