diff --git a/MeshtasticProtobufs/Sources/meshtastic/admin.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/admin.pb.swift
index 0f1c3586..d9ecbe22 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/admin.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/admin.pb.swift
@@ -24,7 +24,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
/// This message is handled by the Admin module and is responsible for all settings/channel read/write operations.
/// This message is used to do settings operations to both remote AND local nodes.
/// (Prior to 1.2 these operations were done via special ToRadio operations)
-public struct AdminMessage {
+public struct AdminMessage: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -483,7 +483,7 @@ public struct AdminMessage {
///
/// TODO: REPLACE
- public enum OneOf_PayloadVariant: Equatable {
+ public enum OneOf_PayloadVariant: Equatable, Sendable {
///
/// Send the specified channel in the response to this message
/// NOTE: This field is sent with the channel index + 1 (to ensure we never try to send 'zero' - which protobufs treats as not present)
@@ -624,193 +624,11 @@ public struct AdminMessage {
/// Tell the node to reset the nodedb.
case nodedbReset(Int32)
- #if !swift(>=4.1)
- public static func ==(lhs: AdminMessage.OneOf_PayloadVariant, rhs: AdminMessage.OneOf_PayloadVariant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.getChannelRequest, .getChannelRequest): return {
- guard case .getChannelRequest(let l) = lhs, case .getChannelRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getChannelResponse, .getChannelResponse): return {
- guard case .getChannelResponse(let l) = lhs, case .getChannelResponse(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getOwnerRequest, .getOwnerRequest): return {
- guard case .getOwnerRequest(let l) = lhs, case .getOwnerRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getOwnerResponse, .getOwnerResponse): return {
- guard case .getOwnerResponse(let l) = lhs, case .getOwnerResponse(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getConfigRequest, .getConfigRequest): return {
- guard case .getConfigRequest(let l) = lhs, case .getConfigRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getConfigResponse, .getConfigResponse): return {
- guard case .getConfigResponse(let l) = lhs, case .getConfigResponse(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getModuleConfigRequest, .getModuleConfigRequest): return {
- guard case .getModuleConfigRequest(let l) = lhs, case .getModuleConfigRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getModuleConfigResponse, .getModuleConfigResponse): return {
- guard case .getModuleConfigResponse(let l) = lhs, case .getModuleConfigResponse(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getCannedMessageModuleMessagesRequest, .getCannedMessageModuleMessagesRequest): return {
- guard case .getCannedMessageModuleMessagesRequest(let l) = lhs, case .getCannedMessageModuleMessagesRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getCannedMessageModuleMessagesResponse, .getCannedMessageModuleMessagesResponse): return {
- guard case .getCannedMessageModuleMessagesResponse(let l) = lhs, case .getCannedMessageModuleMessagesResponse(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getDeviceMetadataRequest, .getDeviceMetadataRequest): return {
- guard case .getDeviceMetadataRequest(let l) = lhs, case .getDeviceMetadataRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getDeviceMetadataResponse, .getDeviceMetadataResponse): return {
- guard case .getDeviceMetadataResponse(let l) = lhs, case .getDeviceMetadataResponse(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getRingtoneRequest, .getRingtoneRequest): return {
- guard case .getRingtoneRequest(let l) = lhs, case .getRingtoneRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getRingtoneResponse, .getRingtoneResponse): return {
- guard case .getRingtoneResponse(let l) = lhs, case .getRingtoneResponse(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getDeviceConnectionStatusRequest, .getDeviceConnectionStatusRequest): return {
- guard case .getDeviceConnectionStatusRequest(let l) = lhs, case .getDeviceConnectionStatusRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getDeviceConnectionStatusResponse, .getDeviceConnectionStatusResponse): return {
- guard case .getDeviceConnectionStatusResponse(let l) = lhs, case .getDeviceConnectionStatusResponse(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setHamMode, .setHamMode): return {
- guard case .setHamMode(let l) = lhs, case .setHamMode(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getNodeRemoteHardwarePinsRequest, .getNodeRemoteHardwarePinsRequest): return {
- guard case .getNodeRemoteHardwarePinsRequest(let l) = lhs, case .getNodeRemoteHardwarePinsRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.getNodeRemoteHardwarePinsResponse, .getNodeRemoteHardwarePinsResponse): return {
- guard case .getNodeRemoteHardwarePinsResponse(let l) = lhs, case .getNodeRemoteHardwarePinsResponse(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.enterDfuModeRequest, .enterDfuModeRequest): return {
- guard case .enterDfuModeRequest(let l) = lhs, case .enterDfuModeRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.deleteFileRequest, .deleteFileRequest): return {
- guard case .deleteFileRequest(let l) = lhs, case .deleteFileRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setScale, .setScale): return {
- guard case .setScale(let l) = lhs, case .setScale(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setOwner, .setOwner): return {
- guard case .setOwner(let l) = lhs, case .setOwner(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setChannel, .setChannel): return {
- guard case .setChannel(let l) = lhs, case .setChannel(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setConfig, .setConfig): return {
- guard case .setConfig(let l) = lhs, case .setConfig(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setModuleConfig, .setModuleConfig): return {
- guard case .setModuleConfig(let l) = lhs, case .setModuleConfig(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setCannedMessageModuleMessages, .setCannedMessageModuleMessages): return {
- guard case .setCannedMessageModuleMessages(let l) = lhs, case .setCannedMessageModuleMessages(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setRingtoneMessage, .setRingtoneMessage): return {
- guard case .setRingtoneMessage(let l) = lhs, case .setRingtoneMessage(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.removeByNodenum, .removeByNodenum): return {
- guard case .removeByNodenum(let l) = lhs, case .removeByNodenum(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setFavoriteNode, .setFavoriteNode): return {
- guard case .setFavoriteNode(let l) = lhs, case .setFavoriteNode(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.removeFavoriteNode, .removeFavoriteNode): return {
- guard case .removeFavoriteNode(let l) = lhs, case .removeFavoriteNode(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setFixedPosition, .setFixedPosition): return {
- guard case .setFixedPosition(let l) = lhs, case .setFixedPosition(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.removeFixedPosition, .removeFixedPosition): return {
- guard case .removeFixedPosition(let l) = lhs, case .removeFixedPosition(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.setTimeOnly, .setTimeOnly): return {
- guard case .setTimeOnly(let l) = lhs, case .setTimeOnly(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.beginEditSettings, .beginEditSettings): return {
- guard case .beginEditSettings(let l) = lhs, case .beginEditSettings(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.commitEditSettings, .commitEditSettings): return {
- guard case .commitEditSettings(let l) = lhs, case .commitEditSettings(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.factoryResetDevice, .factoryResetDevice): return {
- guard case .factoryResetDevice(let l) = lhs, case .factoryResetDevice(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.rebootOtaSeconds, .rebootOtaSeconds): return {
- guard case .rebootOtaSeconds(let l) = lhs, case .rebootOtaSeconds(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.exitSimulator, .exitSimulator): return {
- guard case .exitSimulator(let l) = lhs, case .exitSimulator(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.rebootSeconds, .rebootSeconds): return {
- guard case .rebootSeconds(let l) = lhs, case .rebootSeconds(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.shutdownSeconds, .shutdownSeconds): return {
- guard case .shutdownSeconds(let l) = lhs, case .shutdownSeconds(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.factoryResetConfig, .factoryResetConfig): return {
- guard case .factoryResetConfig(let l) = lhs, case .factoryResetConfig(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.nodedbReset, .nodedbReset): return {
- guard case .nodedbReset(let l) = lhs, case .nodedbReset(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
///
/// TODO: REPLACE
- public enum ConfigType: SwiftProtobuf.Enum {
+ public enum ConfigType: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -844,6 +662,7 @@ public struct AdminMessage {
///
/// TODO: REPLACE
case securityConfig // = 7
+ case sessionkeyConfig // = 8
case UNRECOGNIZED(Int)
public init() {
@@ -860,6 +679,7 @@ public struct AdminMessage {
case 5: self = .loraConfig
case 6: self = .bluetoothConfig
case 7: self = .securityConfig
+ case 8: self = .sessionkeyConfig
default: self = .UNRECOGNIZED(rawValue)
}
}
@@ -874,15 +694,29 @@ public struct AdminMessage {
case .loraConfig: return 5
case .bluetoothConfig: return 6
case .securityConfig: return 7
+ case .sessionkeyConfig: return 8
case .UNRECOGNIZED(let i): return i
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [AdminMessage.ConfigType] = [
+ .deviceConfig,
+ .positionConfig,
+ .powerConfig,
+ .networkConfig,
+ .displayConfig,
+ .loraConfig,
+ .bluetoothConfig,
+ .securityConfig,
+ .sessionkeyConfig,
+ ]
+
}
///
/// TODO: REPLACE
- public enum ModuleConfigType: SwiftProtobuf.Enum {
+ public enum ModuleConfigType: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -980,51 +814,31 @@ public struct AdminMessage {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [AdminMessage.ModuleConfigType] = [
+ .mqttConfig,
+ .serialConfig,
+ .extnotifConfig,
+ .storeforwardConfig,
+ .rangetestConfig,
+ .telemetryConfig,
+ .cannedmsgConfig,
+ .audioConfig,
+ .remotehardwareConfig,
+ .neighborinfoConfig,
+ .ambientlightingConfig,
+ .detectionsensorConfig,
+ .paxcounterConfig,
+ ]
+
}
public init() {}
}
-#if swift(>=4.2)
-
-extension AdminMessage.ConfigType: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [AdminMessage.ConfigType] = [
- .deviceConfig,
- .positionConfig,
- .powerConfig,
- .networkConfig,
- .displayConfig,
- .loraConfig,
- .bluetoothConfig,
- .securityConfig,
- ]
-}
-
-extension AdminMessage.ModuleConfigType: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [AdminMessage.ModuleConfigType] = [
- .mqttConfig,
- .serialConfig,
- .extnotifConfig,
- .storeforwardConfig,
- .rangetestConfig,
- .telemetryConfig,
- .cannedmsgConfig,
- .audioConfig,
- .remotehardwareConfig,
- .neighborinfoConfig,
- .ambientlightingConfig,
- .detectionsensorConfig,
- .paxcounterConfig,
- ]
-}
-
-#endif // swift(>=4.2)
-
///
/// Parameters for setting up Meshtastic for ameteur radio usage
-public struct HamParameters {
+public struct HamParameters: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1054,7 +868,7 @@ public struct HamParameters {
///
/// Response envelope for node_remote_hardware_pins
-public struct NodeRemoteHardwarePinsResponse {
+public struct NodeRemoteHardwarePinsResponse: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1068,15 +882,6 @@ public struct NodeRemoteHardwarePinsResponse {
public init() {}
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension AdminMessage: @unchecked Sendable {}
-extension AdminMessage.OneOf_PayloadVariant: @unchecked Sendable {}
-extension AdminMessage.ConfigType: @unchecked Sendable {}
-extension AdminMessage.ModuleConfigType: @unchecked Sendable {}
-extension HamParameters: @unchecked Sendable {}
-extension NodeRemoteHardwarePinsResponse: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
@@ -1755,6 +1560,7 @@ extension AdminMessage.ConfigType: SwiftProtobuf._ProtoNameProviding {
5: .same(proto: "LORA_CONFIG"),
6: .same(proto: "BLUETOOTH_CONFIG"),
7: .same(proto: "SECURITY_CONFIG"),
+ 8: .same(proto: "SESSIONKEY_CONFIG"),
]
}
@@ -1807,7 +1613,7 @@ extension HamParameters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementa
if self.txPower != 0 {
try visitor.visitSingularInt32Field(value: self.txPower, fieldNumber: 2)
}
- if self.frequency != 0 {
+ if self.frequency.bitPattern != 0 {
try visitor.visitSingularFloatField(value: self.frequency, fieldNumber: 3)
}
if !self.shortName.isEmpty {
diff --git a/MeshtasticProtobufs/Sources/meshtastic/apponly.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/apponly.pb.swift
index 0457077c..18e66d8e 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/apponly.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/apponly.pb.swift
@@ -26,7 +26,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
/// any SECONDARY channels.
/// No DISABLED channels are included.
/// This abstraction is used only on the the 'app side' of the world (ie python, javascript and android etc) to show a group of Channels as a (long) URL
-public struct ChannelSet {
+public struct ChannelSet: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -53,10 +53,6 @@ public struct ChannelSet {
fileprivate var _loraConfig: Config.LoRaConfig? = nil
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension ChannelSet: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/atak.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/atak.pb.swift
index 4406deb3..1dd12469 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/atak.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/atak.pb.swift
@@ -20,7 +20,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
typealias Version = _2
}
-public enum Team: SwiftProtobuf.Enum {
+public enum Team: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -130,11 +130,6 @@ public enum Team: SwiftProtobuf.Enum {
}
}
-}
-
-#if swift(>=4.2)
-
-extension Team: CaseIterable {
// The compiler won't synthesize support with the UNRECOGNIZED case.
public static let allCases: [Team] = [
.unspecifedColor,
@@ -153,13 +148,12 @@ extension Team: CaseIterable {
.darkGreen,
.brown,
]
-}
-#endif // swift(>=4.2)
+}
///
/// Role of the group member
-public enum MemberRole: SwiftProtobuf.Enum {
+public enum MemberRole: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -233,11 +227,6 @@ public enum MemberRole: SwiftProtobuf.Enum {
}
}
-}
-
-#if swift(>=4.2)
-
-extension MemberRole: CaseIterable {
// The compiler won't synthesize support with the UNRECOGNIZED case.
public static let allCases: [MemberRole] = [
.unspecifed,
@@ -250,13 +239,12 @@ extension MemberRole: CaseIterable {
.rto,
.k9,
]
-}
-#endif // swift(>=4.2)
+}
///
/// Packets for the official ATAK Plugin
-public struct TAKPacket {
+public struct TAKPacket: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -326,7 +314,7 @@ public struct TAKPacket {
///
/// The payload of the packet
- public enum OneOf_PayloadVariant: Equatable {
+ public enum OneOf_PayloadVariant: Equatable, Sendable {
///
/// TAK position report
case pli(PLI)
@@ -334,24 +322,6 @@ public struct TAKPacket {
/// ATAK GeoChat message
case chat(GeoChat)
- #if !swift(>=4.1)
- public static func ==(lhs: TAKPacket.OneOf_PayloadVariant, rhs: TAKPacket.OneOf_PayloadVariant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.pli, .pli): return {
- guard case .pli(let l) = lhs, case .pli(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.chat, .chat): return {
- guard case .chat(let l) = lhs, case .chat(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
public init() {}
@@ -363,7 +333,7 @@ public struct TAKPacket {
///
/// ATAK GeoChat message
-public struct GeoChat {
+public struct GeoChat: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -405,7 +375,7 @@ public struct GeoChat {
///
/// ATAK Group
/// <__group role='Team Member' name='Cyan'/>
-public struct Group {
+public struct Group: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -427,7 +397,7 @@ public struct Group {
///
/// ATAK EUD Status
///
-public struct Status {
+public struct Status: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -444,7 +414,7 @@ public struct Status {
///
/// ATAK Contact
///
-public struct Contact {
+public struct Contact: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -464,7 +434,7 @@ public struct Contact {
///
/// Position Location Information from ATAK
-public struct PLI {
+public struct PLI: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -496,18 +466,6 @@ public struct PLI {
public init() {}
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension Team: @unchecked Sendable {}
-extension MemberRole: @unchecked Sendable {}
-extension TAKPacket: @unchecked Sendable {}
-extension TAKPacket.OneOf_PayloadVariant: @unchecked Sendable {}
-extension GeoChat: @unchecked Sendable {}
-extension Group: @unchecked Sendable {}
-extension Status: @unchecked Sendable {}
-extension Contact: @unchecked Sendable {}
-extension PLI: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/cannedmessages.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/cannedmessages.pb.swift
index 1b8c84de..a43393e1 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/cannedmessages.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/cannedmessages.pb.swift
@@ -22,7 +22,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
///
/// Canned message module configuration.
-public struct CannedMessageModuleConfig {
+public struct CannedMessageModuleConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -36,10 +36,6 @@ public struct CannedMessageModuleConfig {
public init() {}
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension CannedMessageModuleConfig: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/channel.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/channel.pb.swift
index 5b9c7e49..a8c96595 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/channel.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/channel.pb.swift
@@ -36,13 +36,15 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
/// FIXME: Add description of multi-channel support and how primary vs secondary channels are used.
/// FIXME: explain how apps use channels for security.
/// explain how remote settings and remote gpio are managed as an example
-public struct ChannelSettings {
+public struct ChannelSettings: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
///
/// Deprecated in favor of LoraConfig.channel_num
+ ///
+ /// NOTE: This field was marked as deprecated in the .proto file.
public var channelNum: UInt32 = 0
///
@@ -111,7 +113,7 @@ public struct ChannelSettings {
///
/// This message is specifically for modules to store per-channel configuration data.
-public struct ModuleSettings {
+public struct ModuleSettings: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -132,7 +134,7 @@ public struct ModuleSettings {
///
/// A pair of a channel number, mode and the (sharable) settings for that channel
-public struct Channel {
+public struct Channel: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -170,7 +172,7 @@ public struct Channel {
/// cross band routing as needed.
/// If a device has only a single radio (the common case) only one channel can be PRIMARY at a time
/// (but any number of SECONDARY channels can't be sent received on that common frequency)
- public enum Role: SwiftProtobuf.Enum {
+ public enum Role: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -209,6 +211,13 @@ public struct Channel {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Channel.Role] = [
+ .disabled,
+ .primary,
+ .secondary,
+ ]
+
}
public init() {}
@@ -216,26 +225,6 @@ public struct Channel {
fileprivate var _settings: ChannelSettings? = nil
}
-#if swift(>=4.2)
-
-extension Channel.Role: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Channel.Role] = [
- .disabled,
- .primary,
- .secondary,
- ]
-}
-
-#endif // swift(>=4.2)
-
-#if swift(>=5.5) && canImport(_Concurrency)
-extension ChannelSettings: @unchecked Sendable {}
-extension ModuleSettings: @unchecked Sendable {}
-extension Channel: @unchecked Sendable {}
-extension Channel.Role: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/clientonly.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/clientonly.pb.swift
index c3d93bf7..89370cc5 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/clientonly.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/clientonly.pb.swift
@@ -23,7 +23,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
///
/// This abstraction is used to contain any configuration for provisioning a node on any client.
/// It is useful for importing and exporting configurations.
-public struct DeviceProfile {
+public struct DeviceProfile: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -94,10 +94,6 @@ public struct DeviceProfile {
fileprivate var _moduleConfig: LocalModuleConfig? = nil
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension DeviceProfile: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/config.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/config.pb.swift
index 4b953470..2bb116d3 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/config.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/config.pb.swift
@@ -20,7 +20,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
typealias Version = _2
}
-public struct Config {
+public struct Config: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -93,11 +93,19 @@ public struct Config {
set {payloadVariant = .security(newValue)}
}
+ public var sessionkey: Config.SessionkeyConfig {
+ get {
+ if case .sessionkey(let v)? = payloadVariant {return v}
+ return Config.SessionkeyConfig()
+ }
+ set {payloadVariant = .sessionkey(newValue)}
+ }
+
public var unknownFields = SwiftProtobuf.UnknownStorage()
///
/// Payload Variant
- public enum OneOf_PayloadVariant: Equatable {
+ public enum OneOf_PayloadVariant: Equatable, Sendable {
case device(Config.DeviceConfig)
case position(Config.PositionConfig)
case power(Config.PowerConfig)
@@ -106,54 +114,13 @@ public struct Config {
case lora(Config.LoRaConfig)
case bluetooth(Config.BluetoothConfig)
case security(Config.SecurityConfig)
+ case sessionkey(Config.SessionkeyConfig)
- #if !swift(>=4.1)
- public static func ==(lhs: Config.OneOf_PayloadVariant, rhs: Config.OneOf_PayloadVariant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.device, .device): return {
- guard case .device(let l) = lhs, case .device(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.position, .position): return {
- guard case .position(let l) = lhs, case .position(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.power, .power): return {
- guard case .power(let l) = lhs, case .power(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.network, .network): return {
- guard case .network(let l) = lhs, case .network(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.display, .display): return {
- guard case .display(let l) = lhs, case .display(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.lora, .lora): return {
- guard case .lora(let l) = lhs, case .lora(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.bluetooth, .bluetooth): return {
- guard case .bluetooth(let l) = lhs, case .bluetooth(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.security, .security): return {
- guard case .security(let l) = lhs, case .security(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
///
/// Configuration
- public struct DeviceConfig {
+ public struct DeviceConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -165,13 +132,9 @@ public struct Config {
///
/// Disabling this will disable the SerialConsole by not initilizing the StreamAPI
/// Moved to SecurityConfig
- public var serialEnabled: Bool = false
-
///
- /// By default we turn off logging as soon as an API client connects (to keep shared serial link quiet).
- /// Set this to true to leave the debug log outputting even when API is active.
- /// Moved to SecurityConfig
- public var debugLogEnabled: Bool = false
+ /// NOTE: This field was marked as deprecated in the .proto file.
+ public var serialEnabled: Bool = false
///
/// For boards without a hard wired button, this is the pin number that will be used
@@ -200,6 +163,8 @@ public struct Config {
/// If true, device is considered to be "managed" by a mesh administrator
/// Clients should then limit available configuration and administrative options inside the user interface
/// Moved to SecurityConfig
+ ///
+ /// NOTE: This field was marked as deprecated in the .proto file.
public var isManaged: Bool = false
///
@@ -218,7 +183,7 @@ public struct Config {
///
/// Defines the device's role on the Mesh network
- public enum Role: SwiftProtobuf.Enum {
+ public enum Role: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -236,6 +201,8 @@ public struct Config {
/// The wifi radio and the oled screen will be put to sleep.
/// This mode may still potentially have higher power usage due to it's preference in message rebroadcasting on the mesh.
case router // = 2
+
+ /// NOTE: This enum value was marked as deprecated in the .proto file
case routerClient // = 3
///
@@ -326,11 +293,26 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.DeviceConfig.Role] = [
+ .client,
+ .clientMute,
+ .router,
+ .routerClient,
+ .repeater,
+ .tracker,
+ .sensor,
+ .tak,
+ .clientHidden,
+ .lostAndFound,
+ .takTracker,
+ ]
+
}
///
/// Defines the device's behavior for how messages are rebroadcast
- public enum RebroadcastMode: SwiftProtobuf.Enum {
+ public enum RebroadcastMode: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -378,6 +360,14 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.DeviceConfig.RebroadcastMode] = [
+ .all,
+ .allSkipDecoding,
+ .localOnly,
+ .knownOnly,
+ ]
+
}
public init() {}
@@ -385,7 +375,7 @@ public struct Config {
///
/// Position Config
- public struct PositionConfig {
+ public struct PositionConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -407,6 +397,8 @@ public struct Config {
///
/// Is GPS enabled for this node?
+ ///
+ /// NOTE: This field was marked as deprecated in the .proto file.
public var gpsEnabled: Bool = false
///
@@ -417,6 +409,8 @@ public struct Config {
///
/// Deprecated in favor of using smart / regular broadcast intervals as implicit attempt time
+ ///
+ /// NOTE: This field was marked as deprecated in the .proto file.
public var gpsAttemptTime: UInt32 = 0
///
@@ -457,7 +451,7 @@ public struct Config {
/// are always included (also time if GPS-synced)
/// NOTE: the more fields are included, the larger the message will be -
/// leading to longer airtime and a higher risk of packet loss
- public enum PositionFlags: SwiftProtobuf.Enum {
+ public enum PositionFlags: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -547,9 +541,24 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.PositionConfig.PositionFlags] = [
+ .unset,
+ .altitude,
+ .altitudeMsl,
+ .geoidalSeparation,
+ .dop,
+ .hvdop,
+ .satinview,
+ .seqNo,
+ .timestamp,
+ .heading,
+ .speed,
+ ]
+
}
- public enum GpsMode: SwiftProtobuf.Enum {
+ public enum GpsMode: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -587,6 +596,13 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.PositionConfig.GpsMode] = [
+ .disabled,
+ .enabled,
+ .notPresent,
+ ]
+
}
public init() {}
@@ -595,7 +611,7 @@ public struct Config {
///
/// Power Config\
/// See [Power Config](/docs/settings/config/power) for additional power config details.
- public struct PowerConfig {
+ public struct PowerConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -655,7 +671,7 @@ public struct Config {
///
/// Network Config
- public struct NetworkConfig {
+ public struct NetworkConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -702,7 +718,7 @@ public struct Config {
public var unknownFields = SwiftProtobuf.UnknownStorage()
- public enum AddressMode: SwiftProtobuf.Enum {
+ public enum AddressMode: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -734,9 +750,15 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.NetworkConfig.AddressMode] = [
+ .dhcp,
+ .static,
+ ]
+
}
- public struct IpV4Config {
+ public struct IpV4Config: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -769,7 +791,7 @@ public struct Config {
///
/// Display Config
- public struct DisplayConfig {
+ public struct DisplayConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -825,7 +847,7 @@ public struct Config {
///
/// How the GPS coordinates are displayed on the OLED screen.
- public enum GpsCoordinateFormat: SwiftProtobuf.Enum {
+ public enum GpsCoordinateFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -888,11 +910,21 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.DisplayConfig.GpsCoordinateFormat] = [
+ .dec,
+ .dms,
+ .utm,
+ .mgrs,
+ .olc,
+ .osgr,
+ ]
+
}
///
/// Unit display preference
- public enum DisplayUnits: SwiftProtobuf.Enum {
+ public enum DisplayUnits: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -924,11 +956,17 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.DisplayConfig.DisplayUnits] = [
+ .metric,
+ .imperial,
+ ]
+
}
///
/// Override OLED outo detect with this if it fails.
- public enum OledType: SwiftProtobuf.Enum {
+ public enum OledType: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -972,9 +1010,17 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.DisplayConfig.OledType] = [
+ .oledAuto,
+ .oledSsd1306,
+ .oledSh1106,
+ .oledSh1107,
+ ]
+
}
- public enum DisplayMode: SwiftProtobuf.Enum {
+ public enum DisplayMode: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1018,9 +1064,17 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.DisplayConfig.DisplayMode] = [
+ .default,
+ .twocolor,
+ .inverted,
+ .color,
+ ]
+
}
- public enum CompassOrientation: SwiftProtobuf.Enum {
+ public enum CompassOrientation: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1088,6 +1142,18 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.DisplayConfig.CompassOrientation] = [
+ .degrees0,
+ .degrees90,
+ .degrees180,
+ .degrees270,
+ .degrees0Inverted,
+ .degrees90Inverted,
+ .degrees180Inverted,
+ .degrees270Inverted,
+ ]
+
}
public init() {}
@@ -1095,7 +1161,7 @@ public struct Config {
///
/// Lora Config
- public struct LoRaConfig {
+ public struct LoRaConfig: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1250,9 +1316,16 @@ public struct Config {
set {_uniqueStorage()._ignoreMqtt = newValue}
}
+ ///
+ /// Sets the ok_to_mqtt bit on outgoing packets
+ public var configOkToMqtt: Bool {
+ get {return _storage._configOkToMqtt}
+ set {_uniqueStorage()._configOkToMqtt = newValue}
+ }
+
public var unknownFields = SwiftProtobuf.UnknownStorage()
- public enum RegionCode: SwiftProtobuf.Enum {
+ public enum RegionCode: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1386,12 +1459,35 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.LoRaConfig.RegionCode] = [
+ .unset,
+ .us,
+ .eu433,
+ .eu868,
+ .cn,
+ .jp,
+ .anz,
+ .kr,
+ .tw,
+ .ru,
+ .in,
+ .nz865,
+ .th,
+ .lora24,
+ .ua433,
+ .ua868,
+ .my433,
+ .my919,
+ .sg923,
+ ]
+
}
///
/// Standard predefined channel settings
/// Note: these mappings must match ModemPreset Choice in the device code.
- public enum ModemPreset: SwiftProtobuf.Enum {
+ public enum ModemPreset: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1405,6 +1501,8 @@ public struct Config {
///
/// Very Long Range - Slow
/// Deprecated in 2.5: Works only with txco and is unusably slow
+ ///
+ /// NOTE: This enum value was marked as deprecated in the .proto file
case veryLongSlow // = 2
///
@@ -1468,6 +1566,19 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.LoRaConfig.ModemPreset] = [
+ .longFast,
+ .longSlow,
+ .veryLongSlow,
+ .mediumSlow,
+ .mediumFast,
+ .shortSlow,
+ .shortFast,
+ .longModerate,
+ .shortTurbo,
+ ]
+
}
public init() {}
@@ -1475,7 +1586,7 @@ public struct Config {
fileprivate var _storage = _StorageClass.defaultInstance
}
- public struct BluetoothConfig {
+ public struct BluetoothConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1492,14 +1603,9 @@ public struct Config {
/// Specified PIN for PairingMode.FixedPin
public var fixedPin: UInt32 = 0
- ///
- /// Enables device (serial style logs) over Bluetooth
- /// Moved to SecurityConfig
- public var deviceLoggingEnabled: Bool = false
-
public var unknownFields = SwiftProtobuf.UnknownStorage()
- public enum PairingMode: SwiftProtobuf.Enum {
+ public enum PairingMode: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1537,12 +1643,19 @@ public struct Config {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Config.BluetoothConfig.PairingMode] = [
+ .randomPin,
+ .fixedPin,
+ .noPin,
+ ]
+
}
public init() {}
}
- public struct SecurityConfig {
+ public struct SecurityConfig: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1559,7 +1672,7 @@ public struct Config {
///
/// The public key authorized to send admin messages to this node.
- public var adminKey: Data = Data()
+ public var adminKey: [Data] = []
///
/// If true, device is considered to be "managed" by a mesh administrator via admin messages
@@ -1572,13 +1685,9 @@ public struct Config {
///
/// By default we turn off logging as soon as an API client connects (to keep shared serial link quiet).
- /// Output live debug logging over serial.
+ /// Output live debug logging over serial or bluetooth is set to true.
public var debugLogApiEnabled: Bool = false
- ///
- /// Enables device (serial style logs) over Bluetooth
- public var bluetoothLoggingEnabled: Bool = false
-
///
/// Allow incoming device control over the insecure legacy admin channel.
public var adminChannelEnabled: Bool = false
@@ -1588,204 +1697,21 @@ public struct Config {
public init() {}
}
+ ///
+ /// Blank config request, strictly for getting the session key
+ public struct SessionkeyConfig: Sendable {
+ // SwiftProtobuf.Message conformance is added in an extension below. See the
+ // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+ // methods supported on all messages.
+
+ public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+ public init() {}
+ }
+
public init() {}
}
-#if swift(>=4.2)
-
-extension Config.DeviceConfig.Role: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.DeviceConfig.Role] = [
- .client,
- .clientMute,
- .router,
- .routerClient,
- .repeater,
- .tracker,
- .sensor,
- .tak,
- .clientHidden,
- .lostAndFound,
- .takTracker,
- ]
-}
-
-extension Config.DeviceConfig.RebroadcastMode: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.DeviceConfig.RebroadcastMode] = [
- .all,
- .allSkipDecoding,
- .localOnly,
- .knownOnly,
- ]
-}
-
-extension Config.PositionConfig.PositionFlags: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.PositionConfig.PositionFlags] = [
- .unset,
- .altitude,
- .altitudeMsl,
- .geoidalSeparation,
- .dop,
- .hvdop,
- .satinview,
- .seqNo,
- .timestamp,
- .heading,
- .speed,
- ]
-}
-
-extension Config.PositionConfig.GpsMode: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.PositionConfig.GpsMode] = [
- .disabled,
- .enabled,
- .notPresent,
- ]
-}
-
-extension Config.NetworkConfig.AddressMode: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.NetworkConfig.AddressMode] = [
- .dhcp,
- .static,
- ]
-}
-
-extension Config.DisplayConfig.GpsCoordinateFormat: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.DisplayConfig.GpsCoordinateFormat] = [
- .dec,
- .dms,
- .utm,
- .mgrs,
- .olc,
- .osgr,
- ]
-}
-
-extension Config.DisplayConfig.DisplayUnits: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.DisplayConfig.DisplayUnits] = [
- .metric,
- .imperial,
- ]
-}
-
-extension Config.DisplayConfig.OledType: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.DisplayConfig.OledType] = [
- .oledAuto,
- .oledSsd1306,
- .oledSh1106,
- .oledSh1107,
- ]
-}
-
-extension Config.DisplayConfig.DisplayMode: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.DisplayConfig.DisplayMode] = [
- .default,
- .twocolor,
- .inverted,
- .color,
- ]
-}
-
-extension Config.DisplayConfig.CompassOrientation: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.DisplayConfig.CompassOrientation] = [
- .degrees0,
- .degrees90,
- .degrees180,
- .degrees270,
- .degrees0Inverted,
- .degrees90Inverted,
- .degrees180Inverted,
- .degrees270Inverted,
- ]
-}
-
-extension Config.LoRaConfig.RegionCode: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.LoRaConfig.RegionCode] = [
- .unset,
- .us,
- .eu433,
- .eu868,
- .cn,
- .jp,
- .anz,
- .kr,
- .tw,
- .ru,
- .in,
- .nz865,
- .th,
- .lora24,
- .ua433,
- .ua868,
- .my433,
- .my919,
- .sg923,
- ]
-}
-
-extension Config.LoRaConfig.ModemPreset: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.LoRaConfig.ModemPreset] = [
- .longFast,
- .longSlow,
- .veryLongSlow,
- .mediumSlow,
- .mediumFast,
- .shortSlow,
- .shortFast,
- .longModerate,
- .shortTurbo,
- ]
-}
-
-extension Config.BluetoothConfig.PairingMode: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Config.BluetoothConfig.PairingMode] = [
- .randomPin,
- .fixedPin,
- .noPin,
- ]
-}
-
-#endif // swift(>=4.2)
-
-#if swift(>=5.5) && canImport(_Concurrency)
-extension Config: @unchecked Sendable {}
-extension Config.OneOf_PayloadVariant: @unchecked Sendable {}
-extension Config.DeviceConfig: @unchecked Sendable {}
-extension Config.DeviceConfig.Role: @unchecked Sendable {}
-extension Config.DeviceConfig.RebroadcastMode: @unchecked Sendable {}
-extension Config.PositionConfig: @unchecked Sendable {}
-extension Config.PositionConfig.PositionFlags: @unchecked Sendable {}
-extension Config.PositionConfig.GpsMode: @unchecked Sendable {}
-extension Config.PowerConfig: @unchecked Sendable {}
-extension Config.NetworkConfig: @unchecked Sendable {}
-extension Config.NetworkConfig.AddressMode: @unchecked Sendable {}
-extension Config.NetworkConfig.IpV4Config: @unchecked Sendable {}
-extension Config.DisplayConfig: @unchecked Sendable {}
-extension Config.DisplayConfig.GpsCoordinateFormat: @unchecked Sendable {}
-extension Config.DisplayConfig.DisplayUnits: @unchecked Sendable {}
-extension Config.DisplayConfig.OledType: @unchecked Sendable {}
-extension Config.DisplayConfig.DisplayMode: @unchecked Sendable {}
-extension Config.DisplayConfig.CompassOrientation: @unchecked Sendable {}
-extension Config.LoRaConfig: @unchecked Sendable {}
-extension Config.LoRaConfig.RegionCode: @unchecked Sendable {}
-extension Config.LoRaConfig.ModemPreset: @unchecked Sendable {}
-extension Config.BluetoothConfig: @unchecked Sendable {}
-extension Config.BluetoothConfig.PairingMode: @unchecked Sendable {}
-extension Config.SecurityConfig: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
@@ -1801,6 +1727,7 @@ extension Config: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBas
6: .same(proto: "lora"),
7: .same(proto: "bluetooth"),
8: .same(proto: "security"),
+ 9: .same(proto: "sessionkey"),
]
public mutating func decodeMessage(decoder: inout D) throws {
@@ -1913,6 +1840,19 @@ extension Config: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBas
self.payloadVariant = .security(v)
}
}()
+ case 9: try {
+ var v: Config.SessionkeyConfig?
+ var hadOneofValue = false
+ if let current = self.payloadVariant {
+ hadOneofValue = true
+ if case .sessionkey(let m) = current {v = m}
+ }
+ try decoder.decodeSingularMessageField(value: &v)
+ if let v = v {
+ if hadOneofValue {try decoder.handleConflictingOneOf()}
+ self.payloadVariant = .sessionkey(v)
+ }
+ }()
default: break
}
}
@@ -1956,6 +1896,10 @@ extension Config: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBas
guard case .security(let v)? = self.payloadVariant else { preconditionFailure() }
try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
}()
+ case .sessionkey?: try {
+ guard case .sessionkey(let v)? = self.payloadVariant else { preconditionFailure() }
+ try visitor.visitSingularMessageField(value: v, fieldNumber: 9)
+ }()
case nil: break
}
try unknownFields.traverse(visitor: &visitor)
@@ -1973,7 +1917,6 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl
public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
1: .same(proto: "role"),
2: .standard(proto: "serial_enabled"),
- 3: .standard(proto: "debug_log_enabled"),
4: .standard(proto: "button_gpio"),
5: .standard(proto: "buzzer_gpio"),
6: .standard(proto: "rebroadcast_mode"),
@@ -1993,7 +1936,6 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl
switch fieldNumber {
case 1: try { try decoder.decodeSingularEnumField(value: &self.role) }()
case 2: try { try decoder.decodeSingularBoolField(value: &self.serialEnabled) }()
- case 3: try { try decoder.decodeSingularBoolField(value: &self.debugLogEnabled) }()
case 4: try { try decoder.decodeSingularUInt32Field(value: &self.buttonGpio) }()
case 5: try { try decoder.decodeSingularUInt32Field(value: &self.buzzerGpio) }()
case 6: try { try decoder.decodeSingularEnumField(value: &self.rebroadcastMode) }()
@@ -2015,9 +1957,6 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl
if self.serialEnabled != false {
try visitor.visitSingularBoolField(value: self.serialEnabled, fieldNumber: 2)
}
- if self.debugLogEnabled != false {
- try visitor.visitSingularBoolField(value: self.debugLogEnabled, fieldNumber: 3)
- }
if self.buttonGpio != 0 {
try visitor.visitSingularUInt32Field(value: self.buttonGpio, fieldNumber: 4)
}
@@ -2051,7 +1990,6 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl
public static func ==(lhs: Config.DeviceConfig, rhs: Config.DeviceConfig) -> Bool {
if lhs.role != rhs.role {return false}
if lhs.serialEnabled != rhs.serialEnabled {return false}
- if lhs.debugLogEnabled != rhs.debugLogEnabled {return false}
if lhs.buttonGpio != rhs.buttonGpio {return false}
if lhs.buzzerGpio != rhs.buzzerGpio {return false}
if lhs.rebroadcastMode != rhs.rebroadcastMode {return false}
@@ -2260,7 +2198,7 @@ extension Config.PowerConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImple
if self.onBatteryShutdownAfterSecs != 0 {
try visitor.visitSingularUInt32Field(value: self.onBatteryShutdownAfterSecs, fieldNumber: 2)
}
- if self.adcMultiplierOverride != 0 {
+ if self.adcMultiplierOverride.bitPattern != 0 {
try visitor.visitSingularFloatField(value: self.adcMultiplierOverride, fieldNumber: 3)
}
if self.waitBluetoothSecs != 0 {
@@ -2595,6 +2533,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
15: .standard(proto: "pa_fan_disabled"),
103: .standard(proto: "ignore_incoming"),
104: .standard(proto: "ignore_mqtt"),
+ 105: .standard(proto: "config_ok_to_mqtt"),
]
fileprivate class _StorageClass {
@@ -2615,6 +2554,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
var _paFanDisabled: Bool = false
var _ignoreIncoming: [UInt32] = []
var _ignoreMqtt: Bool = false
+ var _configOkToMqtt: Bool = false
#if swift(>=5.10)
// This property is used as the initial default value for new instances of the type.
@@ -2646,6 +2586,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
_paFanDisabled = source._paFanDisabled
_ignoreIncoming = source._ignoreIncoming
_ignoreMqtt = source._ignoreMqtt
+ _configOkToMqtt = source._configOkToMqtt
}
}
@@ -2681,6 +2622,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
case 15: try { try decoder.decodeSingularBoolField(value: &_storage._paFanDisabled) }()
case 103: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._ignoreIncoming) }()
case 104: try { try decoder.decodeSingularBoolField(value: &_storage._ignoreMqtt) }()
+ case 105: try { try decoder.decodeSingularBoolField(value: &_storage._configOkToMqtt) }()
default: break
}
}
@@ -2704,7 +2646,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
if _storage._codingRate != 0 {
try visitor.visitSingularUInt32Field(value: _storage._codingRate, fieldNumber: 5)
}
- if _storage._frequencyOffset != 0 {
+ if _storage._frequencyOffset.bitPattern != 0 {
try visitor.visitSingularFloatField(value: _storage._frequencyOffset, fieldNumber: 6)
}
if _storage._region != .unset {
@@ -2728,7 +2670,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
if _storage._sx126XRxBoostedGain != false {
try visitor.visitSingularBoolField(value: _storage._sx126XRxBoostedGain, fieldNumber: 13)
}
- if _storage._overrideFrequency != 0 {
+ if _storage._overrideFrequency.bitPattern != 0 {
try visitor.visitSingularFloatField(value: _storage._overrideFrequency, fieldNumber: 14)
}
if _storage._paFanDisabled != false {
@@ -2740,6 +2682,9 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
if _storage._ignoreMqtt != false {
try visitor.visitSingularBoolField(value: _storage._ignoreMqtt, fieldNumber: 104)
}
+ if _storage._configOkToMqtt != false {
+ try visitor.visitSingularBoolField(value: _storage._configOkToMqtt, fieldNumber: 105)
+ }
}
try unknownFields.traverse(visitor: &visitor)
}
@@ -2766,6 +2711,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
if _storage._paFanDisabled != rhs_storage._paFanDisabled {return false}
if _storage._ignoreIncoming != rhs_storage._ignoreIncoming {return false}
if _storage._ignoreMqtt != rhs_storage._ignoreMqtt {return false}
+ if _storage._configOkToMqtt != rhs_storage._configOkToMqtt {return false}
return true
}
if !storagesAreEqual {return false}
@@ -2819,7 +2765,6 @@ extension Config.BluetoothConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageI
1: .same(proto: "enabled"),
2: .same(proto: "mode"),
3: .standard(proto: "fixed_pin"),
- 4: .standard(proto: "device_logging_enabled"),
]
public mutating func decodeMessage(decoder: inout D) throws {
@@ -2831,7 +2776,6 @@ extension Config.BluetoothConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageI
case 1: try { try decoder.decodeSingularBoolField(value: &self.enabled) }()
case 2: try { try decoder.decodeSingularEnumField(value: &self.mode) }()
case 3: try { try decoder.decodeSingularUInt32Field(value: &self.fixedPin) }()
- case 4: try { try decoder.decodeSingularBoolField(value: &self.deviceLoggingEnabled) }()
default: break
}
}
@@ -2847,9 +2791,6 @@ extension Config.BluetoothConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageI
if self.fixedPin != 0 {
try visitor.visitSingularUInt32Field(value: self.fixedPin, fieldNumber: 3)
}
- if self.deviceLoggingEnabled != false {
- try visitor.visitSingularBoolField(value: self.deviceLoggingEnabled, fieldNumber: 4)
- }
try unknownFields.traverse(visitor: &visitor)
}
@@ -2857,7 +2798,6 @@ extension Config.BluetoothConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageI
if lhs.enabled != rhs.enabled {return false}
if lhs.mode != rhs.mode {return false}
if lhs.fixedPin != rhs.fixedPin {return false}
- if lhs.deviceLoggingEnabled != rhs.deviceLoggingEnabled {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
@@ -2880,7 +2820,6 @@ extension Config.SecurityConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
4: .standard(proto: "is_managed"),
5: .standard(proto: "serial_enabled"),
6: .standard(proto: "debug_log_api_enabled"),
- 7: .standard(proto: "bluetooth_logging_enabled"),
8: .standard(proto: "admin_channel_enabled"),
]
@@ -2892,11 +2831,10 @@ extension Config.SecurityConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
switch fieldNumber {
case 1: try { try decoder.decodeSingularBytesField(value: &self.publicKey) }()
case 2: try { try decoder.decodeSingularBytesField(value: &self.privateKey) }()
- case 3: try { try decoder.decodeSingularBytesField(value: &self.adminKey) }()
+ case 3: try { try decoder.decodeRepeatedBytesField(value: &self.adminKey) }()
case 4: try { try decoder.decodeSingularBoolField(value: &self.isManaged) }()
case 5: try { try decoder.decodeSingularBoolField(value: &self.serialEnabled) }()
case 6: try { try decoder.decodeSingularBoolField(value: &self.debugLogApiEnabled) }()
- case 7: try { try decoder.decodeSingularBoolField(value: &self.bluetoothLoggingEnabled) }()
case 8: try { try decoder.decodeSingularBoolField(value: &self.adminChannelEnabled) }()
default: break
}
@@ -2911,7 +2849,7 @@ extension Config.SecurityConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
try visitor.visitSingularBytesField(value: self.privateKey, fieldNumber: 2)
}
if !self.adminKey.isEmpty {
- try visitor.visitSingularBytesField(value: self.adminKey, fieldNumber: 3)
+ try visitor.visitRepeatedBytesField(value: self.adminKey, fieldNumber: 3)
}
if self.isManaged != false {
try visitor.visitSingularBoolField(value: self.isManaged, fieldNumber: 4)
@@ -2922,9 +2860,6 @@ extension Config.SecurityConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
if self.debugLogApiEnabled != false {
try visitor.visitSingularBoolField(value: self.debugLogApiEnabled, fieldNumber: 6)
}
- if self.bluetoothLoggingEnabled != false {
- try visitor.visitSingularBoolField(value: self.bluetoothLoggingEnabled, fieldNumber: 7)
- }
if self.adminChannelEnabled != false {
try visitor.visitSingularBoolField(value: self.adminChannelEnabled, fieldNumber: 8)
}
@@ -2938,9 +2873,27 @@ extension Config.SecurityConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
if lhs.isManaged != rhs.isManaged {return false}
if lhs.serialEnabled != rhs.serialEnabled {return false}
if lhs.debugLogApiEnabled != rhs.debugLogApiEnabled {return false}
- if lhs.bluetoothLoggingEnabled != rhs.bluetoothLoggingEnabled {return false}
if lhs.adminChannelEnabled != rhs.adminChannelEnabled {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
}
+
+extension Config.SessionkeyConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+ public static let protoMessageName: String = Config.protoMessageName + ".SessionkeyConfig"
+ public static let _protobuf_nameMap = SwiftProtobuf._NameMap()
+
+ public mutating func decodeMessage(decoder: inout D) throws {
+ // Load everything into unknown fields
+ while try decoder.nextFieldNumber() != nil {}
+ }
+
+ public func traverse(visitor: inout V) throws {
+ try unknownFields.traverse(visitor: &visitor)
+ }
+
+ public static func ==(lhs: Config.SessionkeyConfig, rhs: Config.SessionkeyConfig) -> Bool {
+ if lhs.unknownFields != rhs.unknownFields {return false}
+ return true
+ }
+}
diff --git a/MeshtasticProtobufs/Sources/meshtastic/connection_status.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/connection_status.pb.swift
index a2ec180e..a4569714 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/connection_status.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/connection_status.pb.swift
@@ -20,7 +20,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
typealias Version = _2
}
-public struct DeviceConnectionStatus {
+public struct DeviceConnectionStatus: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -81,7 +81,7 @@ public struct DeviceConnectionStatus {
///
/// WiFi connection status
-public struct WifiConnectionStatus {
+public struct WifiConnectionStatus: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -114,7 +114,7 @@ public struct WifiConnectionStatus {
///
/// Ethernet connection status
-public struct EthernetConnectionStatus {
+public struct EthernetConnectionStatus: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -139,7 +139,7 @@ public struct EthernetConnectionStatus {
///
/// Ethernet or WiFi connection status
-public struct NetworkConnectionStatus {
+public struct NetworkConnectionStatus: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -167,7 +167,7 @@ public struct NetworkConnectionStatus {
///
/// Bluetooth connection status
-public struct BluetoothConnectionStatus {
+public struct BluetoothConnectionStatus: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -191,7 +191,7 @@ public struct BluetoothConnectionStatus {
///
/// Serial connection status
-public struct SerialConnectionStatus {
+public struct SerialConnectionStatus: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -209,15 +209,6 @@ public struct SerialConnectionStatus {
public init() {}
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension DeviceConnectionStatus: @unchecked Sendable {}
-extension WifiConnectionStatus: @unchecked Sendable {}
-extension EthernetConnectionStatus: @unchecked Sendable {}
-extension NetworkConnectionStatus: @unchecked Sendable {}
-extension BluetoothConnectionStatus: @unchecked Sendable {}
-extension SerialConnectionStatus: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/deviceonly.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/deviceonly.pb.swift
index 43506399..076e639e 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/deviceonly.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/deviceonly.pb.swift
@@ -22,7 +22,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
///
/// Font sizes for the device screen
-public enum ScreenFonts: SwiftProtobuf.Enum {
+public enum ScreenFonts: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -60,24 +60,18 @@ public enum ScreenFonts: SwiftProtobuf.Enum {
}
}
-}
-
-#if swift(>=4.2)
-
-extension ScreenFonts: CaseIterable {
// The compiler won't synthesize support with the UNRECOGNIZED case.
public static let allCases: [ScreenFonts] = [
.fontSmall,
.fontMedium,
.fontLarge,
]
-}
-#endif // swift(>=4.2)
+}
///
/// Position with static location information only for NodeDBLite
-public struct PositionLite {
+public struct PositionLite: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -112,13 +106,15 @@ public struct PositionLite {
public init() {}
}
-public struct UserLite {
+public struct UserLite: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
///
/// This is the addr of the radio.
+ ///
+ /// NOTE: This field was marked as deprecated in the .proto file.
public var macaddr: Data = Data()
///
@@ -157,7 +153,7 @@ public struct UserLite {
public init() {}
}
-public struct NodeInfoLite {
+public struct NodeInfoLite: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -260,7 +256,7 @@ public struct NodeInfoLite {
/// FIXME, since we write this each time we enter deep sleep (and have infinite
/// flash) it would be better to use some sort of append only data structure for
/// the receive queue and use the preferences store for the other stuff
-public struct DeviceState {
+public struct DeviceState: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -320,6 +316,8 @@ public struct DeviceState {
/// Used only during development.
/// Indicates developer is testing and changes should never be saved to flash.
/// Deprecated in 2.3.1
+ ///
+ /// NOTE: This field was marked as deprecated in the .proto file.
public var noSave: Bool {
get {return _storage._noSave}
set {_uniqueStorage()._noSave = newValue}
@@ -368,7 +366,7 @@ public struct DeviceState {
///
/// The on-disk saved channels
-public struct ChannelFile {
+public struct ChannelFile: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -391,7 +389,7 @@ public struct ChannelFile {
///
/// This can be used for customizing the firmware distribution. If populated,
/// show a secondary bootup screen with custom logo and text for 2.5 seconds.
-public struct OEMStore {
+public struct OEMStore: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -450,16 +448,6 @@ public struct OEMStore {
fileprivate var _oemLocalModuleConfig: LocalModuleConfig? = nil
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension ScreenFonts: @unchecked Sendable {}
-extension PositionLite: @unchecked Sendable {}
-extension UserLite: @unchecked Sendable {}
-extension NodeInfoLite: @unchecked Sendable {}
-extension DeviceState: @unchecked Sendable {}
-extension ChannelFile: @unchecked Sendable {}
-extension OEMStore: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
@@ -695,7 +683,7 @@ extension NodeInfoLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat
try { if let v = _storage._position {
try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
} }()
- if _storage._snr != 0 {
+ if _storage._snr.bitPattern != 0 {
try visitor.visitSingularFloatField(value: _storage._snr, fieldNumber: 4)
}
if _storage._lastHeard != 0 {
diff --git a/MeshtasticProtobufs/Sources/meshtastic/localonly.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/localonly.pb.swift
index 0af27466..f2ef681d 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/localonly.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/localonly.pb.swift
@@ -20,7 +20,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
typealias Version = _2
}
-public struct LocalConfig {
+public struct LocalConfig: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -129,7 +129,7 @@ public struct LocalConfig {
fileprivate var _storage = _StorageClass.defaultInstance
}
-public struct LocalModuleConfig {
+public struct LocalModuleConfig: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -293,11 +293,6 @@ public struct LocalModuleConfig {
fileprivate var _storage = _StorageClass.defaultInstance
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension LocalConfig: @unchecked Sendable {}
-extension LocalModuleConfig: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/mesh.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/mesh.pb.swift
index ba12908d..a4dfa4cb 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/mesh.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/mesh.pb.swift
@@ -25,7 +25,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
/// bin/build-all.sh script.
/// Because they will be used to find firmware filenames in the android app for OTA updates.
/// To match the old style filenames, _ is converted to -, p is converted to .
-public enum HardwareModel: SwiftProtobuf.Enum {
+public enum HardwareModel: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -346,6 +346,19 @@ public enum HardwareModel: SwiftProtobuf.Enum {
/// Minewsemi ME25LS01 (ME25LE01_V1.0). NRF52840 w/ LR1110 radio, buttons and leds and pins.
case me25Ls014Y10Td // = 75
+ ///
+ /// RP2040_FEATHER_RFM95
+ /// Adafruit Feather RP2040 with RFM95 LoRa Radio RFM95 with SX1272, SSD1306 OLED
+ /// https://www.adafruit.com/product/5714
+ /// https://www.adafruit.com/product/326
+ /// https://www.adafruit.com/product/938
+ /// ^^^ short A0 to switch to I2C address 0x3C
+ case rp2040FeatherRfm95 // = 76
+
+ /// M5 esp32 based MCU modules with enclosure, TFT and LORA Shields. All Variants (Basic, Core, Fire, Core2, Paper) https://m5stack.com/
+ case m5StackCorebasic // = 77
+ case m5StackCore2 // = 78
+
///
/// ------------------------------------------------------------------------------------------------------------------------------------------
/// Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
@@ -434,6 +447,9 @@ public enum HardwareModel: SwiftProtobuf.Enum {
case 73: self = .wioE5
case 74: self = .radiomaster900Bandit
case 75: self = .me25Ls014Y10Td
+ case 76: self = .rp2040FeatherRfm95
+ case 77: self = .m5StackCorebasic
+ case 78: self = .m5StackCore2
case 255: self = .privateHw
default: self = .UNRECOGNIZED(rawValue)
}
@@ -516,16 +532,14 @@ public enum HardwareModel: SwiftProtobuf.Enum {
case .wioE5: return 73
case .radiomaster900Bandit: return 74
case .me25Ls014Y10Td: return 75
+ case .rp2040FeatherRfm95: return 76
+ case .m5StackCorebasic: return 77
+ case .m5StackCore2: return 78
case .privateHw: return 255
case .UNRECOGNIZED(let i): return i
}
}
-}
-
-#if swift(>=4.2)
-
-extension HardwareModel: CaseIterable {
// The compiler won't synthesize support with the UNRECOGNIZED case.
public static let allCases: [HardwareModel] = [
.unset,
@@ -603,15 +617,17 @@ extension HardwareModel: CaseIterable {
.wioE5,
.radiomaster900Bandit,
.me25Ls014Y10Td,
+ .rp2040FeatherRfm95,
+ .m5StackCorebasic,
+ .m5StackCore2,
.privateHw,
]
-}
-#endif // swift(>=4.2)
+}
///
/// Shared constants between device and phone
-public enum Constants: SwiftProtobuf.Enum {
+public enum Constants: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -646,26 +662,20 @@ public enum Constants: SwiftProtobuf.Enum {
}
}
-}
-
-#if swift(>=4.2)
-
-extension Constants: CaseIterable {
// The compiler won't synthesize support with the UNRECOGNIZED case.
public static let allCases: [Constants] = [
.zero,
.dataPayloadLen,
]
-}
-#endif // swift(>=4.2)
+}
///
/// Error codes for critical errors
/// The device might report these fault codes on the screen.
/// If you encounter a fault code, please post on the meshtastic.discourse.group
/// and we'll try to help.
-public enum CriticalErrorCode: SwiftProtobuf.Enum {
+public enum CriticalErrorCode: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -774,11 +784,6 @@ public enum CriticalErrorCode: SwiftProtobuf.Enum {
}
}
-}
-
-#if swift(>=4.2)
-
-extension CriticalErrorCode: CaseIterable {
// The compiler won't synthesize support with the UNRECOGNIZED case.
public static let allCases: [CriticalErrorCode] = [
.none,
@@ -796,13 +801,12 @@ extension CriticalErrorCode: CaseIterable {
.flashCorruptionRecoverable,
.flashCorruptionUnrecoverable,
]
-}
-#endif // swift(>=4.2)
+}
///
/// a gps position
-public struct Position {
+public struct Position: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1019,7 +1023,7 @@ public struct Position {
///
/// How the location was acquired: manual, onboard GPS, external (EUD) GPS
- public enum LocSource: SwiftProtobuf.Enum {
+ public enum LocSource: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1063,12 +1067,20 @@ public struct Position {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Position.LocSource] = [
+ .locUnset,
+ .locManual,
+ .locInternal,
+ .locExternal,
+ ]
+
}
///
/// How the altitude was acquired: manual, GPS int/ext, etc
/// Default: same as location_source if present
- public enum AltSource: SwiftProtobuf.Enum {
+ public enum AltSource: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1118,6 +1130,15 @@ public struct Position {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Position.AltSource] = [
+ .altUnset,
+ .altManual,
+ .altInternal,
+ .altExternal,
+ .altBarometric,
+ ]
+
}
public init() {}
@@ -1125,31 +1146,6 @@ public struct Position {
fileprivate var _storage = _StorageClass.defaultInstance
}
-#if swift(>=4.2)
-
-extension Position.LocSource: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Position.LocSource] = [
- .locUnset,
- .locManual,
- .locInternal,
- .locExternal,
- ]
-}
-
-extension Position.AltSource: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Position.AltSource] = [
- .altUnset,
- .altManual,
- .altInternal,
- .altExternal,
- .altBarometric,
- ]
-}
-
-#endif // swift(>=4.2)
-
///
/// Broadcast when a newly powered mesh node wants to find a node num it can use
/// Sent from the phone over bluetooth to set the user id for the owner of this node.
@@ -1171,7 +1167,7 @@ extension Position.AltSource: CaseIterable {
/// A few nodenums are reserved and will never be requested:
/// 0xff - broadcast
/// 0 through 3 - for future use
-public struct User {
+public struct User: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1196,6 +1192,8 @@ public struct User {
/// Deprecated in Meshtastic 2.1.x
/// This is the addr of the radio.
/// Not populated by the phone, but added by the esp32 when broadcasting
+ ///
+ /// NOTE: This field was marked as deprecated in the .proto file.
public var macaddr: Data = Data()
///
@@ -1227,7 +1225,7 @@ public struct User {
///
/// A message used in a traceroute
-public struct RouteDiscovery {
+public struct RouteDiscovery: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1255,7 +1253,7 @@ public struct RouteDiscovery {
///
/// A Routing control Data packet handled by the routing module
-public struct Routing {
+public struct Routing: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1295,7 +1293,7 @@ public struct Routing {
public var unknownFields = SwiftProtobuf.UnknownStorage()
- public enum OneOf_Variant: Equatable {
+ public enum OneOf_Variant: Equatable, Sendable {
///
/// A route request going from the requester
case routeRequest(RouteDiscovery)
@@ -1307,34 +1305,12 @@ public struct Routing {
/// in addition to ack.fail_id to provide details on the type of failure).
case errorReason(Routing.Error)
- #if !swift(>=4.1)
- public static func ==(lhs: Routing.OneOf_Variant, rhs: Routing.OneOf_Variant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.routeRequest, .routeRequest): return {
- guard case .routeRequest(let l) = lhs, case .routeRequest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.routeReply, .routeReply): return {
- guard case .routeReply(let l) = lhs, case .routeReply(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.errorReason, .errorReason): return {
- guard case .errorReason(let l) = lhs, case .errorReason(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
///
/// A failure in delivering a message (usually used for routing control messages, but might be provided in addition to ack.fail_id to provide
/// details on the type of failure).
- public enum Error: SwiftProtobuf.Enum {
+ public enum Error: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1440,40 +1416,34 @@ public struct Routing {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [Routing.Error] = [
+ .none,
+ .noRoute,
+ .gotNak,
+ .timeout,
+ .noInterface,
+ .maxRetransmit,
+ .noChannel,
+ .tooLarge,
+ .noResponse,
+ .dutyCycleLimit,
+ .badRequest,
+ .notAuthorized,
+ .pkiFailed,
+ .pkiUnknownPubkey,
+ ]
+
}
public init() {}
}
-#if swift(>=4.2)
-
-extension Routing.Error: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [Routing.Error] = [
- .none,
- .noRoute,
- .gotNak,
- .timeout,
- .noInterface,
- .maxRetransmit,
- .noChannel,
- .tooLarge,
- .noResponse,
- .dutyCycleLimit,
- .badRequest,
- .notAuthorized,
- .pkiFailed,
- .pkiUnknownPubkey,
- ]
-}
-
-#endif // swift(>=4.2)
-
///
/// (Formerly called SubPacket)
/// The payload portion fo a packet, this is the actual bytes that are sent
/// inside a radio packet (because from/to are broken out by the comms library)
-public struct DataMessage {
+public struct DataMessage: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1520,14 +1490,27 @@ public struct DataMessage {
/// a message a heart or poop emoji.
public var emoji: UInt32 = 0
+ ///
+ /// Bitfield for extra flags. First use is to indicate that user approves the packet being uploaded to MQTT.
+ public var bitfield: UInt32 {
+ get {return _bitfield ?? 0}
+ set {_bitfield = newValue}
+ }
+ /// Returns true if `bitfield` has been explicitly set.
+ public var hasBitfield: Bool {return self._bitfield != nil}
+ /// Clears the value of `bitfield`. Subsequent reads from it will return its default value.
+ public mutating func clearBitfield() {self._bitfield = nil}
+
public var unknownFields = SwiftProtobuf.UnknownStorage()
public init() {}
+
+ fileprivate var _bitfield: UInt32? = nil
}
///
/// Waypoint message, used to share arbitrary locations across the mesh
-public struct Waypoint {
+public struct Waypoint: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1589,7 +1572,7 @@ public struct Waypoint {
///
/// This message will be proxied over the PhoneAPI for the client to deliver to the MQTT server
-public struct MqttClientProxyMessage {
+public struct MqttClientProxyMessage: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1630,7 +1613,7 @@ public struct MqttClientProxyMessage {
///
/// The actual service envelope payload or text for mqtt pub / sub
- public enum OneOf_PayloadVariant: Equatable {
+ public enum OneOf_PayloadVariant: Equatable, @unchecked Sendable {
///
/// Bytes
case data(Data)
@@ -1638,24 +1621,6 @@ public struct MqttClientProxyMessage {
/// Text
case text(String)
- #if !swift(>=4.1)
- public static func ==(lhs: MqttClientProxyMessage.OneOf_PayloadVariant, rhs: MqttClientProxyMessage.OneOf_PayloadVariant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.data, .data): return {
- guard case .data(let l) = lhs, case .data(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.text, .text): return {
- guard case .text(let l) = lhs, case .text(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
public init() {}
@@ -1665,7 +1630,7 @@ public struct MqttClientProxyMessage {
/// A packet envelope sent/received over the mesh
/// only payload_variant is sent in the payload portion of the LORA packet.
/// The other fields are either not sent at all, or sent in the special 16 byte LORA header.
-public struct MeshPacket {
+public struct MeshPacket: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1799,6 +1764,8 @@ public struct MeshPacket {
///
/// Describe if this message is delayed
+ ///
+ /// NOTE: This field was marked as deprecated in the .proto file.
public var delayed: MeshPacket.Delayed {
get {return _storage._delayed}
set {_uniqueStorage()._delayed = newValue}
@@ -1835,7 +1802,7 @@ public struct MeshPacket {
public var unknownFields = SwiftProtobuf.UnknownStorage()
- public enum OneOf_PayloadVariant: Equatable {
+ public enum OneOf_PayloadVariant: Equatable, @unchecked Sendable {
///
/// TODO: REPLACE
case decoded(DataMessage)
@@ -1843,24 +1810,6 @@ public struct MeshPacket {
/// TODO: REPLACE
case encrypted(Data)
- #if !swift(>=4.1)
- public static func ==(lhs: MeshPacket.OneOf_PayloadVariant, rhs: MeshPacket.OneOf_PayloadVariant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.decoded, .decoded): return {
- guard case .decoded(let l) = lhs, case .decoded(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.encrypted, .encrypted): return {
- guard case .encrypted(let l) = lhs, case .encrypted(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
///
@@ -1882,7 +1831,7 @@ public struct MeshPacket {
/// So I bit the bullet and implemented a new (internal - not sent over the air)
/// field in MeshPacket called 'priority'.
/// And the transmission queue in the router object is now a priority queue.
- public enum Priority: SwiftProtobuf.Enum {
+ public enum Priority: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1907,6 +1856,15 @@ public struct MeshPacket {
/// assume it is important and use a slightly higher priority
case reliable // = 70
+ ///
+ /// If priority is unset but the packet is a response to a request, we want it to get there relatively quickly.
+ /// Furthermore, responses stop relaying packets directed to a node early.
+ case response // = 80
+
+ ///
+ /// Higher priority for specific message types (portnums) to distinguish between other reliable packets.
+ case high // = 100
+
///
/// Ack/naks are sent with very high priority to ensure that retransmission
/// stops as soon as possible
@@ -1928,6 +1886,8 @@ public struct MeshPacket {
case 10: self = .background
case 64: self = .default
case 70: self = .reliable
+ case 80: self = .response
+ case 100: self = .high
case 120: self = .ack
case 127: self = .max
default: self = .UNRECOGNIZED(rawValue)
@@ -1941,17 +1901,32 @@ public struct MeshPacket {
case .background: return 10
case .default: return 64
case .reliable: return 70
+ case .response: return 80
+ case .high: return 100
case .ack: return 120
case .max: return 127
case .UNRECOGNIZED(let i): return i
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [MeshPacket.Priority] = [
+ .unset,
+ .min,
+ .background,
+ .default,
+ .reliable,
+ .response,
+ .high,
+ .ack,
+ .max,
+ ]
+
}
///
/// Identify if this is a delayed packet
- public enum Delayed: SwiftProtobuf.Enum {
+ public enum Delayed: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1989,6 +1964,13 @@ public struct MeshPacket {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [MeshPacket.Delayed] = [
+ .noDelay,
+ .broadcast,
+ .direct,
+ ]
+
}
public init() {}
@@ -1996,32 +1978,6 @@ public struct MeshPacket {
fileprivate var _storage = _StorageClass.defaultInstance
}
-#if swift(>=4.2)
-
-extension MeshPacket.Priority: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [MeshPacket.Priority] = [
- .unset,
- .min,
- .background,
- .default,
- .reliable,
- .ack,
- .max,
- ]
-}
-
-extension MeshPacket.Delayed: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [MeshPacket.Delayed] = [
- .noDelay,
- .broadcast,
- .direct,
- ]
-}
-
-#endif // swift(>=4.2)
-
///
/// The bluetooth to device link:
/// Old BTLE protocol docs from TODO, merge in above and make real docs...
@@ -2039,7 +1995,7 @@ extension MeshPacket.Delayed: CaseIterable {
/// level etc) SET_CONFIG (switches device to a new set of radio params and
/// preshared key, drops all existing nodes, force our node to rejoin this new group)
/// Full information about a node on the mesh
-public struct NodeInfo {
+public struct NodeInfo: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2140,7 +2096,7 @@ public struct NodeInfo {
/// Unique local debugging info for this node
/// Note: we don't include position or the user info, because that will come in the
/// Sent to the phone in response to WantNodes.
-public struct MyNodeInfo {
+public struct MyNodeInfo: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2171,7 +2127,7 @@ public struct MyNodeInfo {
/// on the message it is assumed to be a continuation of the previously sent message.
/// This allows the device code to use fixed maxlen 64 byte strings for messages,
/// and then extend as needed by emitting multiple records.
-public struct LogRecord {
+public struct LogRecord: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2196,7 +2152,7 @@ public struct LogRecord {
///
/// Log levels, chosen to match python logging conventions.
- public enum Level: SwiftProtobuf.Enum {
+ public enum Level: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -2258,29 +2214,23 @@ public struct LogRecord {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [LogRecord.Level] = [
+ .unset,
+ .critical,
+ .error,
+ .warning,
+ .info,
+ .debug,
+ .trace,
+ ]
+
}
public init() {}
}
-#if swift(>=4.2)
-
-extension LogRecord.Level: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [LogRecord.Level] = [
- .unset,
- .critical,
- .error,
- .warning,
- .info,
- .debug,
- .trace,
- ]
-}
-
-#endif // swift(>=4.2)
-
-public struct QueueStatus {
+public struct QueueStatus: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2307,7 +2257,7 @@ public struct QueueStatus {
/// It will support READ and NOTIFY. When a new packet arrives the device will BLE notify?
/// It will sit in that descriptor until consumed by the phone,
/// at which point the next item in the FIFO will be populated.
-public struct FromRadio {
+public struct FromRadio: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2483,7 +2433,7 @@ public struct FromRadio {
///
/// Log levels, chosen to match python logging conventions.
- public enum OneOf_PayloadVariant: Equatable {
+ public enum OneOf_PayloadVariant: Equatable, Sendable {
///
/// Log levels, chosen to match python logging conventions.
case packet(MeshPacket)
@@ -2538,76 +2488,6 @@ public struct FromRadio {
/// Notification message to the client
case clientNotification(ClientNotification)
- #if !swift(>=4.1)
- public static func ==(lhs: FromRadio.OneOf_PayloadVariant, rhs: FromRadio.OneOf_PayloadVariant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.packet, .packet): return {
- guard case .packet(let l) = lhs, case .packet(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.myInfo, .myInfo): return {
- guard case .myInfo(let l) = lhs, case .myInfo(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.nodeInfo, .nodeInfo): return {
- guard case .nodeInfo(let l) = lhs, case .nodeInfo(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.config, .config): return {
- guard case .config(let l) = lhs, case .config(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.logRecord, .logRecord): return {
- guard case .logRecord(let l) = lhs, case .logRecord(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.configCompleteID, .configCompleteID): return {
- guard case .configCompleteID(let l) = lhs, case .configCompleteID(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.rebooted, .rebooted): return {
- guard case .rebooted(let l) = lhs, case .rebooted(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.moduleConfig, .moduleConfig): return {
- guard case .moduleConfig(let l) = lhs, case .moduleConfig(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.channel, .channel): return {
- guard case .channel(let l) = lhs, case .channel(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.queueStatus, .queueStatus): return {
- guard case .queueStatus(let l) = lhs, case .queueStatus(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.xmodemPacket, .xmodemPacket): return {
- guard case .xmodemPacket(let l) = lhs, case .xmodemPacket(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.metadata, .metadata): return {
- guard case .metadata(let l) = lhs, case .metadata(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.mqttClientProxyMessage, .mqttClientProxyMessage): return {
- guard case .mqttClientProxyMessage(let l) = lhs, case .mqttClientProxyMessage(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.fileInfo, .fileInfo): return {
- guard case .fileInfo(let l) = lhs, case .fileInfo(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.clientNotification, .clientNotification): return {
- guard case .clientNotification(let l) = lhs, case .clientNotification(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
public init() {}
@@ -2618,7 +2498,7 @@ public struct FromRadio {
/// To be used for important messages that should to be displayed to the user
/// in the form of push notifications or validation messages when saving
/// invalid configuration.
-public struct ClientNotification {
+public struct ClientNotification: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2655,7 +2535,7 @@ public struct ClientNotification {
///
/// Individual File info for the device
-public struct FileInfo {
+public struct FileInfo: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2676,7 +2556,7 @@ public struct FileInfo {
///
/// Packets/commands to the radio will be written (reliably) to the toRadio characteristic.
/// Once the write completes the phone can assume it is handled.
-public struct ToRadio {
+public struct ToRadio: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2756,7 +2636,7 @@ public struct ToRadio {
///
/// Log levels, chosen to match python logging conventions.
- public enum OneOf_PayloadVariant: Equatable {
+ public enum OneOf_PayloadVariant: Equatable, Sendable {
///
/// Send this packet on the mesh
case packet(MeshPacket)
@@ -2783,40 +2663,6 @@ public struct ToRadio {
/// Heartbeat message (used to keep the device connection awake on serial)
case heartbeat(Heartbeat)
- #if !swift(>=4.1)
- public static func ==(lhs: ToRadio.OneOf_PayloadVariant, rhs: ToRadio.OneOf_PayloadVariant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.packet, .packet): return {
- guard case .packet(let l) = lhs, case .packet(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.wantConfigID, .wantConfigID): return {
- guard case .wantConfigID(let l) = lhs, case .wantConfigID(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.disconnect, .disconnect): return {
- guard case .disconnect(let l) = lhs, case .disconnect(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.xmodemPacket, .xmodemPacket): return {
- guard case .xmodemPacket(let l) = lhs, case .xmodemPacket(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.mqttClientProxyMessage, .mqttClientProxyMessage): return {
- guard case .mqttClientProxyMessage(let l) = lhs, case .mqttClientProxyMessage(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.heartbeat, .heartbeat): return {
- guard case .heartbeat(let l) = lhs, case .heartbeat(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
public init() {}
@@ -2824,7 +2670,7 @@ public struct ToRadio {
///
/// Compressed message payload
-public struct Compressed {
+public struct Compressed: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2844,7 +2690,7 @@ public struct Compressed {
///
/// Full info on edges for a single node
-public struct NeighborInfo {
+public struct NeighborInfo: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2872,7 +2718,7 @@ public struct NeighborInfo {
///
/// A single edge in the mesh
-public struct Neighbor {
+public struct Neighbor: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2902,7 +2748,7 @@ public struct Neighbor {
///
/// Device metadata response
-public struct DeviceMetadata {
+public struct DeviceMetadata: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2955,7 +2801,7 @@ public struct DeviceMetadata {
///
/// A heartbeat message is sent to the node from the client to keep the connection alive.
/// This is currently only needed to keep serial connections alive, but can be used by any PhoneAPI.
-public struct Heartbeat {
+public struct Heartbeat: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2967,7 +2813,7 @@ public struct Heartbeat {
///
/// RemoteHardwarePins associated with a node
-public struct NodeRemoteHardwarePin {
+public struct NodeRemoteHardwarePin: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -2994,7 +2840,7 @@ public struct NodeRemoteHardwarePin {
fileprivate var _pin: RemoteHardwarePin? = nil
}
-public struct ChunkedPayload {
+public struct ChunkedPayload: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -3022,7 +2868,7 @@ public struct ChunkedPayload {
///
/// Wrapper message for broken repeated oneof support
-public struct resend_chunks {
+public struct resend_chunks: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -3036,7 +2882,7 @@ public struct resend_chunks {
///
/// Responses to a ChunkedPayload request
-public struct ChunkedPayloadResponse {
+public struct ChunkedPayloadResponse: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -3079,7 +2925,7 @@ public struct ChunkedPayloadResponse {
public var unknownFields = SwiftProtobuf.UnknownStorage()
- public enum OneOf_PayloadVariant: Equatable {
+ public enum OneOf_PayloadVariant: Equatable, Sendable {
///
/// Request to transfer chunked payload
case requestTransfer(Bool)
@@ -3090,76 +2936,11 @@ public struct ChunkedPayloadResponse {
/// Request missing indexes in the chunked payload
case resendChunks(resend_chunks)
- #if !swift(>=4.1)
- public static func ==(lhs: ChunkedPayloadResponse.OneOf_PayloadVariant, rhs: ChunkedPayloadResponse.OneOf_PayloadVariant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.requestTransfer, .requestTransfer): return {
- guard case .requestTransfer(let l) = lhs, case .requestTransfer(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.acceptTransfer, .acceptTransfer): return {
- guard case .acceptTransfer(let l) = lhs, case .acceptTransfer(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.resendChunks, .resendChunks): return {
- guard case .resendChunks(let l) = lhs, case .resendChunks(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
public init() {}
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension HardwareModel: @unchecked Sendable {}
-extension Constants: @unchecked Sendable {}
-extension CriticalErrorCode: @unchecked Sendable {}
-extension Position: @unchecked Sendable {}
-extension Position.LocSource: @unchecked Sendable {}
-extension Position.AltSource: @unchecked Sendable {}
-extension User: @unchecked Sendable {}
-extension RouteDiscovery: @unchecked Sendable {}
-extension Routing: @unchecked Sendable {}
-extension Routing.OneOf_Variant: @unchecked Sendable {}
-extension Routing.Error: @unchecked Sendable {}
-extension DataMessage: @unchecked Sendable {}
-extension Waypoint: @unchecked Sendable {}
-extension MqttClientProxyMessage: @unchecked Sendable {}
-extension MqttClientProxyMessage.OneOf_PayloadVariant: @unchecked Sendable {}
-extension MeshPacket: @unchecked Sendable {}
-extension MeshPacket.OneOf_PayloadVariant: @unchecked Sendable {}
-extension MeshPacket.Priority: @unchecked Sendable {}
-extension MeshPacket.Delayed: @unchecked Sendable {}
-extension NodeInfo: @unchecked Sendable {}
-extension MyNodeInfo: @unchecked Sendable {}
-extension LogRecord: @unchecked Sendable {}
-extension LogRecord.Level: @unchecked Sendable {}
-extension QueueStatus: @unchecked Sendable {}
-extension FromRadio: @unchecked Sendable {}
-extension FromRadio.OneOf_PayloadVariant: @unchecked Sendable {}
-extension ClientNotification: @unchecked Sendable {}
-extension FileInfo: @unchecked Sendable {}
-extension ToRadio: @unchecked Sendable {}
-extension ToRadio.OneOf_PayloadVariant: @unchecked Sendable {}
-extension Compressed: @unchecked Sendable {}
-extension NeighborInfo: @unchecked Sendable {}
-extension Neighbor: @unchecked Sendable {}
-extension DeviceMetadata: @unchecked Sendable {}
-extension Heartbeat: @unchecked Sendable {}
-extension NodeRemoteHardwarePin: @unchecked Sendable {}
-extension ChunkedPayload: @unchecked Sendable {}
-extension resend_chunks: @unchecked Sendable {}
-extension ChunkedPayloadResponse: @unchecked Sendable {}
-extension ChunkedPayloadResponse.OneOf_PayloadVariant: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
@@ -3241,6 +3022,9 @@ extension HardwareModel: SwiftProtobuf._ProtoNameProviding {
73: .same(proto: "WIO_E5"),
74: .same(proto: "RADIOMASTER_900_BANDIT"),
75: .same(proto: "ME25LS01_4Y10TD"),
+ 76: .same(proto: "RP2040_FEATHER_RFM95"),
+ 77: .same(proto: "M5STACK_COREBASIC"),
+ 78: .same(proto: "M5STACK_CORE2"),
255: .same(proto: "PRIVATE_HW"),
]
}
@@ -3779,6 +3563,7 @@ extension DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
6: .standard(proto: "request_id"),
7: .standard(proto: "reply_id"),
8: .same(proto: "emoji"),
+ 9: .same(proto: "bitfield"),
]
public mutating func decodeMessage(decoder: inout D) throws {
@@ -3795,12 +3580,17 @@ extension DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
case 6: try { try decoder.decodeSingularFixed32Field(value: &self.requestID) }()
case 7: try { try decoder.decodeSingularFixed32Field(value: &self.replyID) }()
case 8: try { try decoder.decodeSingularFixed32Field(value: &self.emoji) }()
+ case 9: try { try decoder.decodeSingularUInt32Field(value: &self._bitfield) }()
default: break
}
}
}
public func traverse(visitor: inout V) throws {
+ // The use of inline closures is to circumvent an issue where the compiler
+ // allocates stack space for every if/case branch local when no optimizations
+ // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+ // https://github.com/apple/swift-protobuf/issues/1182
if self.portnum != .unknownApp {
try visitor.visitSingularEnumField(value: self.portnum, fieldNumber: 1)
}
@@ -3825,6 +3615,9 @@ extension DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
if self.emoji != 0 {
try visitor.visitSingularFixed32Field(value: self.emoji, fieldNumber: 8)
}
+ try { if let v = self._bitfield {
+ try visitor.visitSingularUInt32Field(value: v, fieldNumber: 9)
+ } }()
try unknownFields.traverse(visitor: &visitor)
}
@@ -3837,6 +3630,7 @@ extension DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
if lhs.requestID != rhs.requestID {return false}
if lhs.replyID != rhs.replyID {return false}
if lhs.emoji != rhs.emoji {return false}
+ if lhs._bitfield != rhs._bitfield {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
@@ -4153,7 +3947,7 @@ extension MeshPacket: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio
if _storage._rxTime != 0 {
try visitor.visitSingularFixed32Field(value: _storage._rxTime, fieldNumber: 7)
}
- if _storage._rxSnr != 0 {
+ if _storage._rxSnr.bitPattern != 0 {
try visitor.visitSingularFloatField(value: _storage._rxSnr, fieldNumber: 8)
}
if _storage._hopLimit != 0 {
@@ -4224,6 +4018,8 @@ extension MeshPacket.Priority: SwiftProtobuf._ProtoNameProviding {
10: .same(proto: "BACKGROUND"),
64: .same(proto: "DEFAULT"),
70: .same(proto: "RELIABLE"),
+ 80: .same(proto: "RESPONSE"),
+ 100: .same(proto: "HIGH"),
120: .same(proto: "ACK"),
127: .same(proto: "MAX"),
]
@@ -4336,7 +4132,7 @@ extension NodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB
try { if let v = _storage._position {
try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
} }()
- if _storage._snr != 0 {
+ if _storage._snr.bitPattern != 0 {
try visitor.visitSingularFloatField(value: _storage._snr, fieldNumber: 4)
}
if _storage._lastHeard != 0 {
@@ -5181,7 +4977,7 @@ extension Neighbor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB
if self.nodeID != 0 {
try visitor.visitSingularUInt32Field(value: self.nodeID, fieldNumber: 1)
}
- if self.snr != 0 {
+ if self.snr.bitPattern != 0 {
try visitor.visitSingularFloatField(value: self.snr, fieldNumber: 2)
}
if self.lastRxTime != 0 {
@@ -5294,8 +5090,8 @@ extension Heartbeat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation
public static let _protobuf_nameMap = SwiftProtobuf._NameMap()
public mutating func decodeMessage(decoder: inout D) throws {
- while let _ = try decoder.nextFieldNumber() {
- }
+ // Load everything into unknown fields
+ while try decoder.nextFieldNumber() != nil {}
}
public func traverse(visitor: inout V) throws {
diff --git a/MeshtasticProtobufs/Sources/meshtastic/module_config.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/module_config.pb.swift
index 3186c349..d1de21cf 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/module_config.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/module_config.pb.swift
@@ -20,7 +20,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
typealias Version = _2
}
-public enum RemoteHardwarePinType: SwiftProtobuf.Enum {
+public enum RemoteHardwarePinType: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -58,24 +58,18 @@ public enum RemoteHardwarePinType: SwiftProtobuf.Enum {
}
}
-}
-
-#if swift(>=4.2)
-
-extension RemoteHardwarePinType: CaseIterable {
// The compiler won't synthesize support with the UNRECOGNIZED case.
public static let allCases: [RemoteHardwarePinType] = [
.unknown,
.digitalRead,
.digitalWrite,
]
-}
-#endif // swift(>=4.2)
+}
///
/// Module Config
-public struct ModuleConfig {
+public struct ModuleConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -218,7 +212,7 @@ public struct ModuleConfig {
///
/// TODO: REPLACE
- public enum OneOf_PayloadVariant: Equatable {
+ public enum OneOf_PayloadVariant: Equatable, Sendable {
///
/// TODO: REPLACE
case mqtt(ModuleConfig.MQTTConfig)
@@ -259,73 +253,11 @@ public struct ModuleConfig {
/// TODO: REPLACE
case paxcounter(ModuleConfig.PaxcounterConfig)
- #if !swift(>=4.1)
- public static func ==(lhs: ModuleConfig.OneOf_PayloadVariant, rhs: ModuleConfig.OneOf_PayloadVariant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.mqtt, .mqtt): return {
- guard case .mqtt(let l) = lhs, case .mqtt(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.serial, .serial): return {
- guard case .serial(let l) = lhs, case .serial(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.externalNotification, .externalNotification): return {
- guard case .externalNotification(let l) = lhs, case .externalNotification(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.storeForward, .storeForward): return {
- guard case .storeForward(let l) = lhs, case .storeForward(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.rangeTest, .rangeTest): return {
- guard case .rangeTest(let l) = lhs, case .rangeTest(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.telemetry, .telemetry): return {
- guard case .telemetry(let l) = lhs, case .telemetry(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.cannedMessage, .cannedMessage): return {
- guard case .cannedMessage(let l) = lhs, case .cannedMessage(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.audio, .audio): return {
- guard case .audio(let l) = lhs, case .audio(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.remoteHardware, .remoteHardware): return {
- guard case .remoteHardware(let l) = lhs, case .remoteHardware(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.neighborInfo, .neighborInfo): return {
- guard case .neighborInfo(let l) = lhs, case .neighborInfo(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.ambientLighting, .ambientLighting): return {
- guard case .ambientLighting(let l) = lhs, case .ambientLighting(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.detectionSensor, .detectionSensor): return {
- guard case .detectionSensor(let l) = lhs, case .detectionSensor(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.paxcounter, .paxcounter): return {
- guard case .paxcounter(let l) = lhs, case .paxcounter(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
///
/// MQTT Client Config
- public struct MQTTConfig {
+ public struct MQTTConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -400,7 +332,7 @@ public struct ModuleConfig {
///
/// Settings for reporting unencrypted information about our node to a map via MQTT
- public struct MapReportSettings {
+ public struct MapReportSettings: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -420,7 +352,7 @@ public struct ModuleConfig {
///
/// RemoteHardwareModule Config
- public struct RemoteHardwareConfig {
+ public struct RemoteHardwareConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -444,7 +376,7 @@ public struct ModuleConfig {
///
/// NeighborInfoModule Config
- public struct NeighborInfoConfig {
+ public struct NeighborInfoConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -465,7 +397,7 @@ public struct ModuleConfig {
///
/// Detection Sensor Module Config
- public struct DetectionSensorConfig {
+ public struct DetectionSensorConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -516,7 +448,7 @@ public struct ModuleConfig {
///
/// Audio Config for codec2 voice
- public struct AudioConfig {
+ public struct AudioConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -553,7 +485,7 @@ public struct ModuleConfig {
///
/// Baudrate for codec2 voice
- public enum Audio_Baud: SwiftProtobuf.Enum {
+ public enum Audio_Baud: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
case codec2Default // = 0
case codec23200 // = 1
@@ -600,6 +532,19 @@ public struct ModuleConfig {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [ModuleConfig.AudioConfig.Audio_Baud] = [
+ .codec2Default,
+ .codec23200,
+ .codec22400,
+ .codec21600,
+ .codec21400,
+ .codec21300,
+ .codec21200,
+ .codec2700,
+ .codec2700B,
+ ]
+
}
public init() {}
@@ -607,7 +552,7 @@ public struct ModuleConfig {
///
/// Config for the Paxcounter Module
- public struct PaxcounterConfig {
+ public struct PaxcounterConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -633,7 +578,7 @@ public struct ModuleConfig {
///
/// Serial Config
- public struct SerialConfig {
+ public struct SerialConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -676,7 +621,7 @@ public struct ModuleConfig {
///
/// TODO: REPLACE
- public enum Serial_Baud: SwiftProtobuf.Enum {
+ public enum Serial_Baud: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
case baudDefault // = 0
case baud110 // = 1
@@ -744,11 +689,31 @@ public struct ModuleConfig {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [ModuleConfig.SerialConfig.Serial_Baud] = [
+ .baudDefault,
+ .baud110,
+ .baud300,
+ .baud600,
+ .baud1200,
+ .baud2400,
+ .baud4800,
+ .baud9600,
+ .baud19200,
+ .baud38400,
+ .baud57600,
+ .baud115200,
+ .baud230400,
+ .baud460800,
+ .baud576000,
+ .baud921600,
+ ]
+
}
///
/// TODO: REPLACE
- public enum Serial_Mode: SwiftProtobuf.Enum {
+ public enum Serial_Mode: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
case `default` // = 0
case simple // = 1
@@ -793,6 +758,17 @@ public struct ModuleConfig {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [ModuleConfig.SerialConfig.Serial_Mode] = [
+ .default,
+ .simple,
+ .proto,
+ .textmsg,
+ .nmea,
+ .caltopo,
+ .ws85,
+ ]
+
}
public init() {}
@@ -800,7 +776,7 @@ public struct ModuleConfig {
///
/// External Notifications Config
- public struct ExternalNotificationConfig {
+ public struct ExternalNotificationConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -883,7 +859,7 @@ public struct ModuleConfig {
///
/// Store and Forward Module Config
- public struct StoreForwardConfig {
+ public struct StoreForwardConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -919,7 +895,7 @@ public struct ModuleConfig {
///
/// Preferences for the RangeTestModule
- public struct RangeTestConfig {
+ public struct RangeTestConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -944,7 +920,7 @@ public struct ModuleConfig {
///
/// Configuration for both device and environment metrics
- public struct TelemetryConfig {
+ public struct TelemetryConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1001,7 +977,7 @@ public struct ModuleConfig {
///
/// TODO: REPLACE
- public struct CannedMessageConfig {
+ public struct CannedMessageConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1056,7 +1032,7 @@ public struct ModuleConfig {
///
/// TODO: REPLACE
- public enum InputEventChar: SwiftProtobuf.Enum {
+ public enum InputEventChar: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -1124,6 +1100,18 @@ public struct ModuleConfig {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [ModuleConfig.CannedMessageConfig.InputEventChar] = [
+ .none,
+ .up,
+ .down,
+ .left,
+ .right,
+ .select,
+ .back,
+ .cancel,
+ ]
+
}
public init() {}
@@ -1132,7 +1120,7 @@ public struct ModuleConfig {
///
///Ambient Lighting Module - Settings for control of onboard LEDs to allow users to adjust the brightness levels and respective color levels.
///Initially created for the RAK14001 RGB LED module.
- public struct AmbientLightingConfig {
+ public struct AmbientLightingConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1165,77 +1153,9 @@ public struct ModuleConfig {
public init() {}
}
-#if swift(>=4.2)
-
-extension ModuleConfig.AudioConfig.Audio_Baud: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [ModuleConfig.AudioConfig.Audio_Baud] = [
- .codec2Default,
- .codec23200,
- .codec22400,
- .codec21600,
- .codec21400,
- .codec21300,
- .codec21200,
- .codec2700,
- .codec2700B,
- ]
-}
-
-extension ModuleConfig.SerialConfig.Serial_Baud: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [ModuleConfig.SerialConfig.Serial_Baud] = [
- .baudDefault,
- .baud110,
- .baud300,
- .baud600,
- .baud1200,
- .baud2400,
- .baud4800,
- .baud9600,
- .baud19200,
- .baud38400,
- .baud57600,
- .baud115200,
- .baud230400,
- .baud460800,
- .baud576000,
- .baud921600,
- ]
-}
-
-extension ModuleConfig.SerialConfig.Serial_Mode: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [ModuleConfig.SerialConfig.Serial_Mode] = [
- .default,
- .simple,
- .proto,
- .textmsg,
- .nmea,
- .caltopo,
- .ws85,
- ]
-}
-
-extension ModuleConfig.CannedMessageConfig.InputEventChar: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [ModuleConfig.CannedMessageConfig.InputEventChar] = [
- .none,
- .up,
- .down,
- .left,
- .right,
- .select,
- .back,
- .cancel,
- ]
-}
-
-#endif // swift(>=4.2)
-
///
/// A GPIO pin definition for remote hardware module
-public struct RemoteHardwarePin {
+public struct RemoteHardwarePin: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -1257,31 +1177,6 @@ public struct RemoteHardwarePin {
public init() {}
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension RemoteHardwarePinType: @unchecked Sendable {}
-extension ModuleConfig: @unchecked Sendable {}
-extension ModuleConfig.OneOf_PayloadVariant: @unchecked Sendable {}
-extension ModuleConfig.MQTTConfig: @unchecked Sendable {}
-extension ModuleConfig.MapReportSettings: @unchecked Sendable {}
-extension ModuleConfig.RemoteHardwareConfig: @unchecked Sendable {}
-extension ModuleConfig.NeighborInfoConfig: @unchecked Sendable {}
-extension ModuleConfig.DetectionSensorConfig: @unchecked Sendable {}
-extension ModuleConfig.AudioConfig: @unchecked Sendable {}
-extension ModuleConfig.AudioConfig.Audio_Baud: @unchecked Sendable {}
-extension ModuleConfig.PaxcounterConfig: @unchecked Sendable {}
-extension ModuleConfig.SerialConfig: @unchecked Sendable {}
-extension ModuleConfig.SerialConfig.Serial_Baud: @unchecked Sendable {}
-extension ModuleConfig.SerialConfig.Serial_Mode: @unchecked Sendable {}
-extension ModuleConfig.ExternalNotificationConfig: @unchecked Sendable {}
-extension ModuleConfig.StoreForwardConfig: @unchecked Sendable {}
-extension ModuleConfig.RangeTestConfig: @unchecked Sendable {}
-extension ModuleConfig.TelemetryConfig: @unchecked Sendable {}
-extension ModuleConfig.CannedMessageConfig: @unchecked Sendable {}
-extension ModuleConfig.CannedMessageConfig.InputEventChar: @unchecked Sendable {}
-extension ModuleConfig.AmbientLightingConfig: @unchecked Sendable {}
-extension RemoteHardwarePin: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/mqtt.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/mqtt.pb.swift
index efe6cdd5..fc5e37a1 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/mqtt.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/mqtt.pb.swift
@@ -22,7 +22,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
///
/// This message wraps a MeshPacket with extra metadata about the sender and how it arrived.
-public struct ServiceEnvelope {
+public struct ServiceEnvelope: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -57,7 +57,7 @@ public struct ServiceEnvelope {
///
/// Information about a node intended to be reported unencrypted to a map using MQTT.
-public struct MapReport {
+public struct MapReport: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -121,11 +121,6 @@ public struct MapReport {
public init() {}
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension ServiceEnvelope: @unchecked Sendable {}
-extension MapReport: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/paxcount.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/paxcount.pb.swift
index cf8aa463..f82b3c51 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/paxcount.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/paxcount.pb.swift
@@ -22,7 +22,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
///
/// TODO: REPLACE
-public struct Paxcount {
+public struct Paxcount: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -44,10 +44,6 @@ public struct Paxcount {
public init() {}
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension Paxcount: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/portnums.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/portnums.pb.swift
index dd7e036f..46455db7 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/portnums.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/portnums.pb.swift
@@ -33,7 +33,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
/// Note: This was formerly a Type enum named 'typ' with the same id #
/// We have change to this 'portnum' based scheme for specifying app handlers for particular payloads.
/// This change is backwards compatible by treating the legacy OPAQUE/CLEAR_TEXT values identically.
-public enum PortNum: SwiftProtobuf.Enum {
+public enum PortNum: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -277,11 +277,6 @@ public enum PortNum: SwiftProtobuf.Enum {
}
}
-}
-
-#if swift(>=4.2)
-
-extension PortNum: CaseIterable {
// The compiler won't synthesize support with the UNRECOGNIZED case.
public static let allCases: [PortNum] = [
.unknownApp,
@@ -313,14 +308,9 @@ extension PortNum: CaseIterable {
.atakForwarder,
.max,
]
+
}
-#endif // swift(>=4.2)
-
-#if swift(>=5.5) && canImport(_Concurrency)
-extension PortNum: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
extension PortNum: SwiftProtobuf._ProtoNameProviding {
diff --git a/MeshtasticProtobufs/Sources/meshtastic/powermon.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/powermon.pb.swift
index 5f51e948..9c61e6d0 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/powermon.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/powermon.pb.swift
@@ -22,7 +22,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
/// Note: There are no 'PowerMon' messages normally in use (PowerMons are sent only as structured logs - slogs).
///But we wrap our State enum in this message to effectively nest a namespace (without our linter yelling at us)
-public struct PowerMon {
+public struct PowerMon: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -31,7 +31,7 @@ public struct PowerMon {
/// Any significant power changing event in meshtastic should be tagged with a powermon state transition.
///If you are making new meshtastic features feel free to add new entries at the end of this definition.
- public enum State: SwiftProtobuf.Enum {
+ public enum State: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
case none // = 0
case cpuDeepSleep // = 1
@@ -104,37 +104,31 @@ public struct PowerMon {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [PowerMon.State] = [
+ .none,
+ .cpuDeepSleep,
+ .cpuLightSleep,
+ .vext1On,
+ .loraRxon,
+ .loraTxon,
+ .loraRxactive,
+ .btOn,
+ .ledOn,
+ .screenOn,
+ .screenDrawing,
+ .wifiOn,
+ .gpsActive,
+ ]
+
}
public init() {}
}
-#if swift(>=4.2)
-
-extension PowerMon.State: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [PowerMon.State] = [
- .none,
- .cpuDeepSleep,
- .cpuLightSleep,
- .vext1On,
- .loraRxon,
- .loraTxon,
- .loraRxactive,
- .btOn,
- .ledOn,
- .screenOn,
- .screenDrawing,
- .wifiOn,
- .gpsActive,
- ]
-}
-
-#endif // swift(>=4.2)
-
///
/// PowerStress testing support via the C++ PowerStress module
-public struct PowerStressMessage {
+public struct PowerStressMessage: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -151,7 +145,7 @@ public struct PowerStressMessage {
/// What operation would we like the UUT to perform.
///note: senders should probably set want_response in their request packets, so that they can know when the state
///machine has started processing their request
- public enum Opcode: SwiftProtobuf.Enum {
+ public enum Opcode: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -272,48 +266,35 @@ public struct PowerStressMessage {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [PowerStressMessage.Opcode] = [
+ .unset,
+ .printInfo,
+ .forceQuiet,
+ .endQuiet,
+ .screenOn,
+ .screenOff,
+ .cpuIdle,
+ .cpuDeepsleep,
+ .cpuFullon,
+ .ledOn,
+ .ledOff,
+ .loraOff,
+ .loraTx,
+ .loraRx,
+ .btOff,
+ .btOn,
+ .wifiOff,
+ .wifiOn,
+ .gpsOff,
+ .gpsOn,
+ ]
+
}
public init() {}
}
-#if swift(>=4.2)
-
-extension PowerStressMessage.Opcode: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [PowerStressMessage.Opcode] = [
- .unset,
- .printInfo,
- .forceQuiet,
- .endQuiet,
- .screenOn,
- .screenOff,
- .cpuIdle,
- .cpuDeepsleep,
- .cpuFullon,
- .ledOn,
- .ledOff,
- .loraOff,
- .loraTx,
- .loraRx,
- .btOff,
- .btOn,
- .wifiOff,
- .wifiOn,
- .gpsOff,
- .gpsOn,
- ]
-}
-
-#endif // swift(>=4.2)
-
-#if swift(>=5.5) && canImport(_Concurrency)
-extension PowerMon: @unchecked Sendable {}
-extension PowerMon.State: @unchecked Sendable {}
-extension PowerStressMessage: @unchecked Sendable {}
-extension PowerStressMessage.Opcode: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
@@ -323,8 +304,8 @@ extension PowerMon: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationB
public static let _protobuf_nameMap = SwiftProtobuf._NameMap()
public mutating func decodeMessage(decoder: inout D) throws {
- while let _ = try decoder.nextFieldNumber() {
- }
+ // Load everything into unknown fields
+ while try decoder.nextFieldNumber() != nil {}
}
public func traverse(visitor: inout V) throws {
@@ -379,7 +360,7 @@ extension PowerStressMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImple
if self.cmd != .unset {
try visitor.visitSingularEnumField(value: self.cmd, fieldNumber: 1)
}
- if self.numSeconds != 0 {
+ if self.numSeconds.bitPattern != 0 {
try visitor.visitSingularFloatField(value: self.numSeconds, fieldNumber: 2)
}
try unknownFields.traverse(visitor: &visitor)
diff --git a/MeshtasticProtobufs/Sources/meshtastic/remote_hardware.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/remote_hardware.pb.swift
index ac6eeb26..60f64504 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/remote_hardware.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/remote_hardware.pb.swift
@@ -30,7 +30,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
/// because no security yet (beyond the channel mechanism).
/// It should be off by default and then protected based on some TBD mechanism
/// (a special channel once multichannel support is included?)
-public struct HardwareMessage {
+public struct HardwareMessage: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -52,7 +52,7 @@ public struct HardwareMessage {
///
/// TODO: REPLACE
- public enum TypeEnum: SwiftProtobuf.Enum {
+ public enum TypeEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -110,32 +110,21 @@ public struct HardwareMessage {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [HardwareMessage.TypeEnum] = [
+ .unset,
+ .writeGpios,
+ .watchGpios,
+ .gpiosChanged,
+ .readGpios,
+ .readGpiosReply,
+ ]
+
}
public init() {}
}
-#if swift(>=4.2)
-
-extension HardwareMessage.TypeEnum: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [HardwareMessage.TypeEnum] = [
- .unset,
- .writeGpios,
- .watchGpios,
- .gpiosChanged,
- .readGpios,
- .readGpiosReply,
- ]
-}
-
-#endif // swift(>=4.2)
-
-#if swift(>=5.5) && canImport(_Concurrency)
-extension HardwareMessage: @unchecked Sendable {}
-extension HardwareMessage.TypeEnum: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/rtttl.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/rtttl.pb.swift
index 6fdf3208..c1f3f678 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/rtttl.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/rtttl.pb.swift
@@ -22,7 +22,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
///
/// Canned message module configuration.
-public struct RTTTLConfig {
+public struct RTTTLConfig: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -36,10 +36,6 @@ public struct RTTTLConfig {
public init() {}
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension RTTTLConfig: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/storeforward.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/storeforward.pb.swift
index 54efa77b..0b67eaf6 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/storeforward.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/storeforward.pb.swift
@@ -22,7 +22,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
///
/// TODO: REPLACE
-public struct StoreAndForward {
+public struct StoreAndForward: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -79,7 +79,7 @@ public struct StoreAndForward {
///
/// TODO: REPLACE
- public enum OneOf_Variant: Equatable {
+ public enum OneOf_Variant: Equatable, @unchecked Sendable {
///
/// TODO: REPLACE
case stats(StoreAndForward.Statistics)
@@ -93,38 +93,12 @@ public struct StoreAndForward {
/// Text from history message.
case text(Data)
- #if !swift(>=4.1)
- public static func ==(lhs: StoreAndForward.OneOf_Variant, rhs: StoreAndForward.OneOf_Variant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.stats, .stats): return {
- guard case .stats(let l) = lhs, case .stats(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.history, .history): return {
- guard case .history(let l) = lhs, case .history(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.heartbeat, .heartbeat): return {
- guard case .heartbeat(let l) = lhs, case .heartbeat(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.text, .text): return {
- guard case .text(let l) = lhs, case .text(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
///
/// 001 - 063 = From Router
/// 064 - 127 = From Client
- public enum RequestResponse: SwiftProtobuf.Enum {
+ public enum RequestResponse: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -242,11 +216,31 @@ public struct StoreAndForward {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [StoreAndForward.RequestResponse] = [
+ .unset,
+ .routerError,
+ .routerHeartbeat,
+ .routerPing,
+ .routerPong,
+ .routerBusy,
+ .routerHistory,
+ .routerStats,
+ .routerTextDirect,
+ .routerTextBroadcast,
+ .clientError,
+ .clientHistory,
+ .clientStats,
+ .clientPing,
+ .clientPong,
+ .clientAbort,
+ ]
+
}
///
/// TODO: REPLACE
- public struct Statistics {
+ public struct Statistics: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -294,7 +288,7 @@ public struct StoreAndForward {
///
/// TODO: REPLACE
- public struct History {
+ public struct History: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -319,7 +313,7 @@ public struct StoreAndForward {
///
/// TODO: REPLACE
- public struct Heartbeat {
+ public struct Heartbeat: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -340,41 +334,6 @@ public struct StoreAndForward {
public init() {}
}
-#if swift(>=4.2)
-
-extension StoreAndForward.RequestResponse: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [StoreAndForward.RequestResponse] = [
- .unset,
- .routerError,
- .routerHeartbeat,
- .routerPing,
- .routerPong,
- .routerBusy,
- .routerHistory,
- .routerStats,
- .routerTextDirect,
- .routerTextBroadcast,
- .clientError,
- .clientHistory,
- .clientStats,
- .clientPing,
- .clientPong,
- .clientAbort,
- ]
-}
-
-#endif // swift(>=4.2)
-
-#if swift(>=5.5) && canImport(_Concurrency)
-extension StoreAndForward: @unchecked Sendable {}
-extension StoreAndForward.OneOf_Variant: @unchecked Sendable {}
-extension StoreAndForward.RequestResponse: @unchecked Sendable {}
-extension StoreAndForward.Statistics: @unchecked Sendable {}
-extension StoreAndForward.History: @unchecked Sendable {}
-extension StoreAndForward.Heartbeat: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/MeshtasticProtobufs/Sources/meshtastic/telemetry.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/telemetry.pb.swift
index e4b9ee08..44183031 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/telemetry.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/telemetry.pb.swift
@@ -22,7 +22,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
///
/// Supported I2C Sensors for telemetry in Meshtastic
-public enum TelemetrySensorType: SwiftProtobuf.Enum {
+public enum TelemetrySensorType: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
///
@@ -140,6 +140,10 @@ public enum TelemetrySensorType: SwiftProtobuf.Enum {
///
/// MAX17048 1S lipo battery sensor (voltage, state of charge, time to go)
case max17048 // = 28
+
+ ///
+ /// Custom I2C sensor implementation based on https://github.com/meshtastic/i2c-sensor
+ case customSensor // = 29
case UNRECOGNIZED(Int)
public init() {
@@ -177,6 +181,7 @@ public enum TelemetrySensorType: SwiftProtobuf.Enum {
case 26: self = .bmp3Xx
case 27: self = .icm20948
case 28: self = .max17048
+ case 29: self = .customSensor
default: self = .UNRECOGNIZED(rawValue)
}
}
@@ -212,15 +217,11 @@ public enum TelemetrySensorType: SwiftProtobuf.Enum {
case .bmp3Xx: return 26
case .icm20948: return 27
case .max17048: return 28
+ case .customSensor: return 29
case .UNRECOGNIZED(let i): return i
}
}
-}
-
-#if swift(>=4.2)
-
-extension TelemetrySensorType: CaseIterable {
// The compiler won't synthesize support with the UNRECOGNIZED case.
public static let allCases: [TelemetrySensorType] = [
.sensorUnset,
@@ -252,14 +253,14 @@ extension TelemetrySensorType: CaseIterable {
.bmp3Xx,
.icm20948,
.max17048,
+ .customSensor,
]
-}
-#endif // swift(>=4.2)
+}
///
/// Key native device metrics such as battery level
-public struct DeviceMetrics {
+public struct DeviceMetrics: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -332,7 +333,7 @@ public struct DeviceMetrics {
///
/// Weather station or other environmental metrics
-public struct EnvironmentMetrics {
+public struct EnvironmentMetrics: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -535,7 +536,7 @@ public struct EnvironmentMetrics {
///
/// Power Metrics (voltage / current / etc)
-public struct PowerMetrics {
+public struct PowerMetrics: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -620,7 +621,7 @@ public struct PowerMetrics {
///
/// Air quality metrics
-public struct AirQualityMetrics {
+public struct AirQualityMetrics: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -777,7 +778,7 @@ public struct AirQualityMetrics {
///
/// Local device mesh statistics
-public struct LocalStats {
+public struct LocalStats: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -821,7 +822,7 @@ public struct LocalStats {
///
/// Types of Measurements the telemetry module is equipped to handle
-public struct Telemetry {
+public struct Telemetry: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -884,7 +885,7 @@ public struct Telemetry {
public var unknownFields = SwiftProtobuf.UnknownStorage()
- public enum OneOf_Variant: Equatable {
+ public enum OneOf_Variant: Equatable, Sendable {
///
/// Key native device metrics such as battery level
case deviceMetrics(DeviceMetrics)
@@ -901,36 +902,6 @@ public struct Telemetry {
/// Local device mesh statistics
case localStats(LocalStats)
- #if !swift(>=4.1)
- public static func ==(lhs: Telemetry.OneOf_Variant, rhs: Telemetry.OneOf_Variant) -> Bool {
- // The use of inline closures is to circumvent an issue where the compiler
- // allocates stack space for every case branch when no optimizations are
- // enabled. https://github.com/apple/swift-protobuf/issues/1034
- switch (lhs, rhs) {
- case (.deviceMetrics, .deviceMetrics): return {
- guard case .deviceMetrics(let l) = lhs, case .deviceMetrics(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.environmentMetrics, .environmentMetrics): return {
- guard case .environmentMetrics(let l) = lhs, case .environmentMetrics(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.airQualityMetrics, .airQualityMetrics): return {
- guard case .airQualityMetrics(let l) = lhs, case .airQualityMetrics(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.powerMetrics, .powerMetrics): return {
- guard case .powerMetrics(let l) = lhs, case .powerMetrics(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- case (.localStats, .localStats): return {
- guard case .localStats(let l) = lhs, case .localStats(let r) = rhs else { preconditionFailure() }
- return l == r
- }()
- default: return false
- }
- }
- #endif
}
public init() {}
@@ -938,7 +909,7 @@ public struct Telemetry {
///
/// NAU7802 Telemetry configuration, for saving to flash
-public struct Nau7802Config {
+public struct Nau7802Config: Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -956,18 +927,6 @@ public struct Nau7802Config {
public init() {}
}
-#if swift(>=5.5) && canImport(_Concurrency)
-extension TelemetrySensorType: @unchecked Sendable {}
-extension DeviceMetrics: @unchecked Sendable {}
-extension EnvironmentMetrics: @unchecked Sendable {}
-extension PowerMetrics: @unchecked Sendable {}
-extension AirQualityMetrics: @unchecked Sendable {}
-extension LocalStats: @unchecked Sendable {}
-extension Telemetry: @unchecked Sendable {}
-extension Telemetry.OneOf_Variant: @unchecked Sendable {}
-extension Nau7802Config: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
@@ -1003,6 +962,7 @@ extension TelemetrySensorType: SwiftProtobuf._ProtoNameProviding {
26: .same(proto: "BMP3XX"),
27: .same(proto: "ICM20948"),
28: .same(proto: "MAX17048"),
+ 29: .same(proto: "CUSTOM_SENSOR"),
]
}
@@ -1474,10 +1434,10 @@ extension LocalStats: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementatio
if self.uptimeSeconds != 0 {
try visitor.visitSingularUInt32Field(value: self.uptimeSeconds, fieldNumber: 1)
}
- if self.channelUtilization != 0 {
+ if self.channelUtilization.bitPattern != 0 {
try visitor.visitSingularFloatField(value: self.channelUtilization, fieldNumber: 2)
}
- if self.airUtilTx != 0 {
+ if self.airUtilTx.bitPattern != 0 {
try visitor.visitSingularFloatField(value: self.airUtilTx, fieldNumber: 3)
}
if self.numPacketsTx != 0 {
@@ -1666,7 +1626,7 @@ extension Nau7802Config: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementa
if self.zeroOffset != 0 {
try visitor.visitSingularInt32Field(value: self.zeroOffset, fieldNumber: 1)
}
- if self.calibrationFactor != 0 {
+ if self.calibrationFactor.bitPattern != 0 {
try visitor.visitSingularFloatField(value: self.calibrationFactor, fieldNumber: 2)
}
try unknownFields.traverse(visitor: &visitor)
diff --git a/MeshtasticProtobufs/Sources/meshtastic/xmodem.pb.swift b/MeshtasticProtobufs/Sources/meshtastic/xmodem.pb.swift
index 1f41fe0b..89d0097c 100644
--- a/MeshtasticProtobufs/Sources/meshtastic/xmodem.pb.swift
+++ b/MeshtasticProtobufs/Sources/meshtastic/xmodem.pb.swift
@@ -20,7 +20,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
typealias Version = _2
}
-public struct XModem {
+public struct XModem: @unchecked Sendable {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
@@ -35,7 +35,7 @@ public struct XModem {
public var unknownFields = SwiftProtobuf.UnknownStorage()
- public enum Control: SwiftProtobuf.Enum {
+ public enum Control: SwiftProtobuf.Enum, Swift.CaseIterable {
public typealias RawValue = Int
case nul // = 0
case soh // = 1
@@ -79,34 +79,23 @@ public struct XModem {
}
}
+ // The compiler won't synthesize support with the UNRECOGNIZED case.
+ public static let allCases: [XModem.Control] = [
+ .nul,
+ .soh,
+ .stx,
+ .eot,
+ .ack,
+ .nak,
+ .can,
+ .ctrlz,
+ ]
+
}
public init() {}
}
-#if swift(>=4.2)
-
-extension XModem.Control: CaseIterable {
- // The compiler won't synthesize support with the UNRECOGNIZED case.
- public static let allCases: [XModem.Control] = [
- .nul,
- .soh,
- .stx,
- .eot,
- .ack,
- .nak,
- .can,
- .ctrlz,
- ]
-}
-
-#endif // swift(>=4.2)
-
-#if swift(>=5.5) && canImport(_Concurrency)
-extension XModem: @unchecked Sendable {}
-extension XModem.Control: @unchecked Sendable {}
-#endif // swift(>=5.5) && canImport(_Concurrency)
-
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "meshtastic"
diff --git a/protobufs b/protobufs
index b6237629..0acaec6e 160000
--- a/protobufs
+++ b/protobufs
@@ -1 +1 @@
-Subproject commit b623762940ebdb1887a3b31b86f4d9cdaa7e6ecf
+Subproject commit 0acaec6eff00e748beeae89148093221f131cd9c