refactor: feature flags

Author: TheDevMinerTV

src/network/connection.cpp

@@ -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());
@@ -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());
 }
@@ -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();
@@ -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

src/network/connection.h

@@ -37,6 +37,9 @@ namespace Network {
 
 class Connection {
 public:
+	Connection()
+		: m_FirmwareFeatures(m_EnabledFirmwareFeatures) {}
+
 	void searchForServer();
 	void update();
 	void reset();
@@ -107,7 +110,7 @@ class Connection {
 	);
 #endif
 
-	const ServerFeatures& getServerFeatureFlags() { return m_ServerFeatures; }
+	const auto getServerFeatureFlags() { return m_ServerFeatures; }
 
 	bool beginBundle();
 	bool endBundle();
@@ -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;

src/network/featureflags.h

@@ -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